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