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])