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 __init__(self, dbh, sql=None, force=None, blob_map=None): try: sql_base.Cursor.__init__(self, dbh=dbh, sql=sql, force=force) self._type_mapping = ORACLE_TYPE_MAPPING self.blob_map = blob_map except sql_base.SQLSchemaError: e = sys.exc_info()[1] (errno, errmsg) = e.errno, e.errmsg if 900 <= errno <= 999: # Per Oracle's documentation, SQL parsing error raise_with_tb( sql_base.SQLStatementPrepareError(self.dbh, errmsg, self.sql), sys.exc_info()[2]) # XXX: we should be handling the lost connection cases # in here too, but we don't get that many of these and # besides, this is much harder to get right # XXX: Normally we expect the e.args to include a dump of # the SQL code we just passed in since we're dealing with # an OracleError. I hope this is always the case, of not, # we'll have to log the sql code here raise_with_tb(rhnException("Can not prepare statement", e.args), sys.exc_info()[2])
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 Cursor(sql_base.Cursor): """ PostgreSQL specific wrapper over sql_base.Cursor. """ def __init__(self, dbh=None, sql=None, force=None, blob_map=None): sql_base.Cursor.__init__(self, dbh, sql, force) self.blob_map = blob_map # Accept Oracle style named query params, but convert for python-pgsql # under the hood: temp_sql = "" if self.sql is not None: temp_sql = self.sql self.sql = convert_named_query_params(temp_sql) def _prepare_sql(self): cursor = self.dbh.cursor() return cursor 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) except psycopg2.ProgrammingError, e: raise sql_base.SQLStatementPrepareError(self.dbh, e.pgerror, self.sql)
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]