def execute(self, async_conn):
"""Executes a query within an asyncronous psycopg2 connection
"""
if self.status == self.STATUS_CANCELLED:
return
self.status = self.STATUS_EXECUTING
# Async variant of Connection.execute() in storm/database.py
state = State()
statement = compile(self.expr, state)
stmt = convert_param_marks(statement, "?", "%s")
self._async_cursor = async_conn.cursor()
self._async_conn = async_conn
# This is postgres specific, see storm/databases/postgres.py
self._statement = stmt.encode('utf-8')
self._parameters = tuple(Connection.to_database(state.parameters))
trace("connection_raw_execute", self._conn,
self._async_cursor, self._statement, self._parameters)
self._async_cursor.execute(self._statement,
self._parameters)
# This can happen if another thread cancelled this while the cursor was
# executing. In that case, it is not interested in the retval anymore
if self.status == self.STATUS_CANCELLED:
return
self.status = self.STATUS_FINISHED
GLib.idle_add(self._on_finish)
def execute(self, statement, params=None, noresult=False):
"""NOTE: this is being overriden completely because the
original from the base class expects to receive only a
raw_cursor from raw_execute, and we need to receive also the
rowid, as we cannot set it in the cursor object
Execute a statement with the given parameters.
@type statement: L{Expr} or C{str}
@param statement: The statement to execute. It will be
compiled if necessary.
@param noresult: If True, no result will be returned.
@raise DisconnectionError: Raised when the connection is lost.
Reconnection happens automatically on rollback.
@return: The result of C{self.result_factory}, or None if
C{noresult} is True.
"""
if self._closed:
raise ClosedError("Connection is closed")
self._ensure_connected()
if isinstance(statement, Expr):
if params is not None:
raise ValueError("Can't pass parameters with expressions")
state = State()
statement = self.compile(statement, state)
params = state.parameters
statement = convert_param_marks(statement, "?", self.param_mark)
raw_cursor, rowid = self.raw_execute(statement, params)
if noresult:
self._check_disconnect(raw_cursor.close)
return None
return self.result_factory(self, raw_cursor, rowid)
def execute(self, async_conn):
"""Executes a query within an asyncronous psycopg2 connection
"""
if self.status == self.STATUS_CANCELLED:
return
self.status = self.STATUS_EXECUTING
# Async variant of Connection.execute() in storm/database.py
state = State()
statement = compile(self.expr, state)
stmt = convert_param_marks(statement, "?", "%s")
self._async_cursor = async_conn.cursor()
self._async_conn = async_conn
# This is postgres specific, see storm/databases/postgres.py
self._statement = stmt.encode('utf-8')
self._parameters = tuple(Connection.to_database(state.parameters))
trace("connection_raw_execute", self._conn,
self._async_cursor, self._statement, self._parameters)
self._async_cursor.execute(self._statement,
self._parameters)
# This can happen if another thread cancelled this while the cursor was
# executing. In that case, it is not interested in the retval anymore
if self.status == self.STATUS_CANCELLED:
return
self.status = self.STATUS_FINISHED
glib.idle_add(self._on_finish)
def execute(self, async_conn):
"""Executes a query within an asyncronous psycopg2 connection
"""
# Async variant of Connection.execute() in storm/database.py
state = State()
statement = compile(self.expr, state)
stmt = convert_param_marks(statement, "?", "%s")
self._async_cursor = async_conn.cursor()
self._async_conn = async_conn
# This is postgres specific, see storm/databases/postgres.py
self._statement = stmt.encode("utf-8")
self._parameters = tuple(Connection.to_database(state.parameters))
trace("connection_raw_execute", self._conn, self._async_cursor, self._statement, self._parameters)
self._async_cursor.execute(self._statement, self._parameters)
def execute(self, async_conn):
"""Executes a query within an asyncronous psycopg2 connection
"""
# Async variant of Connection.execute() in storm/database.py
state = State()
statement = compile(self.expr, state)
stmt = convert_param_marks(statement, "?", "%s")
self._async_cursor = async_conn.cursor()
self._async_conn = async_conn
# This is postgres specific, see storm/databases/postgres.py
self._statement = stmt.encode('utf-8')
self._parameters = tuple(Connection.to_database(state.parameters))
trace("connection_raw_execute", self._conn, self._async_cursor,
self._statement, self._parameters)
self._async_cursor.execute(self._statement, self._parameters)
def connection_raw_execute(self, connection, raw_cursor,
statement, params):
statement_to_log = statement
if params:
# There are some bind parameters so we want to insert them into
# the sql statement so we can log the statement.
query_params = list(connection.to_database(params))
if connection.param_mark == '%s':
# Double the %'s in the string so that python string formatting
# can restore them to the correct number. Note that %s needs to
# be preserved as that is where we are substituting values in.
quoted_statement = re.sub(
"%%%", "%%%%", re.sub("%([^s])", r"%%\1", statement))
else:
# Double all the %'s in the statement so that python string
# formatting can restore them to the correct number. Any %s in
# the string should be preserved because the param_mark is not
# %s.
quoted_statement = re.sub("%", "%%", statement)
quoted_statement = convert_param_marks(
quoted_statement, connection.param_mark, "%s")
# We need to massage the query parameters a little to deal with
# string parameters which represent encoded binary data.
render_params = []
for param in query_params:
if isinstance(param, six.text_type):
if six.PY3:
render_params.append(ascii(param))
else:
render_params.append(repr(param.encode('utf8')))
else:
render_params.append(repr(param))
try:
statement_to_log = quoted_statement % tuple(render_params)
except TypeError:
statement_to_log = \
"Unformattable query: %r with params %r." % (
statement, query_params)
self._expanded_raw_execute(connection, raw_cursor, statement_to_log)
def connection_raw_execute(self, connection, raw_cursor,
statement, params):
statement_to_log = statement
if params:
# There are some bind parameters so we want to insert them into
# the sql statement so we can log the statement.
query_params = list(connection.to_database(params))
if connection.param_mark == '%s':
# Double the %'s in the string so that python string formatting
# can restore them to the correct number. Note that %s needs to
# be preserved as that is where we are substituting values in.
quoted_statement = re.sub(
"%%%", "%%%%", re.sub("%([^s])", r"%%\1", statement))
else:
# Double all the %'s in the statement so that python string
# formatting can restore them to the correct number. Any %s in
# the string should be preserved because the param_mark is not
# %s.
quoted_statement = re.sub("%", "%%", statement)
quoted_statement = convert_param_marks(
quoted_statement, connection.param_mark, "%s")
# We need to massage the query parameters a little to deal with
# string parameters which represent encoded binary data.
render_params = []
for param in query_params:
if isinstance(param, unicode):
render_params.append(repr(param.encode('utf8')))
else:
render_params.append(repr(param))
try:
statement_to_log = quoted_statement % tuple(render_params)
except TypeError:
statement_to_log = \
"Unformattable query: %r with params %r." % (
statement, query_params)
self._expanded_raw_execute(connection, raw_cursor, statement_to_log)
