Current File : //proc/self/root/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyc
�
��4]c @� sr d d l m Z d d l Z d d l Z d d l m Z d d l m Z d d l m Z d d l m
Z
d d l m Z d d
l m Z d d l m Z d d l m
Z
d d l m Z d
e f d � � YZ d e f d � � YZ d e f d � � YZ d e f d � � YZ d e f d � � YZ d e f d � � YZ d e e j f d � � YZ d e f d � � YZ d S( i����( t with_statementNi ( t Connectable( t ExceptionContext( t _distill_paramsi ( t exc( t
interfaces( t log( t util( t schemat
Connectionc B� s~ e Z d Z e j d9 � Z d9 e d9 d9 d9 d9 d � Z d � Z e
d � � Z d � Z d � Z
d � Z d � Z d � Z e
d � � Z e
d
� � Z e
d � � Z d � Z e
d
� � Z d � Z e
d � � Z e
d � � Z e
d � � Z d � Z d � Z d9 d � Z d � Z d � Z d � Z d9 d � Z d � Z! e d � Z" e d � Z# d � Z$ d � Z% d � Z& e d � Z' d9 d � Z( d! � Z) d" � Z* d# � Z+ d$ � Z, d% � Z- d& � Z. d' � Z/ d( � Z0 d) � Z1 d* � Z2 d+ � Z3 d, � Z4 d- � Z5 d. � Z6 d/ � Z7 d0 � Z8 d1 � Z9 d9 d2 � Z: d3 � Z; e Z< e Z= d4 � Z> e? d5 � � Z@ d6 � ZA d7 � ZB d8 � ZC RS(: s: Provides high-level functionality for a wrapped DB-API connection.
Provides execution support for string-based SQL statements as well as
:class:`.ClauseElement`, :class:`.Compiled` and :class:`.DefaultGenerator`
objects. Provides a :meth:`begin` method to return :class:`.Transaction`
objects.
The Connection object is **not** thread-safe. While a Connection can be
shared among threads using properly synchronized access, it is still
possible that the underlying DBAPI connection may not support shared
access between threads. Check the DBAPI documentation for details.
The Connection object represents a single dbapi connection checked out
from the connection pool. In this state, the connection pool has no affect
upon the connection, including its expiration or timeout state. For the
connection pool to properly manage connections, connections should be
returned to the connection pool (i.e. ``connection.close()``) whenever the
connection is not in use.
.. index::
single: thread safety; Connection
c C� sn | | _ | j | _ | | _ | d k | _ | r~ | | _ | | _ | j | _ t | _ | | _
| j | _ | j | _ n� | d k r� | n | j
� | _ d | _ d | _ | | _ t | _ t | _ | j j � | _ | d k r| j
j | j
� | _
n | p | d k o | j | _ | s0t � | j | _ | j sQ| j j rj| j
j | | j � n d S( s� Construct a new Connection.
The constructor here is not public and is only called only by an
:class:`.Engine`. See :meth:`.Engine.connect` and
:meth:`.Engine.contextual_connect` methods.
i N( t enginet dialectt _Connection__branch_fromt Nonet _Connection__brancht _Connection__connectiont _execution_optionst _echot Falset should_close_with_resultt dispatcht _has_eventst schema_for_objectt raw_connectiont _Connection__transactiont _Connection__savepoint_seqt _Connection__invalidt Truet _Connection__can_reconnectt _should_log_infot _joint AssertionErrort engine_connect( t selfR
t
connectiont close_with_resultt _branch_fromR t _dispatchR ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt __init__E s8
c C� sT | j r | j j � S| j j | j | j d | d | j d | j d | j �Sd S( s� Return a new Connection which references this Connection's
engine and connection; but does not have close_with_result enabled,
and also whose close() method does nothing.
The Core uses this very sparingly, only in the case of
custom SQL default functions that are to be INSERTed as the
primary key of a row where we need to get the value back, so we have
to invoke it distinctly - this is a very uncommon case.
Userland code accesses _branch() when the connect() or
contextual_connect() methods are called. The branched connection
acts as much as possible like the parent, except that it stays
connected when a close() event occurs.
R$ R R R% N( R t _branchR
t _connection_clsR R R R ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR' s
c C� s | j r | j S| Sd S( s� return the 'root' connection.
Returns 'self' if this connection is not a branch, else
returns the root connection from which we ultimately branched.
N( R ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _root� s c C� s+ | j j | j � } | j j � | _ | S( s3 Create a shallow copy of this Connection.
( t __class__t __new__t __dict__t copy( R! t c( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _clone� s c C� s | S( N( ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt __enter__� s c C� s | j � d S( N( t close( R! t type_t valuet traceback( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt __exit__� s c K� sc | j � } | j j | � | _ | j s6 | j j rL | j j | | � n | j j | | � | S( s% Set non-SQL options for the connection which take effect
during execution.
The method returns a copy of this :class:`.Connection` which references
the same underlying DBAPI connection, but also defines the given
execution options which will take effect for a call to
:meth:`execute`. As the new :class:`.Connection` references the same
underlying resource, it's usually a good idea to ensure that the copies
will be discarded immediately, which is implicit if used as in::
result = connection.execution_options(stream_results=True).\
execute(stmt)
Note that any key/value can be passed to
:meth:`.Connection.execution_options`, and it will be stored in the
``_execution_options`` dictionary of the :class:`.Connection`. It
is suitable for usage by end-user schemes to communicate with
event listeners, for example.
The keywords that are currently recognized by SQLAlchemy itself
include all those listed under :meth:`.Executable.execution_options`,
as well as others that are specific to :class:`.Connection`.
:param autocommit: Available on: Connection, statement.
When True, a COMMIT will be invoked after execution
when executed in 'autocommit' mode, i.e. when an explicit
transaction is not begun on the connection. Note that DBAPI
connections by default are always in a transaction - SQLAlchemy uses
rules applied to different kinds of statements to determine if
COMMIT will be invoked in order to provide its "autocommit" feature.
Typically, all INSERT/UPDATE/DELETE statements as well as
CREATE/DROP statements have autocommit behavior enabled; SELECT
constructs do not. Use this option when invoking a SELECT or other
specific SQL construct where COMMIT is desired (typically when
calling stored procedures and such), and an explicit
transaction is not in progress.
:param compiled_cache: Available on: Connection.
A dictionary where :class:`.Compiled` objects
will be cached when the :class:`.Connection` compiles a clause
expression into a :class:`.Compiled` object.
It is the user's responsibility to
manage the size of this dictionary, which will have keys
corresponding to the dialect, clause element, the column
names within the VALUES or SET clause of an INSERT or UPDATE,
as well as the "batch" mode for an INSERT or UPDATE statement.
The format of this dictionary is not guaranteed to stay the
same in future releases.
Note that the ORM makes use of its own "compiled" caches for
some operations, including flush operations. The caching
used by the ORM internally supersedes a cache dictionary
specified here.
:param isolation_level: Available on: :class:`.Connection`.
Set the transaction isolation level for
the lifespan of this :class:`.Connection` object (*not* the
underlying DBAPI connection, for which the level is reset
to its original setting upon termination of this
:class:`.Connection` object).
Valid values include
those string values accepted by the
:paramref:`.create_engine.isolation_level`
parameter passed to :func:`.create_engine`. These levels are
semi-database specific; see individual dialect documentation for
valid levels.
Note that this option necessarily affects the underlying
DBAPI connection for the lifespan of the originating
:class:`.Connection`, and is not per-execution. This
setting is not removed until the underlying DBAPI connection
is returned to the connection pool, i.e.
the :meth:`.Connection.close` method is called.
.. warning:: The ``isolation_level`` execution option should
**not** be used when a transaction is already established, that
is, the :meth:`.Connection.begin` method or similar has been
called. A database cannot change the isolation level on a
transaction in progress, and different DBAPIs and/or
SQLAlchemy dialects may implicitly roll back or commit
the transaction, or not affect the connection at all.
.. versionchanged:: 0.9.9 A warning is emitted when the
``isolation_level`` execution option is used after a
transaction has been started with :meth:`.Connection.begin`
or similar.
.. note:: The ``isolation_level`` execution option is implicitly
reset if the :class:`.Connection` is invalidated, e.g. via
the :meth:`.Connection.invalidate` method, or if a
disconnection error occurs. The new connection produced after
the invalidation will not have the isolation level re-applied
to it automatically.
.. seealso::
:paramref:`.create_engine.isolation_level`
- set per :class:`.Engine` isolation level
:meth:`.Connection.get_isolation_level` - view current level
:ref:`SQLite Transaction Isolation <sqlite_isolation_level>`
:ref:`PostgreSQL Transaction Isolation <postgresql_isolation_level>`
:ref:`MySQL Transaction Isolation <mysql_isolation_level>`
:ref:`SQL Server Transaction Isolation <mssql_isolation_level>`
:ref:`session_transaction_isolation` - for the ORM
:param no_parameters: When ``True``, if the final parameter
list or dictionary is totally empty, will invoke the
statement on the cursor as ``cursor.execute(statement)``,
not passing the parameter collection at all.
Some DBAPIs such as psycopg2 and mysql-python consider
percent signs as significant only when parameters are
present; this option allows code to generate SQL
containing percent signs (and possibly other characters)
that is neutral regarding whether it's executed by the DBAPI
or piped into a script that's later invoked by
command line tools.
:param stream_results: Available on: Connection, statement.
Indicate to the dialect that results should be
"streamed" and not pre-buffered, if possible. This is a limitation
of many DBAPIs. The flag is currently understood only by the
psycopg2, mysqldb and pymysql dialects.
:param schema_translate_map: Available on: Connection, Engine.
A dictionary mapping schema names to schema names, that will be
applied to the :paramref:`.Table.schema` element of each
:class:`.Table` encountered when SQL or DDL expression elements
are compiled into strings; the resulting schema name will be
converted based on presence in the map of the original name.
.. versionadded:: 1.1
.. seealso::
:ref:`schema_translating`
.. seealso::
:meth:`.Engine.execution_options`
:meth:`.Executable.execution_options`
:meth:`.Connection.get_execution_options`
( R/ R t unionR R
R t set_connection_execution_optionsR ( R! t optR. ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt execution_options� s � c C� s | j S( s� Get the non-SQL options which will take effect during execution.
.. versionadded:: 1.3
.. seealso::
:meth:`.Connection.execution_options`
( R ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt get_execution_optionsX s c C� s d | j k o | j S( s) Return True if this connection is closed.R ( R, R ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt closedc s c C� s
| j j S( s/ Return True if this connection was invalidated.( R) R ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt invalidatedl s c C� s` y | j SWn t k
r n Xy | j � SWn, t k
r[ } | j | d d d d � n Xd S( s� The underlying DB-API connection managed by this Connection.
.. seealso::
:ref:`dbapi_connections`
N( R t AttributeErrort _revalidate_connectiont
BaseExceptiont _handle_dbapi_exceptionR
( R! t e( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR" r s
c C� sJ y | j j | j � SWn, t k
rE } | j | d d d d � n Xd S( s� Return the current isolation level assigned to this
:class:`.Connection`.
This will typically be the default isolation level as determined
by the dialect, unless if the
:paramref:`.Connection.execution_options.isolation_level`
feature has been used to alter the isolation level on a
per-:class:`.Connection` basis.
This attribute will typically perform a live SQL operation in order
to procure the current isolation level, so the value returned is the
actual level on the underlying DBAPI connection regardless of how
this state was set. Compare to the
:attr:`.Connection.default_isolation_level` accessor
which returns the dialect-level setting without performing a SQL
query.
.. versionadded:: 0.9.9
.. seealso::
:attr:`.Connection.default_isolation_level` - view default level
:paramref:`.create_engine.isolation_level`
- set per :class:`.Engine` isolation level
:paramref:`.Connection.execution_options.isolation_level`
- set per :class:`.Connection` isolation level
N( R t get_isolation_levelR" R? R@ R
( R! RA ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyRB � s c C� s
| j j S( s� The default isolation level assigned to this :class:`.Connection`.
This is the isolation level setting that the :class:`.Connection`
has when first procured via the :meth:`.Engine.connect` method.
This level stays in place until the
:paramref:`.Connection.execution_options.isolation_level` is used
to change the setting on a per-:class:`.Connection` basis.
Unlike :meth:`.Connection.get_isolation_level`, this attribute is set
ahead of time from the first connection procured by the dialect,
so SQL query is not invoked when this accessor is called.
.. versionadded:: 0.9.9
.. seealso::
:meth:`.Connection.get_isolation_level` - view current level
:paramref:`.create_engine.isolation_level`
- set per :class:`.Engine` isolation level
:paramref:`.Connection.execution_options.isolation_level`
- set per :class:`.Connection` isolation level
( R t default_isolation_level( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyRC � s c C� s� | j r | j j � S| j rq | j rq | j d k rI t j d � � n | j j d | � | _
t | _ | j
St j d � � d S( Ns8 Can't reconnect until invalid transaction is rolled backt _connections This Connection is closed(
R R> R R R R
R t InvalidRequestErrorR
R R R t ResourceClosedError( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR> � s
c C� s t | j d t � S( Nt is_valid( t getattrR R ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _connection_is_valid� s c C� s' | j o& | j o& t | j d t � S( NRG ( R; R< RH R R ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt# _still_open_and_connection_is_valid� s
c C� s
| j j S( s� Info dictionary associated with the underlying DBAPI connection
referred to by this :class:`.Connection`, allowing user-defined
data to be associated with the connection.
The data here will follow along with the DBAPI connection including
after it is returned to the connection pool and used again
in subsequent instances of :class:`.Connection`.
( R" t info( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyRK � s c C� s
| j � S( si Returns a branched version of this :class:`.Connection`.
The :meth:`.Connection.close` method on the returned
:class:`.Connection` can be called and this
:class:`.Connection` will remain open.
This method provides usage symmetry with
:meth:`.Engine.connect`, including for usage
with context managers.
( R' ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt connect� s
c K� s
| j � S( N( R' ( R! t kwargs( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _contextual_connect s c C� sc | j r
d S| j r( t j d � � n | j j rJ | j j j | � n | j ` t | j _ d S( s� Invalidate the underlying DBAPI connection associated with
this :class:`.Connection`.
The underlying DBAPI connection is literally closed (if
possible), and is discarded. Its source connection pool will
typically lazily create a new connection to replace it.
Upon the next use (where "use" typically means using the
:meth:`.Connection.execute` method or similar),
this :class:`.Connection` will attempt to
procure a new DBAPI connection using the services of the
:class:`.Pool` as a source of connectivity (e.g. a "reconnection").
If a transaction was in progress (e.g. the
:meth:`.Connection.begin` method has been called) when
:meth:`.Connection.invalidate` method is called, at the DBAPI
level all state associated with this transaction is lost, as
the DBAPI connection is closed. The :class:`.Connection`
will not allow a reconnection to proceed until the
:class:`.Transaction` object is ended, by calling the
:meth:`.Transaction.rollback` method; until that point, any attempt at
continuing to use the :class:`.Connection` will raise an
:class:`~sqlalchemy.exc.InvalidRequestError`.
This is to prevent applications from accidentally
continuing an ongoing transactional operations despite the
fact that the transaction has been lost due to an
invalidation.
The :meth:`.Connection.invalidate` method, just like auto-invalidation,
will at the connection pool level invoke the
:meth:`.PoolEvents.invalidate` event.
.. seealso::
:ref:`pool_connection_invalidation`
Ns This Connection is closed(
R< R; R RF R) RI R t
invalidateR R ( R! t exception( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyRO s ' c C� s | j j � d S( s Detach the underlying DB-API connection from its connection pool.
E.g.::
with engine.connect() as conn:
conn.detach()
conn.execute("SET search_path TO schema1, schema2")
# work with connection
# connection is fully closed (since we used "with:", can
# also call .close())
This :class:`.Connection` instance will remain usable. When closed
(or exited from a context manager context as above),
the DB-API connection will be literally closed and not
returned to its originating pool.
This method can be used to insulate the rest of an application
from a modified state on a connection (such as a transaction
isolation level or similar).
N( R t detach( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyRQ 9 s c C� sO | j r | j j � S| j d k r; t | � | _ | j St | | j � Sd S( s4 Begin a transaction and return a transaction handle.
The returned object is an instance of :class:`.Transaction`.
This object represents the "scope" of the transaction,
which completes when either the :meth:`.Transaction.rollback`
or :meth:`.Transaction.commit` method is called.
Nested calls to :meth:`.begin` on the same :class:`.Connection`
will return new :class:`.Transaction` objects that represent
an emulated transaction within the scope of the enclosing
transaction, that is::
trans = conn.begin() # outermost transaction
trans2 = conn.begin() # "nested"
trans2.commit() # does nothing
trans.commit() # actually commits
Calls to :meth:`.Transaction.commit` only have an effect
when invoked via the outermost :class:`.Transaction` object, though the
:meth:`.Transaction.rollback` method of any of the
:class:`.Transaction` objects will roll back the
transaction.
.. seealso::
:meth:`.Connection.begin_nested` - use a SAVEPOINT
:meth:`.Connection.begin_twophase` -
use a two phase /XID transaction
:meth:`.Engine.begin` - context manager available from
:class:`.Engine`
N( R t beginR R
t RootTransactiont Transaction( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyRR T s #
c C� sS | j r | j j � S| j d k r7 t | � | _ n t | | j � | _ | j S( s+ Begin a nested transaction and return a transaction handle.
The returned object is an instance of :class:`.NestedTransaction`.
Nested transactions require SAVEPOINT support in the
underlying database. Any transaction in the hierarchy may
``commit`` and ``rollback``, however the outermost transaction
still controls the overall ``commit`` or ``rollback`` of the
transaction of a whole.
.. seealso::
:meth:`.Connection.begin`
:meth:`.Connection.begin_twophase`
N( R t begin_nestedR R
RS t NestedTransaction( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyRU � s
c C� sw | j r | j j d | � S| j d k r= t j d � � n | d k r^ | j j j � } n t | | � | _ | j S( s Begin a two-phase or XA transaction and return a transaction
handle.
The returned object is an instance of :class:`.TwoPhaseTransaction`,
which in addition to the methods provided by
:class:`.Transaction`, also provides a
:meth:`~.TwoPhaseTransaction.prepare` method.
:param xid: the two phase transaction id. If not supplied, a
random id will be generated.
.. seealso::
:meth:`.Connection.begin`
:meth:`.Connection.begin_twophase`
t xidsO Cannot start a two phase transaction when a transaction is already in progress.N(
R t begin_twophaseR R
R RE R
R t
create_xidt TwoPhaseTransaction( R! RW ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyRX � s c C� s | j j j | � S( N( R
R t do_recover_twophase( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt recover_twophase� s c C� s | j j j | | d | �d S( Nt recover( R
R t do_rollback_twophase( R! RW R] ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt rollback_prepared� s c C� s | j j j | | d | �d S( NR] ( R
R t do_commit_twophase( R! RW R] ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt commit_prepared� s c C� s | j j d k S( s, Return True if a transaction is in progress.N( R) R R
( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt in_transaction� s c C� s� | j s t � | j r/ | j j j d � n | j sD | j j rW | j j | � n y; | j j j
| j � | j j d k r� | | j _ n Wn, t k
r� } | j | d d d d � n Xd S( Ns BEGIN (implicit)( R R R R
t loggerRK R R RR R t do_beginR" t _reset_agentR
R? R@ ( R! t transactionRA ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _begin_impl� s c C� s� | j s t � | j s% | j j r8 | j j | � n | j r� | j r` | j j j d � n zM y | j j
j | j � Wn, t
k
r� } | j | d d d d � n XWd | j r� | j j | j k r� d | j _ n d | _ Xn d | _ d S( Nt ROLLBACK( R R R R
R t rollbackRJ R Rc RK R t do_rollbackR" R? R@ R
R Re R ( R! RA ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _rollback_impl� s !
c C� s� | j s t � | j s% | j j r8 | j j | � n | j rW | j j j d � n zM y | j j j
| j � Wn, t k
r� } | j
| d d d d � n XWd | j r� | j j | j k r� d | j _ n d | _ Xd S( Nt COMMIT( R R R R
R t commitR Rc RK R t do_commitR" R? R@ R
R Re R ( R! t
autocommitRA ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _commit_impl� s !
c C� s� | j s t � | j s% | j j r; | j j | | � n | d k rf | j d 7_ d | j } n | j r� | j j j
| | � | Sd S( Ni s sa_savepoint_%s( R R R R
R t savepointR
R RJ R t do_savepoint( R! t name( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _savepoint_impl s c C� sm | j s t � | j s% | j j r> | j j | | | � n | j r` | j j j | | � n | | _ d S( N(
R R R R
R t rollback_savepointRJ R t do_rollback_to_savepointR ( R! Rs t context( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _rollback_to_savepoint_impl s c C� sm | j s t � | j s% | j j r> | j j | | | � n | j r` | j j j | | � n | | _ d S( N(
R R R R
R t release_savepointRJ R t do_release_savepointR ( R! Rs Rw ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _release_savepoint_impl s c C� s� | j s t � | j r/ | j j j d � n | j sD | j j r] | j j | | j � n | j
r� | j j j | | j � | j
j d k r� | | j
_ q� n d S( Ns BEGIN TWOPHASE (implicit)( R R R R
Rc RK R R RX RW RJ R t do_begin_twophaseR" Re R
( R! Rf ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _begin_twophase_impl% s c C� sy | j s t � | j s% | j j r; | j j | | � n | j ru t | j t � s\ t � | j j
j | | � n d S( N( R R R R
R t prepare_twophaseRJ t
isinstanceR RZ R t do_prepare_twophase( R! RW ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _prepare_twophase_impl3 s c C� s� | j s t � | j s% | j j r> | j j | | | � n | j r� t | j t � s_ t � z | j j
j | | | � Wd | j j
| j k r� d | j _
n d | _ Xn d | _ d S( N( R R R R
R t rollback_twophaseRJ R R RZ R R^ R" Re R
( R! RW t is_prepared( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _rollback_twophase_impl= s
c C� s� | j s t � | j s% | j j r> | j j | | | � n | j r� t | j t � s_ t � z | j j
j | | | � Wd | j j
| j k r� d | j _
n d | _ Xn d | _ d S( N( R R R R
R t commit_twophaseRJ R R RZ R R` R" Re R
( R! RW R� ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _commit_twophase_implP s
c C� s# | j j � s | j j � n d S( N( R) Rb Rk ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt
_autorollbacka s c C� s� | j r? z" y
| ` Wn t k
r) n XWd t | _ d SXn y
| j } Wn t k
r_ n; X| j � | j | j k r� d | _ n | j s� | ` n t | _ d | _ d S( s8 Close this :class:`.Connection`.
This results in a release of the underlying database
resources, that is, the DBAPI connection referenced
internally. The DBAPI connection is typically restored
back to the connection-holding :class:`.Pool` referenced
by the :class:`.Engine` that produced this
:class:`.Connection`. Any transactional state present on
the DBAPI connection is also unconditionally released via
the DBAPI connection's ``rollback()`` method, regardless
of any :class:`.Transaction` object that may be
outstanding with regards to this :class:`.Connection`.
After :meth:`~.Connection.close` is called, the
:class:`.Connection` is permanently in a closed state,
and will allow no further operations.
N(
R R R= R R R1 Re R R
R ( R! t conn( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR1 e s&
c O� s | j | | | � j � S( s� Executes and returns the first column of the first row.
The underlying result/cursor is closed after execution.
( t executet scalar( R! t object_t multiparamst params( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR� � s c O� sm t | t j d � r) | j | | | � Sy
| j } Wn t k
rX t j | � � n X| | | | � Sd S( s� Executes a SQL statement construct and returns a
:class:`.ResultProxy`.
:param object: The statement to be executed. May be
one of:
* a plain string
* any :class:`.ClauseElement` construct that is also
a subclass of :class:`.Executable`, such as a
:func:`~.expression.select` construct
* a :class:`.FunctionElement`, such as that generated
by :data:`.func`, will be automatically wrapped in
a SELECT statement, which is then executed.
* a :class:`.DDLElement` object
* a :class:`.DefaultGenerator` object
* a :class:`.Compiled` object
:param \*multiparams/\**params: represent bound parameter
values to be used in the execution. Typically,
the format is either a collection of one or more
dictionaries passed to \*multiparams::
conn.execute(
table.insert(),
{"id":1, "value":"v1"},
{"id":2, "value":"v2"}
)
...or individual key/values interpreted by \**params::
conn.execute(
table.insert(), id=1, value="v1"
)
In the case that a plain SQL string is passed, and the underlying
DBAPI accepts positional bind parameters, a collection of tuples
or individual values in \*multiparams may be passed::
conn.execute(
"INSERT INTO table (id, value) VALUES (?, ?)",
(1, "v1"), (2, "v2")
)
conn.execute(
"INSERT INTO table (id, value) VALUES (?, ?)",
1, "v1"
)
Note above, the usage of a question mark "?" or other
symbol is contingent upon the "paramstyle" accepted by the DBAPI
in use, which may be any of "qmark", "named", "pyformat", "format",
"numeric". See `pep-249 <http://www.python.org/dev/peps/pep-0249/>`_
for details on paramstyle.
To execute a textual SQL statement which uses bound parameters in a
DBAPI-agnostic way, use the :func:`~.expression.text` construct.
i N( R R t string_typest
_execute_textt _execute_on_connectionR= R t ObjectNotExecutableError( R! R� R� R� t meth( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR� � s ;
c C� s | j | j � | | � S( s% Execute a sql.FunctionElement object.( t _execute_clauseelementt select( R! t funcR� R� ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _execute_function� s c
C� sF | j s | j j rM x5 | j j D]$ } | | | | | � \ } } } q" Wn yg y
| j } Wn t k
rv d } n X| d k r� | j � } n | j } | j j
| | | � } Wn, t k
r� } | j | d d d d � n X| j
d | d � } | j r| j � n | j s#| j j rB| j j | | | | | � n | S( s& Execute a schema.ColumnDefault object.N( R R
R t before_executeR R= R
R> R t execution_ctx_clst
_init_defaultR? R@ t
_exec_defaultR R1 t
after_execute(
R! t defaultR� R� t fnR� R t ctxRA t ret( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _execute_default� s, "
c C� s� | j s | j j rM x5 | j j D]$ } | | | | | � \ } } } q" Wn | j } | j d | d | j j sz | j n d � } | j | | j
j | d | � } | j s� | j j r� | j j | | | | | � n | S( s Execute a schema.DDL object.R t schema_translate_mapN(
R R
R R� R t compileR t
is_defaultR
t _execute_contextR� t _init_ddlR� ( R! t ddlR� R� R� R t compiledR� ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _execute_ddl s" % c C� s� | j s | j j rM x5 | j j D]$ } | | | | | � \ } } } q" Wn t | | � } | r{ t | d j � � } n g } | j } d | j k rJ| | t t
| � � | j j t
| � d k f } | j d j | � } | d k r�| j d | d | d t
| � d k d | j j s*| j n d � } | | j d | <q�nE | j d | d | d t
| � d k d | j j s�| j n d � } | j | | j j | | | | � }
| j s�| j j r�| j j | | | | |
� n |
S( s# Execute a sql.ClauseElement object.i t compiled_cachei R t column_keyst inlineR� N( R R
R R� R t listt keysR R t tuplet sortedR t hash_keyt lent getR
R� R� R� R� t _init_compiledR� ( R! t elemR� R� R� t distilled_paramsR� R t keyt compiled_sqlR� ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR� sN % c C� s� | j s | j j rM x5 | j j D]$ } | | | | | � \ } } } q" Wn | j } t | | � } | j | | j j | | | | � } | j s� | j j r� | j j | | | | | � n | S( s Execute a sql.Compiled object.(
R R
R R� R R R� R� R� R� ( R! R� R� R� R� R t
parametersR� ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _execute_compiledY s" " c C� s� | j s | j j rM x5 | j j D]$ } | | | | | � \ } } } q" Wn | j } t | | � } | j | | j j | | | | � } | j s� | j j r� | j j | | | | | � n | S( s Execute a string SQL statement.(
R R
R R� R R R� R� t _init_statementR� ( R! t statementR� R� R� R R� R� ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR� r s" " c
G� s� y[ y
| j } Wn t k
r) d } n X| d k rE | j � } n | | | | | � } Wn5 t k
r� } | j | t j | � | d d � n X| j r� | j � n | j
| j | j } } } | j
s� | d } n | j s� | j j r/x; | j j D]* }
|
| | | | | | j
� \ } } q� Wn | j rs| j j j | � | j j j d t j | d d �� n t } y[| j
r�| j j r�x9 | j j j D]% }
|
| | | | � r�t } Pq�q�Wn | s�| j j | | | | � q�n� | ri| j ri| j j rGx6 | j j j D]" }
|
| | | � r t } Pq q Wn | s�| j j | | | � q�nj | j j r�x9 | j j j D]% }
|
| | | | � r�t } Pq�q�Wn | s�| j j | | | | � n Wn, t k
r} | j | | | | | � n X| j s| j j r=| j j | | | | | | j
� n | j rS| j � n | j se| j! rt| j" � } n( | j# � } | j$ d k r�| j% � n | j& r�| j' j( d k r�| j' j) d t � n | j* r�| j+ r�| j, � q�t | _- n | S( s\ Create an :class:`.ExecutionContext` and execute, returning
a :class:`.ResultProxy`.i s %rt batchesi
Ro N(. R R= R
R> R? R@ R t text_typeR� t pre_exect cursorR� R� t executemanyR R
R t before_cursor_executeR Rc RK t sql_utilt _repr_paramsR R t do_executemanyR t
no_parameterst do_execute_no_paramst
do_executet after_cursor_executet post_exect is_crudt is_textt _setup_crud_result_proxyt get_result_proxyt _metadatat _soft_closet should_autocommitR) R Rp R t _soft_closedR1 t _autoclose_connection(
R! R t constructorR� R� t argsR� Rw RA R� R� t evt_handledt result( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR� � s�
c C� sQ | j s | j j rP x8 | j j D]' } | | | | | | t � \ } } q" Wn | j r� | j j j | � | j j j d | � n yb x[ | j j s� d n | j j j D] } | | | | | � r� Pq� q� W| j j | | | | � Wn, t
k
r} | j | | | | | � n X| j s+| j j rM| j j | | | | | t � n d S( s_ Execute a statement + params on the given cursor.
Adds appropriate logging and exception handling.
This method is used by DefaultDialect for special-case
executions, such as for sequences and column defaults.
The path of statement execution in the majority of cases
terminates at _execute_context().
s %rN( (
R R
R R� R R Rc RK R R� R? R@ R� ( R! R� R� R� Rw R� RA ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _cursor_execute s( % c C� sB y | j � Wn- t k
r= | j j j j d d t �n Xd S( s\ Close the given cursor, catching exceptions
and turning into log warnings.
s Error closing cursort exc_infoN( R1 t ExceptionR
t poolRc t errorR ( R! R� ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _safe_close_cursor/ s
c C� s� t j � } | r- | j d k r- | | _ n t | t � } | j s� t | | j j j � r� | j
r� | j j | | j s� | j
n d | � p� | o� | j
| _ | r� | j | _ q� n | } | j rt j t j j | | | | j j j d | j �| � n t | _ zNt | | j j j � pG| d k oG| d k oG| } | r�t j j | | | | j j j d | j d | j �}
n d }
d } | j s�| j j r�| j j d t � r�| r�| r�| j j | | | | | | � n t | |
| j | | | | | | j | �
} x] | j j D]O }
y, |
| � } | d k rY| | _ } n Wq(t k
rv} | } Pq(Xq(W| j | j k r�| j | _ |
r�| j |
_ q�n | j } n | r�| r�| j! | � n | j s | r�| j" | � n t j# d t � � | j$ � Wd QXn | r7t j | | � n& | rPt j |
| � n
t j% | � Wd | ` | j r�| ` | j s�| j
} | r�| j j& j' | | � n | j( | � q�n | j) r�| j* � n Xd S( NR t connection_invalidatedt skip_user_error_eventst warn_only(+ t sysR� RP R
R R� t _is_disconnectR t dbapit ErrorR; t
is_disconnectR< R t _reentrant_errorR t raise_from_causeR t
DBAPIErrort instanceR R R
R R� R R t dbapi_errort ExceptionContextImplt handle_errort chained_exceptionR� t invalidate_pool_on_disconnectt handle_dbapi_exceptionR� t safe_reraiseR� t reraiseR� t _invalidateRO R R1 ( R! RA R� R� R� Rw R� t is_exit_exceptionR� t should_wrapt sqlalchemy_exceptiont newraiseR� R� t per_fnt _raisedt dbapi_conn_wrapper( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR@ ? s�
c
C� sp t j � } | j | d d � } t | | j j � } | rf t j j d d | | j j d | �} n d } d } | j
r-t | | | d d d d d | t �
} x] | j
j D]O }
y, |
| � } | d k r� | | _ } n Wq� t k
r� } | } Pq� Xq� W| r-| | j k r-| j | _ } q-n | rFt j | | � n& | r_t j | | � n
t j | � d S( NR� ( R� R� R� R
R R� R� R R� R� R R� R R R� R� R� R� R R� R� (
t clsRA R R
R� R� R� R� R� R� R� R� R� ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt$ _handle_dbapi_exception_noconnection� sN c O� s^ | j � } y' | j | | | � } | j � | SWn$ t j � � | j � Wd QXn Xd S( s8 Execute the given function within a transaction boundary.
The function is passed this :class:`.Connection`
as the first argument, followed by the given \*args and \**kwargs,
e.g.::
def do_something(conn, x, y):
conn.execute("some statement", {'x':x, 'y':y})
conn.transaction(do_something, 5, 10)
The operations inside the function are all invoked within the
context of a single :class:`.Transaction`.
Upon success, the transaction is committed. If an
exception is raised, the transaction is rolled back
before propagating the exception.
.. note::
The :meth:`.transaction` method is superseded by
the usage of the Python ``with:`` statement, which can
be used with :meth:`.Connection.begin`::
with conn.begin():
conn.execute("some statement", {'x':5, 'y':10})
As well as with :meth:`.Engine.begin`::
with engine.begin() as conn:
conn.execute("some statement", {'x':5, 'y':10})
.. seealso::
:meth:`.Engine.begin` - engine-level transactional
context
:meth:`.Engine.transaction` - engine-level version of
:meth:`.Connection.transaction`
N( RR t run_callableRm R R� Ri ( R! t callable_R� RM t transR� ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyRf s *
c O� s | | | | � S( s� Given a callable object or function, execute it, passing
a :class:`.Connection` as the first argument.
The given \*args and \**kwargs are passed subsequent
to the :class:`.Connection` argument.
This function, along with :meth:`.Engine.run_callable`,
allows a function to be run with a :class:`.Connection`
or :class:`.Engine` object without the need to know
which one is being dealt with.
( ( R! R� R� RM ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR� 7 s
c K� s | | j | | � j | � d S( N( R t traverse_single( R! t visitorcallablet elementRM ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _run_visitorF s N(D t __name__t
__module__t __doc__R t _schema_getterR
R R R& R' t propertyR) R/ R0 R5 R9 R: R; R< R" RB RC R> RI RJ RK RL RN RO RQ RR RU RX R\ R_ Ra Rb Rg Rk Rp Rt Rx R{ R} R� R� R� R� R1 R� R� R� R� R� R� R� R� R� R� R� R� R� R@ t classmethodR� Rf R� R ( ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR s� 2 � $ 2 , !
- D # 9 | (
�: 3 R� c B� s e Z d Z d � Z RS( s3 Implement the :class:`.ExceptionContext` interface.c C� sU | | _ | | _ | | _ | | _ | | _ | | _ | | _ | | _ |
| _ d S( N( R
R" R� t original_exceptiont execution_contextR� R� R� R� ( R! RP R� R
R" R� R� R� Rw R� R� ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR& M s
( R R R R& ( ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR� J s RT c B� se e Z d Z d � Z e d � � Z d � Z d � Z d � Z d � Z d � Z
d � Z d � Z RS(
s? Represent a database transaction in progress.
The :class:`.Transaction` object is procured by
calling the :meth:`~.Connection.begin` method of
:class:`.Connection`::
from sqlalchemy import create_engine
engine = create_engine("postgresql://scott:tiger@localhost/test")
connection = engine.connect()
trans = connection.begin()
connection.execute("insert into x (a, b) values (1, 2)")
trans.commit()
The object provides :meth:`.rollback` and :meth:`.commit`
methods in order to control transaction boundaries. It
also implements a context manager interface so that
the Python ``with`` statement can be used with the
:meth:`.Connection.begin` method::
with connection.begin():
connection.execute("insert into x (a, b) values (1, 2)")
The Transaction object is **not** threadsafe.
.. seealso::
:meth:`.Connection.begin`
:meth:`.Connection.begin_twophase`
:meth:`.Connection.begin_nested`
.. index::
single: thread safety; Transaction
c C� s | | _ | | _ t | _ d S( N( R" t _actual_parentR t is_active( R! R" t parent( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR& � s c C� s
| j p | S( N( R
( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _parent� s c C� s0 | j j s d S| j | k r, | j � n d S( s; Close this :class:`.Transaction`.
If this transaction is the base transaction in a begin/commit
nesting, the transaction will rollback(). Otherwise, the
method returns.
This is used to cancel a Transaction without affecting the scope of
an enclosing transaction.
N( R
R Ri ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR1 � s c C� s' | j j s d S| j � t | _ d S( s/ Roll back this :class:`.Transaction`.
N( R
R t _do_rollbackR ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyRi � s
c C� s | j j � d S( N( R
Ri ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR � s c C� s5 | j j s t j d � � n | j � t | _ d S( s" Commit this :class:`.Transaction`.s This transaction is inactiveN( R
R R RE t
_do_commitR ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyRm � s
c C� s d S( N( ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR � s c C� s | S( N( ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR0 � s c C� s[ | d k rM | j rM y | j � WqW t j � � | j � Wd QXqW Xn
| j � d S( N( R
R Rm R R� Ri ( R! R2 R3 R4 ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR5 � s
(
R R R R& R R
R1 Ri R Rm R R0 R5 ( ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyRT e s # RS c B� s# e Z d � Z d � Z d � Z RS( c C� s- t t | � j | d � | j j | � d S( N( t superRS R& R
R" Rg ( R! R" ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR& � s c C� s | j r | j j � n d S( N( R R" Rk ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR � s c C� s | j r | j j � n d S( N( R R" Rp ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR � s ( R R R& R R ( ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyRS � s RV c B� s) e Z d Z d � Z d � Z d � Z RS( s� Represent a 'nested', or SAVEPOINT transaction.
A new :class:`.NestedTransaction` object may be procured
using the :meth:`.Connection.begin_nested` method.
The interface is the same as that of :class:`.Transaction`.
c C� s/ t t | � j | | � | j j � | _ d S( N( R RV R& R" Rt t
_savepoint( R! R" R ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR& � s c C� s) | j r% | j j | j | j � n d S( N( R R" Rx R R
( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR � s c C� s) | j r% | j j | j | j � n d S( N( R R" R{ R R
( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR � s ( R R R R& R R ( ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyRV � s RZ c B� s2 e Z d Z d � Z d � Z d � Z d � Z RS( s Represent a two-phase transaction.
A new :class:`.TwoPhaseTransaction` object may be procured
using the :meth:`.Connection.begin_twophase` method.
The interface is the same as that of :class:`.Transaction`
with the addition of the :meth:`prepare` method.
c C� s? t t | � j | d � t | _ | | _ | j j | � d S( N( R RZ R& R
R t _is_preparedRW R" R} ( R! R" RW ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR& � s c C� s> | j j s t j d � � n | j j | j � t | _ d S( sq Prepare this :class:`.TwoPhaseTransaction`.
After a PREPARE, the transaction can be committed.
s This transaction is inactiveN( R
R R RE R" R� RW R R ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt prepare s c C� s | j j | j | j � d S( N( R" R� RW R ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR
s c C� s | j j | j | j � d S( N( R" R� RW R ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR s ( R R R R& R R R ( ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyRZ � s
t Enginec B� s� e Z d Z e j � Z e Z e Z e
j d � Z
d d d d d � Z e d � � Z d � Z d � Z d � Z e d � � Z e d � � Z e j � Z d � Z d � Z d
� Z e j d d � � Z d d � Z d
e f d � � YZ! e d � Z" d � Z# d � Z$ d � Z% d � Z& d d d � Z' d � Z( d � Z) e j* d d � e d � � Z+ e d � Z, d d d � Z- d d � Z. d � Z/ d d � Z0 RS( s{
Connects a :class:`~sqlalchemy.pool.Pool` and
:class:`~sqlalchemy.engine.interfaces.Dialect` together to provide a
source of database connectivity and behavior.
An :class:`.Engine` object is instantiated publicly using the
:func:`~sqlalchemy.create_engine` function.
.. seealso::
:doc:`/core/engines`
:ref:`connections_toplevel`
c C� s | | _ | | _ | | _ | r- | | _ n | | _ t j | d | �| re t j j | | � n | r{ | j
| � n d S( Nt echoflag( R� t urlR t logging_namet echoR t instance_loggerR t ConnectionProxyt _adapt_listenert update_execution_options( R! R� R R R R t proxyR9 ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR& 9 s
c C� s | S( N( ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR
O s c K� s? | j j | � | _ | j j | | � | j j | | � d S( s� Update the default execution_options dictionary
of this :class:`.Engine`.
The given keys/values in \**opt are added to the
default execution options that will be used for
all connections. The initial contents of this dictionary
can be sent via the ``execution_options`` parameter
to :func:`.create_engine`.
.. seealso::
:meth:`.Connection.execution_options`
:meth:`.Engine.execution_options`
N( R R6 R t set_engine_execution_optionsR ( R! R8 ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR S s c K� s
t | | � S( s� Return a new :class:`.Engine` that will provide
:class:`.Connection` objects with the given execution options.
The returned :class:`.Engine` remains related to the original
:class:`.Engine` in that it shares the same connection pool and
other state:
* The :class:`.Pool` used by the new :class:`.Engine` is the
same instance. The :meth:`.Engine.dispose` method will replace
the connection pool instance for the parent engine as well
as this one.
* Event listeners are "cascaded" - meaning, the new :class:`.Engine`
inherits the events of the parent, and new events can be associated
with the new :class:`.Engine` individually.
* The logging configuration and logging_name is copied from the parent
:class:`.Engine`.
The intent of the :meth:`.Engine.execution_options` method is
to implement "sharding" schemes where multiple :class:`.Engine`
objects refer to the same connection pool, but are differentiated
by options that would be consumed by a custom event::
primary_engine = create_engine("mysql://")
shard1 = primary_engine.execution_options(shard_id="shard1")
shard2 = primary_engine.execution_options(shard_id="shard2")
Above, the ``shard1`` engine serves as a factory for
:class:`.Connection` objects that will contain the execution option
``shard_id=shard1``, and ``shard2`` will produce :class:`.Connection`
objects that contain the execution option ``shard_id=shard2``.
An event handler can consume the above execution option to perform
a schema switch or other operation, given a connection. Below
we emit a MySQL ``use`` statement to switch databases, at the same
time keeping track of which database we've established using the
:attr:`.Connection.info` dictionary, which gives us a persistent
storage space that follows the DBAPI connection::
from sqlalchemy import event
from sqlalchemy.engine import Engine
shards = {"default": "base", shard_1: "db1", "shard_2": "db2"}
@event.listens_for(Engine, "before_cursor_execute")
def _switch_shard(conn, cursor, stmt,
params, context, executemany):
shard_id = conn._execution_options.get('shard_id', "default")
current_shard = conn.info.get("current_shard", None)
if current_shard != shard_id:
cursor.execute("use %s" % shards[shard_id])
conn.info["current_shard"] = shard_id
.. seealso::
:meth:`.Connection.execution_options` - update execution options
on a :class:`.Connection` object.
:meth:`.Engine.update_execution_options` - update the execution
options for a given :class:`.Engine` in place.
:meth:`.Engine.get_execution_options`
( t OptionEngine( R! R8 ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR9 h s Bc C� s | j S( s� Get the non-SQL options which will take effect during execution.
.. versionadded: 1.3
.. seealso::
:meth:`.Engine.execution_options`
( R ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR: � s c C� s
| j j S( si String name of the :class:`~sqlalchemy.engine.interfaces.Dialect`
in use by this :class:`Engine`.( R Rs ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyRs � s c C� s
| j j S( si Driver name of the :class:`~sqlalchemy.engine.interfaces.Dialect`
in use by this :class:`Engine`.( R t driver( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR � s c C� s d | j S( Ns
Engine(%r)( R ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt __repr__� s c C� s3 | j j � | j j � | _ | j j | � d S( s� Dispose of the connection pool used by this :class:`.Engine`.
This has the effect of fully closing all **currently checked in**
database connections. Connections that are still checked out
will **not** be closed, however they will no longer be associated
with this :class:`.Engine`, so when they are closed individually,
eventually the :class:`.Pool` which they are associated with will
be garbage collected and they will be closed out fully, if
not already closed on checkin.
A new connection pool is created immediately after the old one has
been disposed. This new pool, like all SQLAlchemy connection pools,
does not make any actual connections to the database until one is
first requested, so as long as the :class:`.Engine` isn't used again,
no new connections will be made.
.. seealso::
:ref:`engine_disposal`
N( R� t disposet recreateR t engine_disposed( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR" � s
c C� s, | j � � } | j | d i � SWd QXd S( N( ( RN R� ( R! R� R� ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR� � s c c� s2 | d k r) | j � � } | VWd QXn | Vd S( N( R
RN ( R! R" R� ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _optional_conn_ctx_manager� s c K� s/ | j | � � } | j | | | � Wd QXd S( N( R% R ( R! R� R R" RM R� ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR � s t
_trans_ctxc B� s# e Z d � Z d � Z d � Z RS( c C� s | | _ | | _ | | _ d S( N( R� Rf R# ( R! R� Rf R# ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR& � s c C� s | j S( N( R� ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR0 � s c C� sF | d k r | j j � n
| j j � | j sB | j j � n d S( N( R
Rf Ri Rm R# R� R1 ( R! R2 R3 R4 ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR5 � s
( R R R& R0 R5 ( ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR& � s c C� s\ | j d | � } y | j � } Wn$ t j � � | j � Wd QXn Xt j | | | � S( s� Return a context manager delivering a :class:`.Connection`
with a :class:`.Transaction` established.
E.g.::
with engine.begin() as conn:
conn.execute("insert into table (x, y, z) values (1, 2, 3)")
conn.execute("my_special_procedure(5)")
Upon successful operation, the :class:`.Transaction`
is committed. If an error is raised, the :class:`.Transaction`
is rolled back.
The ``close_with_result`` flag is normally ``False``, and indicates
that the :class:`.Connection` will be closed when the operation
is complete. When set to ``True``, it indicates the
:class:`.Connection` is in "single use" mode, where the
:class:`.ResultProxy` returned by the first call to
:meth:`.Connection.execute` will close the :class:`.Connection` when
that :class:`.ResultProxy` has exhausted all result rows.
.. seealso::
:meth:`.Engine.connect` - procure a :class:`.Connection` from
an :class:`.Engine`.
:meth:`.Connection.begin` - start a :class:`.Transaction`
for a particular :class:`.Connection`.
R# N( RN RR R R� R1 R R& ( R! R# R� R� ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyRR s
c O� s, | j � � } | j | | | � SWd QXd S( s� Execute the given function within a transaction boundary.
The function is passed a :class:`.Connection` newly procured
from :meth:`.Engine.contextual_connect` as the first argument,
followed by the given \*args and \**kwargs.
e.g.::
def do_something(conn, x, y):
conn.execute("some statement", {'x':x, 'y':y})
engine.transaction(do_something, 5, 10)
The operations inside the function are all invoked within the
context of a single :class:`.Transaction`.
Upon success, the transaction is committed. If an
exception is raised, the transaction is rolled back
before propagating the exception.
.. note::
The :meth:`.transaction` method is superseded by
the usage of the Python ``with:`` statement, which can
be used with :meth:`.Engine.begin`::
with engine.begin() as conn:
conn.execute("some statement", {'x':5, 'y':10})
.. seealso::
:meth:`.Engine.begin` - engine-level transactional
context
:meth:`.Connection.transaction` - connection-level version of
:meth:`.Engine.transaction`
N( RN Rf ( R! R� R� RM R� ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyRf . s 'c O� s, | j � � } | j | | | � SWd QXd S( s� Given a callable object or function, execute it, passing
a :class:`.Connection` as the first argument.
The given \*args and \**kwargs are passed subsequent
to the :class:`.Connection` argument.
This function, along with :meth:`.Connection.run_callable`,
allows a function to be run with a :class:`.Connection`
or :class:`.Engine` object without the need to know
which one is being dealt with.
N( RN R� ( R! R� R� RM R� ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR� X s
c O� s% | j d t � } | j | | | � S( s� Executes the given construct and returns a :class:`.ResultProxy`.
The arguments are the same as those used by
:meth:`.Connection.execute`.
Here, a :class:`.Connection` is acquired using the
:meth:`~.Engine.contextual_connect` method, and the statement executed
with that connection. The returned :class:`.ResultProxy` is flagged
such that when the :class:`.ResultProxy` is exhausted and its
underlying cursor is closed, the :class:`.Connection` created here
will also be closed, which allows its associated DBAPI connection
resource to be returned to the connection pool.
R# ( RN R R� ( R! R� R� R� R" ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR� h s c O� s | j | | | � j � S( N( R� R� ( R! R� R� R� ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR� { s c C� s% | j d t � } | j | | | � S( NR# ( RN R R� ( R! R� R� R� R" ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR� ~ s c C� s% | j d t � } | j | | | � S( NR# ( RN R R� ( R! R� R� R� R" ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR� � s c K� s | j | | � S( sO Return a new :class:`.Connection` object.
The :class:`.Connection` object is a facade that uses a DBAPI
connection internally in order to communicate with the database. This
connection is procured from the connection-holding :class:`.Pool`
referenced by this :class:`.Engine`. When the
:meth:`~.Connection.close` method of the :class:`.Connection` object
is called, the underlying DBAPI connection is then returned to the
connection pool, where it may be used again in a subsequent call to
:meth:`~.Engine.connect`.
( R( ( R! RM ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyRL � s s 1.3s� The :meth:`.Engine.contextual_connect` method is deprecated. This method is an artifact of the threadlocal engine strategy which is also to be deprecated. For explicit connections from an :class:`.Engine`, use the :meth:`.Engine.connect` method.c K� s | j d | | � S( s� Return a :class:`.Connection` object which may be part of some
ongoing context.
By default, this method does the same thing as :meth:`.Engine.connect`.
Subclasses of :class:`.Engine` may override this method
to provide contextual behavior.
:param close_with_result: When True, the first :class:`.ResultProxy`
created by the :class:`.Connection` will call the
:meth:`.Connection.close` method of that connection as soon as any
pending result rows are exhausted. This is used to supply the
"connectionless execution" behavior provided by the
:meth:`.Engine.execute` method.
R# ( RN ( R! R# RM ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt contextual_connect� s c K� s+ | j | | j | j j d � d | | �S( NR# ( R( t _wrap_pool_connectR� RL R
( R! R# RM ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyRN � s
c C� sD | j | � �/ } | s' | j j } n | j j | | � SWd QXd S( s Return a list of all table names available in the database.
:param schema: Optional, retrieve names from a non-default schema.
:param connection: Optional, use a specified connection. Default is
the ``contextual_connect`` for this ``Engine``.
N( R% R t default_schema_namet get_table_names( R! R R" R� ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt table_names� s c C� s | j | j j | | � S( sU Return True if the given backend has a table of the given name.
.. seealso::
:ref:`metadata_reflection_inspector` - detailed schema inspection
using the :class:`.Inspector` interface.
:class:`.quoted_name` - used to pass quoting information along
with a schema identifier.
( R� R t has_table( R! t
table_nameR ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR, � s c C� si | j } y | � SWnN | j j k
rd } | d k rN t j | | | � qe t j t j � � n Xd S( N(
R R� R� R
R R� R R� R� R� ( R! R� R" R RA ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR( � s c C� s | j | j j | � S( s& Return a "raw" DBAPI connection from the connection pool.
The returned object is a proxied version of the DBAPI
connection object used by the underlying driver in use.
The object will have all the same behavior as the real DBAPI
connection, except that its ``close()`` method will result in the
connection being returned to the pool, rather than being closed
for real.
This method provides direct DBAPI connection access for
special situations when the API provided by :class:`.Connection`
is not needed. When a :class:`.Connection` object is already
present, the DBAPI connection is available using
the :attr:`.Connection.connection` accessor.
.. seealso::
:ref:`dbapi_connections`
( R( R� t unique_connection( R! RD ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR � s N(1 R R R R t
immutabledictR R R R R( R R R
R R& R R
R R9 R: Rs R R t
echo_propertyR R! R" R� t
contextlibt contextmanagerR% R t objectR& RR Rf R� R� R� R� R� RL t
deprecatedR' RN R+ R, R( R ( ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR sP D ' * R c B� sY e Z e Z d � Z d � Z d � Z e e e � Z d � Z d � Z
e e e
� Z RS( c C� s� | | _ | j | _ | j | _ | j | _ | j | _ t j | d | j �| j j | j � | _ | j | _ | j
| � d S( NR ( t _proxiedR R R R R R R R R R ( R! t proxiedR9 ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR& � s c C� s
| j j S( N( R5 R� ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _get_pool s c C� s | | j _ d S( N( R5 R� ( R! R� ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _set_pool s c C� s | j j p | j j d t � S( NR ( R5 R R, R� R ( R! ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _get_has_events s c C� s | | j d <d S( NR ( R, ( R! R3 ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt _set_has_events% s ( R R R t _sa_propagate_class_eventsR& R7 R8 R R� R9 R: R ( ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyR � s ( t
__future__R R1 R� R R R R R t R R t sqlR R� R R� R3 RT RS RV RZ t
IdentifiedR R ( ( ( sI /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyt <module> s4 � � � � � � 4c# � �
Mini Shell