sqlalchemy :: engine :: threadlocal :: TLEngine :: Class TLEngine

Class TLEngine

      object --+        
               |        
base.Connectable --+    
                   |    
      object --+   |    
               |   |    
  log.Identified --+    
                   |    
         base.Engine --+
                       |
                      TLEngine

An Engine that includes support for thread-local managed transactions.

Instance Methods

__init__(self, *args, **kwargs)
x.__init__(...) initializes x; see help(type(x)) for signature

__repr__(self)
repr(x)

begin(self)

begin_nested(self)

begin_twophase(self, xid=None)

close(self)

commit(self)

contextual_connect(self, **kw)
Return a Connection object which may be newly allocated, or may be part of some ongoing context.

dispose(self)
Dispose of the connection pool used by this :class:`Engine`.

prepare(self)

rollback(self)

Inherited from base.Engine: connect, create, drop, execute, has_table, raw_connection, reflecttable, run_callable, scalar, table_names, text, transaction, update_execution_options

Inherited from log.Identified: logging_name

Inherited from object: __delattr__, __format__, __getattribute__, __hash__, __new__, __reduce__, __reduce_ex__, __setattr__, __sizeof__, __str__, __subclasshook__

Class Variables
Inherited from `base.Engine`: `echo`

Properties

closed

Inherited from base.Engine: driver, func, name

Inherited from object: __class__

Method Details

init(self, *args, **kwargs)
(Constructor)

x.__init__(...) initializes x; see help(type(x)) for signature

Overrides: object.__init__: (inherited documentation)

repr(self)
(Representation operator)

repr(x)

Overrides: object.__repr__: (inherited documentation)

contextual_connect(self, **kw)

Return a Connection object which may be newly allocated, or may be part of some ongoing context.

This Connection is meant to be used by the various "auto-connecting" operations.

Overrides: base.Connectable.contextual_connect: (inherited documentation)

dispose(self)

Dispose of the connection pool used by this :class:`Engine`.

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.   

This method has two general use cases:

 * When a dropped connection is detected, it is assumed that all
   connections held by the pool are potentially dropped, and 
   the entire pool is replaced.
   
 * An application may want to use :meth:`dispose` within a test 
   suite that is creating multiple engines.
   
It is critical to note that :meth:`dispose` does **not** guarantee
that the application will release all open database connections - only
those connections that are checked into the pool are closed.   
Connections which remain checked out or have been detached from
the engine are not affected.

Overrides: base.Engine.dispose: (inherited documentation)

Property Details

closed

Get Method:: unreachable.closed(self)

Class TLEngine

__init__(self, *args, **kwargs) (Constructor)

__repr__(self) (Representation operator)

contextual_connect(self, **kw)

dispose(self)

closed

init(self, *args, **kwargs)
(Constructor)

repr(self)
(Representation operator)