1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
|
"""Core event interfaces."""
from sqlalchemy import event
class DDLEvents(event.Events):
"""
Define create/drop event listers for schema objects.
See also:
:mod:`sqlalchemy.event`
"""
def on_before_create(self, target, connection, **kw):
""" """
def on_after_create(self, target, connection, **kw):
""" """
def on_before_drop(self, target, connection, **kw):
""" """
def on_after_drop(self, target, connection, **kw):
""" """
class PoolEvents(event.Events):
"""Available events for :class:`.Pool`.
The methods here define the name of an event as well
as the names of members that are passed to listener
functions.
e.g.::
from sqlalchemy import events
def my_on_checkout(dbapi_conn, connection_rec, connection_proxy):
"handle an on checkout event"
events.listen(my_on_checkout, 'on_checkout', Pool)
In addition to the :class:`.Pool` class and :class:`.Pool` instances,
:class:`.PoolEvents` also accepts :class:`.Engine` objects and
the :class:`.Engine` class as targets, which will be resolved
to the ``.pool`` attribute of the given engine or the :class:`.Pool`
class.
"""
@classmethod
def accept_with(cls, target):
from sqlalchemy.engine import Engine
from sqlalchemy.pool import Pool
if isinstance(target, type):
if issubclass(target, Engine):
return Pool
elif issubclass(target, Pool):
return target
elif isinstance(target, Engine):
return target.pool
else:
return target
def on_connect(self, dbapi_connection, connection_record):
"""Called once for each new DB-API connection or Pool's ``creator()``.
:param dbapi_con:
A newly connected raw DB-API connection (not a SQLAlchemy
``Connection`` wrapper).
:param con_record:
The ``_ConnectionRecord`` that persistently manages the connection
"""
def on_first_connect(self, dbapi_connection, connection_record):
"""Called exactly once for the first DB-API connection.
:param dbapi_con:
A newly connected raw DB-API connection (not a SQLAlchemy
``Connection`` wrapper).
:param con_record:
The ``_ConnectionRecord`` that persistently manages the connection
"""
def on_checkout(self, dbapi_connection, connection_record, connection_proxy):
"""Called when a connection is retrieved from the Pool.
:param dbapi_con:
A raw DB-API connection
:param con_record:
The ``_ConnectionRecord`` that persistently manages the connection
:param 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.
"""
def on_checkin(self, dbapi_connection, connection_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.)
:param dbapi_con:
A raw DB-API connection
:param con_record:
The ``_ConnectionRecord`` that persistently manages the connection
"""
class EngineEvents(event.Events):
"""Available events for :class:`.Engine`."""
@classmethod
def listen(cls, fn, identifier, target):
from sqlalchemy.engine.base import Connection, \
_listener_connection_cls
if target.Connection is Connection:
target.Connection = _listener_connection_cls(
Connection,
target.dispatch)
event.Events.listen(fn, identifier, target)
def on_before_execute(self, conn, clauseelement, multiparams, params):
"""Intercept high level execute() events."""
def on_after_execute(self, conn, clauseelement, multiparams, params, result):
"""Intercept high level execute() events."""
def on_before_cursor_execute(self, conn, cursor, statement,
parameters, context, executemany):
"""Intercept low-level cursor execute() events."""
def on_after_cursor_execute(self, conn, cursor, statement,
parameters, context, executemany):
"""Intercept low-level cursor execute() events."""
def on_begin(self, conn):
"""Intercept begin() events."""
def on_rollback(self, conn):
"""Intercept rollback() events."""
def on_commit(self, conn):
"""Intercept commit() events."""
def on_savepoint(self, conn, name=None):
"""Intercept savepoint() events."""
def on_rollback_savepoint(self, conn, name, context):
"""Intercept rollback_savepoint() events."""
def on_release_savepoint(self, conn, name, context):
"""Intercept release_savepoint() events."""
def on_begin_twophase(self, conn, xid):
"""Intercept begin_twophase() events."""
def on_prepare_twophase(self, conn, xid):
"""Intercept prepare_twophase() events."""
def on_rollback_twophase(self, conn, xid, is_prepared):
"""Intercept rollback_twophase() events."""
def on_commit_twophase(self, conn, xid, is_prepared):
"""Intercept commit_twophase() events."""
|
