def _function(self, name, ret_type):
try:
c = self.dbh.cursor()
except cx_Oracle.DatabaseError, error:
e = error[0]
raise sql_base.SQLSchemaError(e.code, e.message,
e.context), None, sys.exc_info()[2]
def __call__(self, *args):
log_debug(2, self.name, args)
# Buildup a string for the positional arguments to the procedure:
positional_args = ""
i = 1
for arg in args:
if len(positional_args) == 0:
positional_args = "%s"
else:
positional_args = positional_args + ", %s"
i += 1
query = "SELECT %s(%s)" % (self.name, positional_args)
log_debug(2, query, args)
try:
ret = self.cursor.execute(query, args)
except psycopg2.Error:
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)
if self.ret_type is None:
return ret
else:
return self.cursor.fetchone()[0]
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 __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 _function(self, name, ret_type):
try:
c = self.dbh.cursor()
except cx_Oracle.DatabaseError:
error = sys.exc_info()[1]
e = error[0]
raise_with_tb(sql_base.SQLSchemaError(e.code, e.message, e.context), sys.exc_info()[2])
return Function(name, c, ret_type)
def procedure(self, name):
try:
c = self.dbh.cursor()
except cx_Oracle.DatabaseError:
error = sys.exc_info()[1]
e = error[0]
raise_with_tb(sql_base.SQLSchemaError(e.code, e.message, e.context), sys.exc_info()[2])
# Pass the cursor in so we can close it after execute()
return self._procedure_class(name, c)
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
def _execute_wrapper(self, function, *p, **kw):
params = ','.join(["%s: %s" % (key, 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:
for blob_var in self.blob_map.keys():
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)
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 _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])
