def __call__(self, *args):
"""
Wrap the __call__ method from the parent class to catch Oracle specific
actions and convert them to something generic.
"""
log_debug(2, self.name, args)
retval = None
try:
retval = self._call_proc(args)
except cx_Oracle.DatabaseError:
e = sys.exc_info()[1]
if not hasattr(e, "args"):
raise_with_tb(sql_base.SQLError(self.name, args),
sys.exc_info()[2])
elif 20000 <= e[
0].code <= 20999: # error codes we know we raise as schema errors
raise_with_tb(sql_base.SQLSchemaError(e[0].code, str(e[0])),
sys.exc_info()[2])
raise_with_tb(sql_base.SQLError(e[0].code, str(e[0])),
sys.exc_info()[2])
except cx_Oracle.NotSupportedError:
error = sys.exc_info()[1]
raise_with_tb(sql_base.SQLError(*error.args), sys.exc_info()[2])
return retval
def _execute_(self, args, kwargs):
"""
Oracle specific execution of the query.
"""
# TODO: args appears unused, raise exception if we see any?
# Only copy the arguments we're interested in
_p = UserDictCase(kwargs)
params = {}
# Check that all required parameters were provided:
# NOTE: bindnames() is Oracle specific:
for k in self._real_cursor.bindnames():
if not _p.has_key(k):
# Raise the fault ourselves
raise sql_base.SQLError(1008, 'Not all variables bound', k)
params[k] = to_string(_p[k])
# cx_Oracle expects the first arg to be the statement and no
# positional args:
try:
self._real_cursor.execute(*(None, ), **params)
except cx_Oracle.OperationalError:
e = sys.exc_info()[1]
raise sql_base.SQLError("Cannot execute SQL statement: %s" % str(e))
self.description = self._real_cursor.description
return self._real_cursor.rowcount
def _execute_wrapper(self, function, *p, **kw):
params = ','.join([
"%s: %s" % (repr(key), repr(value))
for key, value in list(kw.items())
])
log_debug(
5, "Executing SQL: \"%s\" with bind params: {%s}" %
(self.sql, params))
if self.sql is None:
raise rhnException("Cannot execute empty cursor")
if self.blob_map:
blob_content = {}
for orig_blob_var in list(self.blob_map.keys()):
new_blob_var = orig_blob_var + '_blob'
blob_content[new_blob_var] = kw[orig_blob_var]
kw[new_blob_var] = self.var(cx_Oracle.BLOB)
del kw[orig_blob_var]
modified_params = self._munge_args(kw)
try:
retval = function(*p, **kw)
except self.OracleError:
e = sys.exc_info()[1]
ret = self._get_oracle_error_info(e)
if isinstance(ret, usix.StringType):
raise_with_tb(sql_base.SQLError(self.sql, p, kw, ret),
sys.exc_info()[2])
(errno, errmsg) = ret[:2]
if 900 <= errno <= 999:
# Per Oracle's documentation, SQL parsing error
raise_with_tb(
sql_base.SQLStatementPrepareError(errno, errmsg, self.sql),
sys.exc_info()[2])
if errno == 1475: # statement needs to be reparsed; force a prepare again
if self.reparsed: # useless, tried that already. give up
log_error("Reparsing cursor did not fix it", self.sql)
args = (
"Reparsing tried and still got this", ) + tuple(ret)
raise_with_tb(sql_base.SQLError(*args), sys.exc_info()[2])
self._real_cursor = self.dbh.prepare(self.sql)
self.reparsed = 1
self._execute_wrapper(function, *p, **kw)
elif 20000 <= errno <= 20999: # error codes we know we raise as schema errors
raise_with_tb(sql_base.SQLSchemaError(*ret), sys.exc_info()[2])
raise_with_tb(sql_base.SQLError(*ret), sys.exc_info()[2])
except ValueError:
# this is not good.Let the user know
raise
else:
self.reparsed = 0 # reset the reparsed counter
if self.blob_map:
for blob_var, content in blob_content.items():
kw[blob_var].getvalue().write(content)
# Munge back the values
self._unmunge_args(kw, modified_params)
return retval
class Procedure(sql_base.Procedure):
OracleError = cx_Oracle.DatabaseError
def __init__(self, name, cursor):
sql_base.Procedure.__init__(self, name, cursor)
self._type_mapping = ORACLE_TYPE_MAPPING
def __call__(self, *args):
"""
Wrap the __call__ method from the parent class to catch Oracle specific
actions and convert them to something generic.
"""
log_debug(2, self.name, args)
retval = None
try:
retval = self._call_proc(args)
except cx_Oracle.DatabaseError, e:
if not hasattr(e, "args"):
raise sql_base.SQLError(self.name,
args), None, sys.exc_info()[2]
elif 20000 <= e[
0].code <= 20999: # error codes we know we raise as schema errors
raise sql_base.SQLSchemaError(e[0].code, str(
e[0])), None, sys.exc_info()[2]
raise sql_base.SQLError(e[0].code,
str(e[0])), None, sys.exc_info()[2]
except cx_Oracle.NotSupportedError, error:
raise sql_base.SQLError(*error.args), None, sys.exc_info()[2]
def _execute_wrapper(self, function, *p, **kw):
params = ','.join(["%s: %s" % (key, value) for key, value
in list(kw.items())])
log_debug(5, "Executing SQL: \"%s\" with bind params: {%s}"
% (self.sql, params))
if self.sql is None:
raise rhnException("Cannot execute empty cursor")
if self.blob_map:
for blob_var in list(self.blob_map.keys()):
kw[blob_var] = BufferType(kw[blob_var])
try:
retval = function(*p, **kw)
except psycopg2.InternalError:
e = sys.exc_info()[1]
error_code = 99999
m = re.match('ERROR: +-([0-9]+)', e.pgerror)
if m:
error_code = int(m.group(1))
raise sql_base.SQLSchemaError(error_code, e.pgerror, e)
except psycopg2.ProgrammingError:
e = sys.exc_info()[1]
raise sql_base.SQLStatementPrepareError(self.dbh, e.pgerror, self.sql)
except KeyError:
e = sys.exc_info()[1]
raise sql_base.SQLError("Unable to bound the following variable(s): %s"
% (string.join(e.args, " ")))
return retval
def _execute_wrapper(self, function, *p, **kw):
params = ','.join(
["%s: %s" % (repr(key), repr(value)) for key, value in kw.items()])
log_debug(
5, "Executing SQL: \"%s\" with bind params: {%s}" %
(self.sql, params))
if self.sql is None:
raise rhnException("Cannot execute empty cursor")
if self.blob_map:
blob_content = {}
for orig_blob_var in self.blob_map.keys():
new_blob_var = orig_blob_var + '_blob'
blob_content[new_blob_var] = kw[orig_blob_var]
kw[new_blob_var] = self.var(cx_Oracle.BLOB)
del kw[orig_blob_var]
modified_params = self._munge_args(kw)
try:
retval = apply(function, p, kw)
except self.OracleError, e:
ret = self._get_oracle_error_info(e)
if isinstance(ret, types.StringType):
raise sql_base.SQLError(self.sql, p, kw,
ret), None, sys.exc_info()[2]
(errno, errmsg) = ret[:2]
if 900 <= errno <= 999:
# Per Oracle's documentation, SQL parsing error
raise sql_base.SQLStatementPrepareError(
errno, errmsg, self.sql), None, sys.exc_info()[2]
if errno == 1475: # statement needs to be reparsed; force a prepare again
if self.reparsed: # useless, tried that already. give up
log_error("Reparsing cursor did not fix it", self.sql)
args = (
"Reparsing tried and still got this", ) + tuple(ret)
raise sql_base.SQLError(*args), None, sys.exc_info()[2]
self._real_cursor = self.dbh.prepare(self.sql)
self.reparsed = 1
apply(self._execute_wrapper, (function, ) + p, kw)
elif 20000 <= errno <= 20999: # error codes we know we raise as schema errors
raise sql_base.SQLSchemaError(*ret), None, sys.exc_info()[2]
raise apply(sql_base.SQLError, ret), None, sys.exc_info()[2]
def _execute_(self, args, kwargs):
"""
PostgreSQL specific execution of the query.
"""
params = UserDictCase(kwargs)
try:
self._real_cursor.execute(self.sql, params)
except psycopg2.OperationalError:
e = sys.exc_info()[1]
raise sql_base.SQLError("Cannot execute SQL statement: %s" % str(e))
self.description = self._real_cursor.description
return self._real_cursor.rowcount
def _build_exception(self, error):
ret = self._get_oracle_error_info(error)
if isinstance(ret, types.StringType):
return sql_base.SQLError(ret)
return sql_base.SQLSchemaError(ret[0], ret[1])
kw[blob_var] = buffer(kw[blob_var])
try:
retval = function(*p, **kw)
except psycopg2.InternalError, e:
error_code = 99999
m = re.match('ERROR: +-([0-9]+)', e.pgerror)
if m:
error_code = int(m.group(1))
raise sql_base.SQLSchemaError(error_code, e.pgerror, e)
except psycopg2.ProgrammingError, e:
raise sql_base.SQLStatementPrepareError(self.dbh, e.pgerror,
self.sql)
except KeyError, e:
raise sql_base.SQLError(
"Unable to bound the following variable(s): %s" %
(string.join(e.args, " ")))
return retval
def _execute_(self, args, kwargs):
"""
PostgreSQL specific execution of the query.
"""
params = UserDictCase(kwargs)
self._real_cursor.execute(self.sql, params)
self.description = self._real_cursor.description
return self._real_cursor.rowcount
def _executemany(self, *args, **kwargs):
if not kwargs:
return 0
