SQLAlchemy 1.3 Documentation
SQLAlchemy Core
- SQL Expression Language Tutorial
- SQL Statements and Expressions API
- Schema Definition Language
- Column and Data Types
- Engine and Connection Use
- Core API Basics
- Events
- Runtime Inspection API
- Deprecated Event Interfaces¶
- Execution, Connection and Cursor Events
ConnectionProxy
ConnectionProxy.begin()
ConnectionProxy.begin_twophase()
ConnectionProxy.commit()
ConnectionProxy.commit_twophase()
ConnectionProxy.cursor_execute()
ConnectionProxy.execute()
ConnectionProxy.prepare_twophase()
ConnectionProxy.release_savepoint()
ConnectionProxy.rollback()
ConnectionProxy.rollback_savepoint()
ConnectionProxy.rollback_twophase()
ConnectionProxy.savepoint()
- Connection Pool Events
- Execution, Connection and Cursor Events
- Core Exceptions
- Core Internals
Project Versions
- Previous: Runtime Inspection API
- Next: Core Exceptions
- Up: Home
- On this page:
- Deprecated Event Interfaces
- Execution, Connection and Cursor Events
ConnectionProxy
ConnectionProxy.begin()
ConnectionProxy.begin_twophase()
ConnectionProxy.commit()
ConnectionProxy.commit_twophase()
ConnectionProxy.cursor_execute()
ConnectionProxy.execute()
ConnectionProxy.prepare_twophase()
ConnectionProxy.release_savepoint()
ConnectionProxy.rollback()
ConnectionProxy.rollback_savepoint()
ConnectionProxy.rollback_twophase()
ConnectionProxy.savepoint()
- Connection Pool Events
- Execution, Connection and Cursor Events
Deprecated Event Interfaces¶
This section describes the class-based core event interface introduced in SQLAlchemy 0.5. The ORM analogue is described at Deprecated ORM Event Interfaces.
Deprecated since version 0.7: The new event system described in Events replaces the extension/proxy/listener system, providing a consistent interface to all events without the need for subclassing.
Execution, Connection and Cursor Events¶
Object Name | Description |
---|---|
Allows interception of statement execution by Connections. |
- class sqlalchemy.interfaces.ConnectionProxy¶
Allows interception of statement execution by Connections.
Deprecated since version 0.7:
ConnectionProxy
is deprecated and will be removed in a future release. Please refer tolisten()
in conjunction with theConnectionEvents
listener interface.Either or both of the
execute()
andcursor_execute()
may be implemented to intercept compiled statement and cursor level executions, e.g.:class MyProxy(ConnectionProxy): def execute(self, conn, execute, clauseelement, *multiparams, **params): print "compiled statement:", clauseelement return execute(clauseelement, *multiparams, **params) def cursor_execute(self, execute, cursor, statement, parameters, context, executemany): print "raw statement:", statement return execute(cursor, statement, parameters, context)
The
execute
argument is a function that will fulfill the default execution behavior for the operation. The signature illustrated in the example should be used.The proxy is installed into an
Engine
via theproxy
argument:Members
begin(), begin_twophase(), commit(), commit_twophase(), cursor_execute(), execute(), prepare_twophase(), release_savepoint(), rollback(), rollback_savepoint(), rollback_twophase(), savepoint()
e = create_engine('someurl://', proxy=MyProxy())
-
method
sqlalchemy.interfaces.ConnectionProxy.
begin(conn, begin)¶ Intercept begin() events.
-
method
sqlalchemy.interfaces.ConnectionProxy.
begin_twophase(conn, begin_twophase, xid)¶ Intercept begin_twophase() events.
-
method
sqlalchemy.interfaces.ConnectionProxy.
commit(conn, commit)¶ Intercept commit() events.
-
method
sqlalchemy.interfaces.ConnectionProxy.
commit_twophase(conn, commit_twophase, xid, is_prepared)¶ Intercept commit_twophase() events.
-
method
sqlalchemy.interfaces.ConnectionProxy.
cursor_execute(execute, cursor, statement, parameters, context, executemany)¶ Intercept low-level cursor execute() events.
-
method
sqlalchemy.interfaces.ConnectionProxy.
execute(conn, execute, clauseelement, *multiparams, **params)¶ Intercept high level execute() events.
-
method
sqlalchemy.interfaces.ConnectionProxy.
prepare_twophase(conn, prepare_twophase, xid)¶ Intercept prepare_twophase() events.
-
method
sqlalchemy.interfaces.ConnectionProxy.
release_savepoint(conn, release_savepoint, name, context)¶ Intercept release_savepoint() events.
-
method
sqlalchemy.interfaces.ConnectionProxy.
rollback(conn, rollback)¶ Intercept rollback() events.
-
method
sqlalchemy.interfaces.ConnectionProxy.
rollback_savepoint(conn, rollback_savepoint, name, context)¶ Intercept rollback_savepoint() events.
-
method
sqlalchemy.interfaces.ConnectionProxy.
rollback_twophase(conn, rollback_twophase, xid, is_prepared)¶ Intercept rollback_twophase() events.
-
method
sqlalchemy.interfaces.ConnectionProxy.
savepoint(conn, savepoint, name=None)¶ Intercept savepoint() events.
-
method
Connection Pool Events¶
Object Name | Description |
---|---|
Hooks into the lifecycle of connections in a |
- class sqlalchemy.interfaces.PoolListener¶
Hooks into the lifecycle of connections in a
Pool
.Deprecated since version 0.7:
PoolListener
is deprecated and will be removed in a future release. Please refer tolisten()
in conjunction with thePoolEvents
listener interface.Usage:
class MyListener(PoolListener): def connect(self, dbapi_con, con_record): '''perform connect operations''' # etc. # create a new pool with a listener p = QueuePool(..., listeners=[MyListener()]) # add a listener after the fact p.add_listener(MyListener()) # usage with create_engine() e = create_engine("url://", listeners=[MyListener()])
All of the standard connection
Pool
types can accept event listeners for key connection lifecycle events: creation, pool check-out and check-in. There are no events fired when a connection closes.For any given DB-API connection, there will be one
connect
event, n number ofcheckout
events, and either n or n - 1checkin
events. (If aConnection
is detached from its pool via thedetach()
method, it won’t be checked back in.)These are low-level events for low-level objects: raw Python DB-API connections, without the conveniences of the SQLAlchemy
Connection
wrapper,Dialect
services orClauseElement
execution. If you execute SQL through the connection, explicitly closing all cursors and other resources is recommended.Events also receive a
_ConnectionRecord
, a long-lived internalPool
object that basically represents a “slot” in the connection pool._ConnectionRecord
objects have one public attribute of note:info
, a dictionary whose contents are scoped to the lifetime of the DB-API connection managed by the record. You can use this shared storage area however you like.Members
There is no need to subclass
PoolListener
to handle events. Any class that implements one or more of these methods can be used as a pool listener. ThePool
will inspect the methods provided by a listener object and add the listener to one or more internal event queues based on its capabilities. In terms of efficiency and function call overhead, you’re much better off only providing implementations for the hooks you’ll be using.-
method
sqlalchemy.interfaces.PoolListener.
checkin(dbapi_con, con_record)¶ Called when a connection returns to the pool.
Note that the connection may be closed, and may be None if the connection has been invalidated.
checkin
will not be called for detached connections. (They do not return to the pool.)- dbapi_con
A raw DB-API connection
- con_record
The
_ConnectionRecord
that persistently manages the connection
-
method
sqlalchemy.interfaces.PoolListener.
checkout(dbapi_con, con_record, con_proxy)¶ Called when a connection is retrieved from the Pool.
- dbapi_con
A raw DB-API connection
- con_record
The
_ConnectionRecord
that persistently manages the connection- con_proxy
The
_ConnectionFairy
which manages the connection for the span of the current checkout.
If you raise an
exc.DisconnectionError
, the current connection will be disposed and a fresh connection retrieved. Processing of all checkout listeners will abort and restart using the new connection.
-
method
sqlalchemy.interfaces.PoolListener.
connect(dbapi_con, con_record)¶ Called once for each new DB-API connection or Pool’s
creator()
.- dbapi_con
A newly connected raw DB-API connection (not a SQLAlchemy
Connection
wrapper).- con_record
The
_ConnectionRecord
that persistently manages the connection
-
method
sqlalchemy.interfaces.PoolListener.
first_connect(dbapi_con, con_record)¶ Called exactly once for the first DB-API connection.
- dbapi_con
A newly connected raw DB-API connection (not a SQLAlchemy
Connection
wrapper).- con_record
The
_ConnectionRecord
that persistently manages the connection
-
method
flambé! the dragon and The Alchemist image designs created and generously donated by Rotem Yaari.
Created using Sphinx 7.2.6. Documentation last generated: Sat 06 Jan 2024 12:15:55 PM