,h%SrSSKJr SSKrSSKrSSKrSSKJr SSKJr SSKJr SSKJ r SSKJ r SS KJ r SS KJ r SS KJ r SS KJr SS KJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSK J!r! SSK J"r" SS K J#r# SS!K Jr SS"K$J%r% SS!K$Jr& \RN(aSS#K J(r( SS$K J)r) SS%KJ*r* SS&KJ+r+ SS'KJ,r, SS(KJ-r- SS)KJ.r. SS*KJ/r/ SS+KJ0r0 SS,KJ1r1 SS-KJ2r2 SS.KJ3r3 SS/KJ4r4 SS0KJ5r5 SS1K6J7r7 SS2K8J9r9 SS3K:J;r; SS4K#Jr> SS6K=J?r? SS7K=J@r@ SS8K$JArA SS9KBJCrC SS:KDJErE SS;KFJGrG SSKKJLrL SS?KKJMrM SS@KKJNrN SSAKOJPrP \"SB\SC9rQ\RrSSD\TSE'\RrUSF\TSG'"SHSI\\"RSJ5rW"SKSL\5rX"SMSN\5rY"SOSP\Y5rZ"SQSR\Y5r["SSST\Z5r\"SUSV\\#R\"RSJ5r^"SWSX\#R5r_"SYSZ\_\^5r`\`\^lag)[zBDefines :class:`_engine.Connection` and :class:`_engine.Engine`. ) annotationsN)Any)Callable)cast)Iterable)Iterator)List)Mapping)NoReturn)Optional)overload)Tuple)Type)TypeVar)Union) BindTyping)ConnectionEventsTarget) DBAPICursor)ExceptionContext) ExecuteStyle)ExecutionContext)IsolationLevel)_distill_params_20)_distill_raw_params)TransactionalContext)exc) inspection)log)util)compiler) CursorResult) ScalarResult)_AnyExecuteParams)_AnyMultiExecuteParams)_CoreAnyExecuteParams)_CoreMultiExecuteParams)_CoreSingleExecuteParams)_DBAPIAnyExecuteParams)_DBAPISingleExecuteParams)_ExecuteOptions)CompiledCacheType)CoreExecuteOptionsParameter)Dialect)SchemaTranslateMapType) Inspector)URL) dispatcher) _EchoFlagType)_ConnectionFairy)Pool)PoolProxiedConnection) Executable) _InfoType)Compiled)ExecutableDDLElement) InvokeDDLBase)FunctionElement)DefaultGenerator) HasSchemaAttr)SchemaVisitable)TypedReturnsRows_T)boundr,_EMPTY_EXECUTION_OPTSzMapping[str, Any] NO_OPTIONSc \rSrSr%SrS\S'S\S'SrSrS \S 'S rS \S 'S\S'S\S'S\S'ScSdSjjr Sr S\S'SeSjr SeSjr \ SfSj5rSgSjrShSjrSiSjr\SSSS S SSSSS S. SjSjj5r\SkS j5rSkS!jrSlS"jr\ SmS#j5r\ SmS$j5r\ SmS%j5r\ SnS&j5rSoS'jr\ SpS(j5rSqS)jrSnS*jr\ SrS+j5rSsStS,jjrSuS-jrSuS.jr SvS/jr!SwS0jr"SsSxS1jjr#SuS2jr$SuS3jr%SyS4jr&SzS{S5jjr'SzS{S6jjr(SmS7jr)SmS8jr*SmS9jr+SvS:jr,SwS;jr-S|S<jr.S}S=jr/S~S>jr0SuS?jr1SuS@jr2SsSSAjjr3SSBjr4SSCjr5SSDjr6SSEjr7SSFjr8SSGjr9SuSHjr:\SsSSI.SSJjjj5r;\SsSSI.SSKjjj5r;SsSSI.SSLjjjr;\SsSSI.SSMjjj5r<\SsSSI.SSNjjj5r<SsSSI.SSOjjjr<\SsSSI.SSPjjj5r=\SsSSI.SSQjjj5r=SsSSI.SSRjjjr=SSSjr>SSTjr?SSUjr@SSVjrASSWjrB\C4SSXjjrDSSSYjjrESSZjrFSS[jrGSS\jrHSsSS]jjrISS^jrJS rKS rLSzSS_jjrM\NSSS`jj5rOSSajrPSbrQg) ConnectionVaProvides high-level functionality for a wrapped DB-API connection. The :class:`_engine.Connection` object is procured by calling the :meth:`_engine.Engine.connect` method of the :class:`_engine.Engine` object, and provides services for execution of SQL statements as well as transaction control. 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 r/dialect"dispatcher[ConnectionEventsTarget]dispatchzsqlalchemy.engine.ConnectionNzOptional[TransactionalContext]_trans_context_managerFOptional[PoolProxiedConnection]_dbapi_connectionr,_execution_optionsOptional[RootTransaction] _transactionOptional[NestedTransaction]_nested_transactioncXlUR=UlnUcUR5UlOX lS=UlUl SUl SUl X@l XPl URR5UlUc*UR R#UR 5UlU=(d USL=(a UR$UlUR&UlUR$(dURR$(aUR R)U5 gg!URR an[ RXvU5 eSnAff=f)zConstruct a new Connection.NrF)enginerIraw_connectionrN loaded_dbapiErrorrG$_handle_dbapi_exception_noconnectionrQrS_Connection__savepoint_seq_Connection__in_begin_Connection__can_reconnect_allow_autobegin_should_log_info_echorK_join _has_eventsrOengine_connect)selfrU connectionra_allow_revalidater]rIerrs N/var/www/auris/envauris/lib/python3.13/site-packages/sqlalchemy/engine/base.py__init__Connection.__init__s3 !'/ w   )/)>)>)@&&0 "7;;D4 0 0[[113  !MM//@DM& 4  6F$6$6 #)";";   t{{66 MM ( ( . 77''-- ??&  sD--E#EE#r_message_formattercURnU(aU"U5n[R(aS[R-US'URR R "U/UQ70UD6 gNr stacklevel)rjr STACKLEVELSTACKLEVEL_OFFSETrUloggerinforcmessageargkwfmts rg _log_infoConnection._log_infosW%% 'lG >> 3#8#88B|  4#44cURnU(aU"U5n[R(aS[R-US'URR R "U/UQ70UD6 grl)rjr rnrorUrpdebugrrs rg _log_debugConnection._log_debugsW%% 'lG >> 3#8#88B|    535"5ryc>URRSS5nU$)Nschema_translate_map)rOget)rcrs rg_schema_translate_map Connection._schema_translate_maps(  # # ' '(> E $#rycURnURRSS5nU(aX#;aUR(aX2$U$)zdReturn the schema name for the given schema item taking into account current schema translate map. rN)schemarOr_use_schema_map)rcobjnamers rgschema_for_objectConnection.schema_for_objectsK zz  # # ' '(> E  !,##'- -KrycU$Nrcs rg __enter__Connection.__enter__s ryc$UR5 gr)close)rctype_value tracebacks rg__exit__Connection.__exit__s  ry.) compiled_cache logging_tokenisolation_level no_parametersstream_resultsmax_row_buffer yield_perinsertmanyvalues_page_sizerpreserve_rowcountc  grr) rcrrrrrrrrrropts rgexecution_optionsConnection.execution_optionssryc grrrcrs rgrrs;>ryc  UR(dURR(aURRX5 URR U5UlUR RX5 U$)a*Set non-SQL options for the connection which take effect during execution. This method modifies this :class:`_engine.Connection` **in-place**; the return value is the same :class:`_engine.Connection` object upon which the method is called. Note that this is in contrast to the behavior of the ``execution_options`` methods on other objects such as :meth:`_engine.Engine.execution_options` and :meth:`_sql.Executable.execution_options`. The rationale is that many such execution options necessarily modify the state of the base DBAPI connection in any case so there is no feasible means of keeping the effect of such an option localized to a "sub" connection. .. versionchanged:: 2.0 The :meth:`_engine.Connection.execution_options` method, in contrast to other objects with this method, modifies the connection in-place without creating copy of it. As discussed elsewhere, the :meth:`_engine.Connection.execution_options` method accepts any arbitrary parameters including user defined names. All parameters given are consumable in a number of ways including by using the :meth:`_engine.Connection.get_execution_options` method. See the examples at :meth:`_sql.Executable.execution_options` and :meth:`_engine.Engine.execution_options`. 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:`_engine.Connection`. :param compiled_cache: Available on: :class:`_engine.Connection`, :class:`_engine.Engine`. A dictionary where :class:`.Compiled` objects will be cached when the :class:`_engine.Connection` compiles a clause expression into a :class:`.Compiled` object. This dictionary will supersede the statement cache that may be configured on the :class:`_engine.Engine` itself. If set to None, caching is disabled, even if the engine has a configured cache size. 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 logging_token: Available on: :class:`_engine.Connection`, :class:`_engine.Engine`, :class:`_sql.Executable`. Adds the specified string token surrounded by brackets in log messages logged by the connection, i.e. the logging that's enabled either via the :paramref:`_sa.create_engine.echo` flag or via the ``logging.getLogger("sqlalchemy.engine")`` logger. This allows a per-connection or per-sub-engine token to be available which is useful for debugging concurrent connection scenarios. .. versionadded:: 1.4.0b2 .. seealso:: :ref:`dbengine_logging_tokens` - usage example :paramref:`_sa.create_engine.logging_name` - adds a name to the name used by the Python logger object itself. :param isolation_level: Available on: :class:`_engine.Connection`, :class:`_engine.Engine`. Set the transaction isolation level for the lifespan of this :class:`_engine.Connection` object. Valid values include those string values accepted by the :paramref:`_sa.create_engine.isolation_level` parameter passed to :func:`_sa.create_engine`. These levels are semi-database specific; see individual dialect documentation for valid levels. The isolation level option applies the isolation level by emitting statements on the DBAPI connection, and **necessarily affects the original Connection object overall**. The isolation level will remain at the given setting until explicitly changed, or when the DBAPI connection itself is :term:`released` to the connection pool, i.e. the :meth:`_engine.Connection.close` method is called, at which time an event handler will emit additional statements on the DBAPI connection in order to revert the isolation level change. .. note:: The ``isolation_level`` execution option may only be established before the :meth:`_engine.Connection.begin` method is called, as well as before any SQL statements are emitted which would otherwise trigger "autobegin", or directly after a call to :meth:`_engine.Connection.commit` or :meth:`_engine.Connection.rollback`. A database cannot change the isolation level on a transaction in progress. .. note:: The ``isolation_level`` execution option is implicitly reset if the :class:`_engine.Connection` is invalidated, e.g. via the :meth:`_engine.Connection.invalidate` method, or if a disconnection error occurs. The new connection produced after the invalidation will **not** have the selected isolation level re-applied to it automatically. .. seealso:: :ref:`dbapi_autocommit` :meth:`_engine.Connection.get_isolation_level` - view current actual level :param no_parameters: Available on: :class:`_engine.Connection`, :class:`_sql.Executable`. 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: :class:`_engine.Connection`, :class:`_sql.Executable`. Indicate to the dialect that results should be "streamed" and not pre-buffered, if possible. For backends such as PostgreSQL, MySQL and MariaDB, this indicates the use of a "server side cursor" as opposed to a client side cursor. Other backends such as that of Oracle Database may already use server side cursors by default. The usage of :paramref:`_engine.Connection.execution_options.stream_results` is usually combined with setting a fixed number of rows to to be fetched in batches, to allow for efficient iteration of database rows while at the same time not loading all result rows into memory at once; this can be configured on a :class:`_engine.Result` object using the :meth:`_engine.Result.yield_per` method, after execution has returned a new :class:`_engine.Result`. If :meth:`_engine.Result.yield_per` is not used, the :paramref:`_engine.Connection.execution_options.stream_results` mode of operation will instead use a dynamically sized buffer which buffers sets of rows at a time, growing on each batch based on a fixed growth size up until a limit which may be configured using the :paramref:`_engine.Connection.execution_options.max_row_buffer` parameter. When using the ORM to fetch ORM mapped objects from a result, :meth:`_engine.Result.yield_per` should always be used with :paramref:`_engine.Connection.execution_options.stream_results`, so that the ORM does not fetch all rows into new ORM objects at once. For typical use, the :paramref:`_engine.Connection.execution_options.yield_per` execution option should be preferred, which sets up both :paramref:`_engine.Connection.execution_options.stream_results` and :meth:`_engine.Result.yield_per` at once. This option is supported both at a core level by :class:`_engine.Connection` as well as by the ORM :class:`_engine.Session`; the latter is described at :ref:`orm_queryguide_yield_per`. .. seealso:: :ref:`engine_stream_results` - background on :paramref:`_engine.Connection.execution_options.stream_results` :paramref:`_engine.Connection.execution_options.max_row_buffer` :paramref:`_engine.Connection.execution_options.yield_per` :ref:`orm_queryguide_yield_per` - in the :ref:`queryguide_toplevel` describing the ORM version of ``yield_per`` :param max_row_buffer: Available on: :class:`_engine.Connection`, :class:`_sql.Executable`. Sets a maximum buffer size to use when the :paramref:`_engine.Connection.execution_options.stream_results` execution option is used on a backend that supports server side cursors. The default value if not specified is 1000. .. seealso:: :paramref:`_engine.Connection.execution_options.stream_results` :ref:`engine_stream_results` :param yield_per: Available on: :class:`_engine.Connection`, :class:`_sql.Executable`. Integer value applied which will set the :paramref:`_engine.Connection.execution_options.stream_results` execution option and invoke :meth:`_engine.Result.yield_per` automatically at once. Allows equivalent functionality as is present when using this parameter with the ORM. .. versionadded:: 1.4.40 .. seealso:: :ref:`engine_stream_results` - background and examples on using server side cursors with Core. :ref:`orm_queryguide_yield_per` - in the :ref:`queryguide_toplevel` describing the ORM version of ``yield_per`` :param insertmanyvalues_page_size: Available on: :class:`_engine.Connection`, :class:`_engine.Engine`. Number of rows to format into an INSERT statement when the statement uses "insertmanyvalues" mode, which is a paged form of bulk insert that is used for many backends when using :term:`executemany` execution typically in conjunction with RETURNING. Defaults to 1000. May also be modified on a per-engine basis using the :paramref:`_sa.create_engine.insertmanyvalues_page_size` parameter. .. versionadded:: 2.0 .. seealso:: :ref:`engine_insertmanyvalues` :param schema_translate_map: Available on: :class:`_engine.Connection`, :class:`_engine.Engine`, :class:`_sql.Executable`. A dictionary mapping schema names to schema names, that will be applied to the :paramref:`_schema.Table.schema` element of each :class:`_schema.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. .. seealso:: :ref:`schema_translating` :param preserve_rowcount: Boolean; when True, the ``cursor.rowcount`` attribute will be unconditionally memoized within the result and made available via the :attr:`.CursorResult.rowcount` attribute. Normally, this attribute is only preserved for UPDATE and DELETE statements. Using this option, the DBAPIs rowcount value can be accessed for other kinds of statements such as INSERT and SELECT, to the degree that the DBAPI supports these statements. See :attr:`.CursorResult.rowcount` for notes regarding the behavior of this attribute. .. versionadded:: 2.0.28 .. seealso:: :meth:`_engine.Engine.execution_options` :meth:`.Executable.execution_options` :meth:`_engine.Connection.get_execution_options` :ref:`orm_queryguide_execution_options` - documentation on all ORM-specific execution options )rarUrK set_connection_execution_optionsrOunionrIrs rgrrs\B   t{{66 MM : :4 E"&"9"9"?"?"D 55d@ rycUR$)zGet the non-SQL options which will take effect during execution. .. versionadded:: 1.3 .. seealso:: :meth:`_engine.Connection.execution_options` rOrs rgget_execution_options Connection.get_execution_options&&&rycHURnUSL=(a UR$r)rNis_validrcpool_proxied_connections rg)_still_open_and_dbapi_connection_is_valid4Connection._still_open_and_dbapi_connection_is_valids)"&"8"8 #4 / 1'00 rycNURSL=(a UR(+$)z)Return True if this connection is closed.NrNr\rs rgclosedConnection.closeds#%%-Jd6J6J2JJrycHURnUSL=(a UR$)zReturn True if this connection was invalidated. This does not indicate whether or not the connection was invalidated at the pool level, however Nrrs rg invalidatedConnection.invalidated s&$#'"8"8&$.G43G3GGrycURcUR5$UR$![R[R4a e[ anUR USSSS5 SnAgSnAff=f)aThe underlying DB-API connection managed by this Connection. This is a SQLAlchemy connection-pool proxied connection which then has the attribute :attr:`_pool._ConnectionFairy.dbapi_connection` that refers to the actual driver connection. .. seealso:: :ref:`dbapi_connections` N)rN_revalidate_connectionrPendingRollbackErrorResourceClosedError BaseException_handle_dbapi_exceptionrces rgrdConnection.connection5s|  ! ! ) H2244 )) ) ,,c.E.EF   H,,QdD$GG Hs+.A8A33A8cURRnUceURRU5$![anUR USSSS5 SnAgSnAff=f)aReturn the current **actual** isolation level that's present on the database within the scope of this connection. This attribute will perform a live SQL operation against the database 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. This will be one of the four actual isolation modes ``READ UNCOMMITTED``, ``READ COMMITTED``, ``REPEATABLE READ``, ``SERIALIZABLE``. It will **not** include the ``AUTOCOMMIT`` isolation level setting. Third party dialects may also feature additional isolation level settings. .. note:: This method **will not report** on the ``AUTOCOMMIT`` isolation level, which is a separate :term:`dbapi` setting that's independent of **actual** isolation level. When ``AUTOCOMMIT`` is in use, the database connection still has a "traditional" isolation mode in effect, that is typically one of the four values ``READ UNCOMMITTED``, ``READ COMMITTED``, ``REPEATABLE READ``, ``SERIALIZABLE``. Compare to the :attr:`_engine.Connection.default_isolation_level` accessor which returns the isolation level that is present on the database at initial connection time. .. seealso:: :attr:`_engine.Connection.default_isolation_level` - view default level :paramref:`_sa.create_engine.isolation_level` - set per :class:`_engine.Engine` isolation level :paramref:`.Connection.execution_options.isolation_level` - set per :class:`_engine.Connection` isolation level N)rddbapi_connectionrIget_isolation_levelrr)rcrrs rgrConnection.get_isolation_levelOshJ ??;;+++ D<<334DE E D  ( (D$d C C Ds8 A!AA!c.URR$)anThe initial-connection time isolation level associated with the :class:`_engine.Dialect` in use. This value is independent of the :paramref:`.Connection.execution_options.isolation_level` and :paramref:`.Engine.execution_options.isolation_level` execution options, and is determined by the :class:`_engine.Dialect` when the first connection is created, by performing a SQL query against the database for the current isolation level before any additional commands have been emitted. Calling this accessor does not invoke any new SQL queries. .. seealso:: :meth:`_engine.Connection.get_isolation_level` - view current actual isolation level :paramref:`_sa.create_engine.isolation_level` - set per :class:`_engine.Engine` isolation level :paramref:`.Connection.execution_options.isolation_level` - set per :class:`_engine.Connection` isolation level )rIdefault_isolation_levelrs rgr"Connection.default_isolation_level{s6||333rycP[R"SURbSOS-SS9e)NzfCan't reconnect until invalid %stransaction is rolled back. Please rollback() fully before proceedingz savepoint 8s2b)code)rrrSrs rg_invalid_transactionConnection._invalid_transactions5&& ?#77C| M   rycUR(aYUR(aHURbUR5 URR 5UlUR $[R"S5e)NThis Connection is closed) r\rrQrrUrVrNrrrs rgr!Connection._revalidate_connections^   D$4$4  ,))+%)[[%?%?%AD ")) )%%&ABBryc.URR$)akInfo dictionary associated with the underlying DBAPI connection referred to by this :class:`_engine.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:`_engine.Connection`. )rdrqrs rgrqConnection.infos###rycUR(agUR(a[R"S5eUR(a"UR nUceUR U5 SUlg)aInvalidate the underlying DBAPI connection associated with this :class:`_engine.Connection`. An attempt will be made to close the underlying DBAPI connection immediately; however if this operation fails, the error is logged but not raised. The connection is then discarded whether or not close() succeeded. Upon the next use (where "use" typically means using the :meth:`_engine.Connection.execute` method or similar), this :class:`_engine.Connection` will attempt to procure a new DBAPI connection using the services of the :class:`_pool.Pool` as a source of connectivity (e.g. a "reconnection"). If a transaction was in progress (e.g. the :meth:`_engine.Connection.begin` method has been called) when :meth:`_engine.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:`_engine.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:`_engine.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:`_engine.Connection.invalidate` method, just like auto-invalidation, will at the connection pool level invoke the :meth:`_events.PoolEvents.invalidate` event. :param exception: an optional ``Exception`` instance that's the reason for the invalidation. is passed along to event handlers and logging functions. .. seealso:: :ref:`pool_connection_invalidation` Nr)rrrrrrN invalidate)rc exceptionrs rgrConnection.invalidatesa\     ;;))*EF F  9 9&*&<&< #*6 66 # . .y 9!%rycUR(a[R"S5eURnUc[R"S5eUR 5 g)aDetach the underlying DB-API connection from its connection pool. E.g.:: with engine.connect() as conn: conn.detach() conn.execute(text("SET search_path TO schema1, schema2")) # work with connection # connection is fully closed (since we used "with:", can # also call .close()) This :class:`_engine.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). rNz&Can't detach an invalidated Connection)rrrrNInvalidRequestErrordetachrs rgrConnection.detachsS4 ;;))*EF F"&"8"8 " *))8  &&(ryclUR(a#UR(dUR5 gggr)r]r[beginrs rg _autobeginConnection._autobegins"   JJL*9 rycURc[U5UlUR$[R"S5e)a)Begin a transaction prior to autobegin occurring. E.g.:: with engine.connect() as conn: with conn.begin() as trans: conn.execute(table.insert(), {"username": "sandy"}) The returned object is an instance of :class:`_engine.RootTransaction`. This object represents the "scope" of the transaction, which completes when either the :meth:`_engine.Transaction.rollback` or :meth:`_engine.Transaction.commit` method is called; the object also works as a context manager as illustrated above. The :meth:`_engine.Connection.begin` method begins a transaction that normally will be begun in any case when the connection is first used to execute a statement. The reason this method might be used would be to invoke the :meth:`_events.ConnectionEvents.begin` event at a specific time, or to organize code within the scope of a connection checkout in terms of context managed blocks, such as:: with engine.connect() as conn: with conn.begin(): conn.execute(...) conn.execute(...) with conn.begin(): conn.execute(...) conn.execute(...) The above code is not fundamentally any different in its behavior than the following code which does not use :meth:`_engine.Connection.begin`; the below style is known as "commit as you go" style:: with engine.connect() as conn: conn.execute(...) conn.execute(...) conn.commit() conn.execute(...) conn.execute(...) conn.commit() From a database point of view, the :meth:`_engine.Connection.begin` method does not emit any SQL or change the state of the underlying DBAPI connection in any way; the Python DBAPI does not have any concept of explicit transaction begin. .. seealso:: :ref:`tutorial_working_with_transactions` - in the :ref:`unified_tutorial` :meth:`_engine.Connection.begin_nested` - use a SAVEPOINT :meth:`_engine.Connection.begin_twophase` - use a two phase /XID transaction :meth:`_engine.Engine.begin` - context manager available from :class:`_engine.Engine` zThis connection has already initialized a SQLAlchemy Transaction() object via begin() or autobegin; can't call begin() here unless rollback() or commit() is called first.)rQRootTransactionrrrs rgrConnection.beginsB@    $ / 5D $$ $))# rycRURcUR5 [U5$)a? Begin a nested transaction (i.e. SAVEPOINT) and return a transaction handle that controls the scope of the SAVEPOINT. E.g.:: with engine.begin() as connection: with connection.begin_nested(): connection.execute(table.insert(), {"username": "sandy"}) The returned object is an instance of :class:`_engine.NestedTransaction`, which includes transactional methods :meth:`_engine.NestedTransaction.commit` and :meth:`_engine.NestedTransaction.rollback`; for a nested transaction, these methods correspond to the operations "RELEASE SAVEPOINT " and "ROLLBACK TO SAVEPOINT ". The name of the savepoint is local to the :class:`_engine.NestedTransaction` object and is generated automatically. Like any other :class:`_engine.Transaction`, the :class:`_engine.NestedTransaction` may be used as a context manager as illustrated above which will "release" or "rollback" corresponding to if the operation within the block were successful or raised an exception. Nested transactions require SAVEPOINT support in the underlying database, else the behavior is undefined. SAVEPOINT is commonly used to run operations within a transaction that may fail, while continuing the outer transaction. E.g.:: from sqlalchemy import exc with engine.begin() as connection: trans = connection.begin_nested() try: connection.execute(table.insert(), {"username": "sandy"}) trans.commit() except exc.IntegrityError: # catch for duplicate username trans.rollback() # rollback to savepoint # outer transaction continues connection.execute(...) If :meth:`_engine.Connection.begin_nested` is called without first calling :meth:`_engine.Connection.begin` or :meth:`_engine.Engine.begin`, the :class:`_engine.Connection` object will "autobegin" the outer transaction first. This outer transaction may be committed using "commit-as-you-go" style, e.g.:: with engine.connect() as connection: # begin() wasn't called with connection.begin_nested(): # will auto-"begin()" first connection.execute(...) # savepoint is released connection.execute(...) # explicitly commit outer transaction connection.commit() # can continue working with connection here .. versionchanged:: 2.0 :meth:`_engine.Connection.begin_nested` will now participate in the connection "autobegin" behavior that is new as of 2.0 / "future" style connections in 1.4. .. seealso:: :meth:`_engine.Connection.begin` :ref:`session_begin_nested` - ORM support for SAVEPOINT )rQrNestedTransactionrs rg begin_nestedConnection.begin_nestedds&R    $ OO  &&rycURb[R"S5eUc$URRR 5n[ X5$)aBegin 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:`_engine.Connection.begin` :meth:`_engine.Connection.begin_twophase` zOCannot start a two phase transaction when a transaction is already in progress.)rQrrrUrI create_xidTwoPhaseTransaction)rcxids rgbegin_twophaseConnection.begin_twophasesR(    ())*  ;++%%002C"4--ryc\UR(aURR5 gg)aCommit the transaction that is currently in progress. This method commits the current transaction if one has been started. If no transaction was started, the method has no effect, assuming the connection is in a non-invalidated state. A transaction is begun on a :class:`_engine.Connection` automatically whenever a statement is first executed, or when the :meth:`_engine.Connection.begin` method is called. .. note:: The :meth:`_engine.Connection.commit` method only acts upon the primary database transaction that is linked to the :class:`_engine.Connection` object. It does not operate upon a SAVEPOINT that would have been invoked from the :meth:`_engine.Connection.begin_nested` method; for control of a SAVEPOINT, call :meth:`_engine.NestedTransaction.commit` on the :class:`_engine.NestedTransaction` that is returned by the :meth:`_engine.Connection.begin_nested` method itself. N)rQcommitrs rgrConnection.commits$,       $ $ & ryc\UR(aURR5 gg)aRoll back the transaction that is currently in progress. This method rolls back the current transaction if one has been started. If no transaction was started, the method has no effect. If a transaction was started and the connection is in an invalidated state, the transaction is cleared using this method. A transaction is begun on a :class:`_engine.Connection` automatically whenever a statement is first executed, or when the :meth:`_engine.Connection.begin` method is called. .. note:: The :meth:`_engine.Connection.rollback` method only acts upon the primary database transaction that is linked to the :class:`_engine.Connection` object. It does not operate upon a SAVEPOINT that would have been invoked from the :meth:`_engine.Connection.begin_nested` method; for control of a SAVEPOINT, call :meth:`_engine.NestedTransaction.rollback` on the :class:`_engine.NestedTransaction` that is returned by the :meth:`_engine.Connection.begin_nested` method itself. N)rQrollbackrs rgrConnection.rollbacks$.       & & ( rycLURRRU5$r)rUrIdo_recover_twophasers rgrecover_twophaseConnection.recover_twophases{{""66t<  9 9 KK   8 8 D :rycUR(dURR(aURRXS5 URRR X5 gr)rarUrKrelease_savepointrIdo_release_savepointr4s rg_release_savepoint_impl"Connection._release_savepoint_implsC   t{{66 MM + +D = 00 D  ( (D$d C C Ds*%B B9B44B9cUR(dURR(aURRXU5 UR(aI[ UR [5(deURRRXU5 gg![anURUSSSS5 SnAgSnAff=fr) rarUrKrollback_twophaserrGrQrrIrrrrcr is_preparedrs rg_rollback_twophase_impl"Connection._rollback_twophase_impls   t{{66 MM + +D{ C  9 9d//1DEE EE H ##88{ : ! H,,QdD$GG Hs<&B$$ C .CC c|UR(dURR(aURRXU5 [ UR [ 5(deURRRXU5 g![anURUSSSS5 SnAgSnAff=fr) rarUrKcommit_twophaserGrQrrIrrrrMs rg_commit_twophase_impl Connection._commit_twophase_impls   t{{66 MM ) )$[ A$++-@AAAA D KK   2 24k J D  ( (D$d C C Ds+&B B;B66B;cUR(aURR5 SnOSnURbDURnU(a[SU5R SS9 OUR5 SUlSUlg)a_Close this :class:`_engine.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.Pool` referenced by the :class:`_engine.Engine` that produced this :class:`_engine.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:`_engine.Connection`. This has the effect of also calling :meth:`_engine.Connection.rollback` if any transaction is in place. After :meth:`_engine.Connection.close` is called, the :class:`_engine.Connection` is permanently in a closed state, and will allow no further operations. TFNr5)transaction_reset)rQrrNr_close_specialr\)rc skip_resetconns rgrConnection.closes.       # # %JJ  ! ! -))D'.==&*> &*D "$ryrcgrrrc statement parametersrs rgscalarConnection.scalarsrycgrrr]s rgr`rasryc[U5nURnU"UUU=(d [5$![an[R "U5UeSnAff=f)aEExecutes a SQL statement construct and returns a scalar object. This method is shorthand for invoking the :meth:`_engine.Result.scalar` method after invoking the :meth:`_engine.Connection.execute` method. Parameters are equivalent. :return: a scalar Python value representing the first column of the first row returned. N)r_execute_on_scalarrEAttributeErrorrObjectNotExecutableErrorrcr^r_rdistilled_parametersmethrfs rgr`rasc" 2*= //D$!/Z  C..y9s B C 0 AAAcgrrr]s rgscalarsConnection.scalarsrycgrrr]s rgrlrm' ryc>URXUS9R5$)aExecutes and returns a scalar result set, which yields scalar values from the first column of each row. This method is equivalent to calling :meth:`_engine.Connection.execute` to receive a :class:`_result.Result` object, then invoking the :meth:`_result.Result.scalars` method to produce a :class:`_result.ScalarResult` instance. :return: a :class:`_result.ScalarResult` .. versionadded:: 1.4.24 r[)executerlr]s rgrlrm0s'*|| 5F ') rycgrrr]s rgrrConnection.executeIrnrycgrrr]s rgrrrtRrpryc[U5nURnU"UUU=(d [5$![an[R "U5UeSnAff=f)aExecutes a SQL statement construct and returns a :class:`_engine.CursorResult`. :param statement: The statement to be executed. This is always an object that is in both the :class:`_expression.ClauseElement` and :class:`_expression.Executable` hierarchies, including: * :class:`_expression.Select` * :class:`_expression.Insert`, :class:`_expression.Update`, :class:`_expression.Delete` * :class:`_expression.TextClause` and :class:`_expression.TextualSelect` * :class:`_schema.DDL` and objects which inherit from :class:`_schema.ExecutableDDLElement` :param parameters: parameters which will be bound into the statement. This may be either a dictionary of parameter names to values, or a mutable sequence (e.g. a list) of dictionaries. When a list of dictionaries is passed, the underlying statement execution will make use of the DBAPI ``cursor.executemany()`` method. When a single dictionary is passed, the DBAPI ``cursor.execute()`` method will be used. :param execution_options: optional dictionary of execution options, which will be associated with the statement execution. This dictionary can provide a subset of the options that are accepted by :meth:`_engine.Connection.execution_options`. :return: a :class:`_engine.Result` object. N)r_execute_on_connectionrErerrfrgs rgrrrt[sdL 2*= 33D$!/Z  C..y9s B CrjcBURUR5X#5$)z%Execute a sql.FunctionElement object.)_execute_clauseelementselect)rcfuncrhrs rg_execute_functionConnection._execute_functions#** KKM/  rycURRU5nUR(dURR(aUR XU5unnnnOS=pEUR nUcUR 5nURnURRXpXc5nWRSUS5n UR(dURR(a UR R#UUUUUU 5 U $![R[R4a e[an URU SSSS5 Sn A NSn A ff=f)z&Execute a schema.ColumnDefault object.N)rO merge_withrarU_invoke_before_exec_eventrNrrIexecution_ctx_cls _init_defaultrrrrr _exec_defaultrK after_execute) rcdefaultrhrevent_multiparams event_paramsrYrIctxrrets rg_execute_defaultConnection._execute_defaultsN!33>>     t{{66 ../@  $! 04 3  D))D|224llG++99tCgt4   t{{66 MM ' '!!   #((#*A*AB   D  ( (D$d C C Ds$AD .E:EEc&URRURU5nUR(dURR(aUR XU5unnnnOS=pVUR SS5nUR nURXS9n URUURRU SUU 5n UR(dURR(a URRUUUUUU 5 U $)zExecute a schema.DDL object.Nr)rIr) rOrrarUrrrIcompile_execute_contextr _init_ddlrKr) rcddlrhr exec_optsrrrrIcompiledrs rg _execute_ddlConnection._execute_ddls**55  # #%6    t{{66 ..9  $! 04 3 (}}-CTJ,,;; ##   % % / /         t{{66 MM ' '!   ryc[U5S:Xa/USpTOU0pTURRHnU"UUUUU5upnM U(a)[U5nU(a[R "S5eO U(aU/nO/nXXE4$)NrrzLEvent handler can't return non-empty multiparams and params at the same time)lenrKbefore_executelistrr)rcelemdistilled_paramsrrrfns rgr$Connection._invoke_before_exec_event s  A %.02B12E|.>|--..B46!! 5 1D\/ #$56 --2  ,~ ! '8FFryc URRURU5nUR=(d URRnU(aUR XU5unnnnU(a[ US5n[ U5S:nO/nSnURn URSS5n URSURR5n URU U UUU URR[R-S9upnURU U RR U UUU UUU US9 nU(a UR"R%UUWWUU5 U$) z#Execute a sql.ClauseElement object.rrFrNr)rIr column_keysfor_executemanyrlinting) cache_hit)rOrrarUrsortedrrIr_compiled_cache_compile_w_cachecompiler_lintingr" WARN_LINTINGrr_init_compiledrKr)rcrrhr has_eventsrrkeysrrIrr compiled_sqlextracted_paramsrrs rgry!Connection._execute_clauseelement3s!33>>  # #%6 %%@)@)@  ..,=  $! .q12D!"67!;OD#O,,044 "D 7H6K6K dkk997 594I4I)+!5LL11H4I4II 5J5 1 ##   % % 4 4     $    MM ' '!!   ryc URRURU5nUR(dURR(aUR XU5unnnnUR nURUURRUUUUUSS5 nUR(dURR(a URRUUWWUU5 U$)zYExecute a sql.Compiled object. TODO: why do we have this? likely deprecate or remove N) rrrOrarUrrIrrrrKr)rcrrhrrrrIrs rg_execute_compiledConnection._execute_compiled|s%66AA  # #%6    t{{66 ..0A  $! ,,##   % % 4 4          t{{66 MM ' '!!   ryc [U5nURRU5nURnUR UUR R USUUU5nU$)a4Executes a string SQL statement on the DBAPI cursor directly, without any SQL compilation steps. This can be used to pass any string directly to the ``cursor.execute()`` method of the DBAPI in use. :param statement: The statement str to be executed. Bound parameters must use the underlying DBAPI's paramstyle, such as "qmark", "pyformat", "format", etc. :param parameters: represent bound parameter values to be used in the execution. The format is one of: a dictionary of named parameters, a tuple of positional parameters, or a list containing either dictionaries or tuples for multiple-execute support. :return: a :class:`_engine.CursorResult`. E.g. multiple dictionaries:: conn.exec_driver_sql( "INSERT INTO table (id, value) VALUES (%(id)s, %(value)s)", [{"id": 1, "value": "v1"}, {"id": 2, "value": "v2"}], ) Single dictionary:: conn.exec_driver_sql( "INSERT INTO table (id, value) VALUES (%(id)s, %(value)s)", dict(id=1, value="v1"), ) Single tuple:: conn.exec_driver_sql( "INSERT INTO table (id, value) VALUES (?, ?)", (1, "v1") ) .. note:: The :meth:`_engine.Connection.exec_driver_sql` method does not participate in the :meth:`_events.ConnectionEvents.before_execute` and :meth:`_events.ConnectionEvents.after_execute` events. To intercept calls to :meth:`_engine.Connection.exec_driver_sql`, use :meth:`_events.ConnectionEvents.before_cursor_execute` and :meth:`_events.ConnectionEvents.after_cursor_execute`. .. seealso:: :pep:`249` N)rrOrrIrr_init_statement)rcr^r_rrhrIrs rgexec_driver_sqlConnection.exec_driver_sqlsmt 3:> 33>>  ,,##   % % 5 5       rycrU(a-URSS5nU(aURSUS.5nURn U cUR5n U"XX/UQ70UD6n UR(aURR(a,UR(a,URR(dUR5 O'UR(a[R "U5 URcUR#5 W R%5 U R&[(R*LaUR-X5$UR/XX45$![R [R 4a e[a)n URU [U5USS5 Sn A GNOSn A ff=f)z\Create an :class:`.ExecutionContext` and execute, returning a :class:`_engine.CursorResult`.rNT)rr)rrrNrrrrrrstrrQrrSrrLr_trans_ctx_checkrpre_exec execute_stylerINSERTMANYVALUES_exec_insertmany_context_exec_single_context) rcrI constructorr^r_rargsruyprYcontextrs rgrConnection._execute_contexts} "&&{D9B$5$;$;'+rB%! ))D|224!t9=ACG   %%//((00::  % % '  ( ( 1 1$ 7    $ OO   L$A$A A00B B,,) 9((#*A*AB     ( (3y>:tT   s,E.F6 F11F6c 0UR[RLa4UR5nU(aUR UR XR5 UR URURpHnUR(dUSn OUn UR(dURR(a6URRHn U "UUUU UUR5upM UR (aUR#U5 UR%5n URR&(d2UR#SU [(R*"U SURS95 OUR#SU 5 Sn UR,[.R0La[3SU 5n UR4R(a;UR4RR6Hn U "UUU U5(dMS n O U (dUR4R7UUU U5 GOU (dUR8(axUR4R(a9UR4RR:Hn U "XxU5(dMS n O U (dUR4R;XxU5 O[3S U 5n UR4R(a;UR4RR<Hn U "UUU U5(dMS n O U (dUR4R=XxX5 UR(dURR(a*URR?UUUU UUR5 URA5 URC5n U $![ a)nURU[U5USU5 SnAGNSnAff=f![ anURXhXU5 SnAW $SnAff=f) zjcontinue the _execute_context() method for a single DBAPI cursor.execute() or cursor.executemany() call. Nr[%s] %r batchesismulti8[%s] [SQL parameters hidden due to hide_parameters=True]Fr(Tr))" bind_typingr SETINPUTSIZES_prepare_set_input_sizesdo_set_input_sizescursorrrrr^r_ executemanyrarUrKbefore_cursor_executer_rw_get_cache_statshide_parameterssql_util _repr_paramsrr EXECUTEMANYrrIdo_executemanyrdo_execute_no_params do_executeafter_cursor_execute post_exec_setup_result_proxy)rcrIrr^r_generic_setinputsizesrr str_statementeffective_parametersrstats evt_handledresults rgrConnection._exec_single_context6s   *":": :$+$D$D$F !$..(= NN       *""#-a= #-   t{{66mm9968!('' 73 3: :: NN= ),,.E;;..)), " ' 3 3N " D $$ (@(@@'+-/C($<<++"ll33BB")0#  +/K!C#LL//%,  *g.C.C<<++"ll33HHfW==*.K!I#LL55w(,.0D($<<++"ll33>>")0#  +/K!?#LL++/C4;;#:#: 22!(''     002F s%003y>:tWh   ( ("6    sEN7A5O-=BO-BO-BO-7 O*O%%O*- P7PPc UR[RLaUR5nOSnURUR UR penUnUR=(d URRnURR(a!URRRn OSn UR(aUR5S-n URRSS5n Sn UR!UUUUUU5GHn U R"(a(UR%URU R"U5 U R.nU R0nU(a-URR2HnU"UUUUUS5unnM UR(aUR5[*R,"U55 S U R6S U R8S U R:(aS OS U R<(aSOSS3nU R6S:XaW U- n OSU3n URR>(d(UR5SU [*R@"USSS95 OUR5SU 5 U HnU"UUUU5(dM O URUUUU5 U(a*URRCUUUUUURD5 U (dGMXRF- n GM URI5 U (aXl%URM5nU$![&aGnUR)U[*R,"U R.5U R0SUSS9 SnAGN5SnAff=f![&a3nUR)U[*R,"U5UUUSS9 SnAGN SnAff=f![&anUR)XXtU5 SnAW$SnAff=f)zcontinue the _execute_context() method for an "insertmanyvalues" operation, which will invoke DBAPI cursor.execute() one or more times with individual log and event hook calls. Nrz (insertmanyvalues)rFrT) is_sub_exec /z (ordered unorderedz; batch not supportedr)rinsertmanyvaluesrrrr)'rrrrrr^r_rarUrIrKrr_rrr!_deliver_insertmanyvalues_batchesprocessed_setinputsizesrrrr_long_statementreplaced_statementreplaced_parametersrrwbatchnum total_batches rows_sorted is_downgradedrrrrcurrent_batch_sizer _rowcountr)rcrIrrrrr_r engine_eventsdo_execute_dispatchrrrowcount imv_batchrsub_stmt sub_paramsr imv_statsrs rgr#Connection._exec_insertmany_contexts   *":": :$+$D$D$F !$( ! NN       * *((CDKK,C,C << # # %%00 #%  ::,,.1FFE#5599   BB    !   I00..!99!33H"66J--==B+- " ,(Hj>zzx77AB !)"4"4!5Q%337 ,,2= !..,  %%*Y&E.yk:E{{22NN! --&$&$)NN0  -B "  .&& " " 22!('' ! 888c f      $,!002F c%00 001M1MN!55$( 1Z! ,,,,X6 $ - >   ( ("6    sT+'L; N$N&N -O; N : 6 ||//\\**556 f== 6 '':O   t{{66 MM . .iWe  7    ( (j'   s% A E E E E0E++E0cUR5 g![a1 URRRR SSS9 gf=f)zLClose the given cursor, catching exceptions and turning into log warnings. zError closing cursorT)exc_infoN)r ExceptionrUpoolrperror)rcrs rg_safe_close_cursorConnection._safe_close_cursorsG   LLN  KK   # # ) )& *  s8A Ac [R"5n[R"U5nUR(d[ XR RR5=(aR UR(+=(a: UR RUUR(d UROSU5=(d U=(a UR(+UlU(+n UbU(+=(a UROSn UR(ar[R R#UUUUR RRUR$R&UR U S9R)US5UeSUl[ XR RR5=(d USL=(a USL=(a U(+n U (ay[R R#UU[+[,U5UR RRUR$R&URUR U S9n OSn Sn UR R.(aUR0R3SS5(d[5UU UR$UR UUUUUURU S5 nUR R6R8HnU"U5nUb U=Uln MM URUR:wa)URUlU (aURU lUR>n U (aU(aURAU5 UR(d=U(aURCU5 URE5(dURG5 U (aU R)US5UeU (aU ceU R)US5UeUSceUSR)US5e![,anUn SnA GM,SnAff=f!U?UR(adU?UR(dPURnUceU (a&UR$RHRKUU5 URMU5 fff=f)NF)rrIrrT)rconnection_invalidatedrIrskip_user_error_eventsr)'sysrr!is_exit_exception_is_disconnectrGrIrWrXr is_disconnectrrNr_reentrant_errorr DBAPIErrorinstancerUrwith_tracebackrrrarOrExceptionContextImplrK handle_errorchained_exceptionrinvalidate_pool_on_disconnecthandle_dbapi_exceptionrrr*r _invalidater)rcrr^r_rrrrr rr should_wrapsqlalchemy_exceptionnewraiserrper_fn_raiseddbapi_conn_wrappers rgr"Connection._handle_dbapi_exceptions*<<> 2215""1ll77==> OLL..262B2BD**#9$7DKK  ->(=%"O 3 3 3   ..)) ))// $ ; ; *nXa[)q 1!%e '%Q (A(A(G(GH%*tO*))  '*~~'>'>A&LL--33$(KK$?$?+/+>+> LL#(? ($(,$H (($2I2I2M2M(%33+(KKLL''1 ,,//< s<<>  &''--7''46 !$8$8$>$>? #&>>#:#:Y"$$**.4.@F**e'4$; $ $(    &$- C&&33  WF);AA-* 4$ 9J9J(J>A>O>O$; ))(1+6A = '3 33&55hqkB IA;* **1+,,Xa[9 9!&HsF// G9GGc LU"SURUS.UD6RU5 g)zrun a DDL visitor. This method is only here so that the MockConnection can change the options given to the visitor so that "checkfirst" is skipped. )rIrdNr)rItraverse_single)rcvisitorcallableelementkwargss rg_run_ddl_visitorConnection._run_ddl_visitor s,  LLT 5; /' "ry)__can_reconnect __in_begin__savepoint_seqr]rNr_rOrar rSr rQrIrKrU)NNTT) rUEnginerdrMraOptional[bool]rerr]r)rsrrtrrurreturnNone)r. Optional[SchemaTranslateMapType])rr?r. Optional[str]r.rG)rrrrrrr.r/)rOptional[CompiledCacheType]rrrrrrrrrintrr4rr4rr0rrrrr.rG)rrr.rGr.r,r.rr.r7)r.r)r.zOptional[IsolationLevel])r.r )r.r9r)rzOptional[BaseException]r.r/r.r/)r.r)r.r)rz Optional[Any]r.r)r.z List[Any]F)rrrrr.r/)r.rP)r.rR)r$rr.r/)rr1r.r)rrr.r/)r$rr.r/)rrr.r/)rrrNrr.r/)r^TypedReturnsRows[Tuple[_T]]r_"Optional[_CoreSingleExecuteParams]r%Optional[CoreExecuteOptionsParameter]r.z Optional[_T])r^r8r_r;rr<r.r)r^r:r_Optional[_CoreAnyExecuteParams]rr<r.zScalarResult[_T])r^r8r_r=rr<r.zScalarResult[Any])r^zTypedReturnsRows[_T]r_r=rr<r.zCursorResult[_T])r^r8r_r=rr<r.CursorResult[Any])r{zFunctionElement[Any]rhr(rr.r.r>)rr>rhr(rr.r.r)rr;rhr(rr.r.r>)rrrr(rr,r.zVTuple[Any, _CoreMultiExecuteParams, _CoreMultiExecuteParams, _CoreSingleExecuteParams])rr8rhr(rr.r.r>)rr:rhr(rr.r.r>)NN)r^rr_ Optional[_DBAPIAnyExecuteParams]rr<r.r>)rIr/rzCallable[..., ExecutionContext]r^Union[str, Compiled]r_ Optional[_AnyMultiExecuteParams]rr,rrrurr.r>) rIr/rrr^r@r_rAr.r>)rIr/rrr.r>) rrr^rr_r+rOptional[ExecutionContext]r.r/)rrr.r/)rrr^r1r_zOptional[_AnyExecuteParams]rOptional[DBAPICursor]rrBrrr.r )NNTF)rrrIr/rUOptional[Engine]r r-rrr rr.r r$zType[InvokeDDLBase]r%r@r&rr.r/)R__name__ __module__ __qualname____firstlineno____doc____annotations___sqla_logger_namespacerLshould_close_with_resultrhrjrwr|propertyrrrrr rrrrrrdrrrrrqrrrrrrrrrrrrr rrrrrr%r*r/r5r:r?rCrIrOrSrr`rlrrr|rrrryrDrrrrrrrr r r classmethodrYr'__static_attributes__rryrgrGrGVs000;>B:A %66''++44 7;&*"&!% +/+/4+/$ +/  +/  +/^#" 5 6$$(7: *-#$!*-AD"'4  (   %(?   >>EN '  KK HH(**2*DX448 C $ $9&v")HIVL'\.:'2)4=MKM    !($,H$D"E= $D HD.%`:> DH .7 A   :> DH 7 A  :> DH 7 A  :7; DH .4 A   7; DH   4 A     7; DH 4 A   27; DH '4 A   7; DH   4 A     7;0 DH 0040 A 0  0d  "  6  7    9!9697 9 9v3 !3637 3  3j(G(G2(G+ (G   (GTGG6G7 G  GZ:O 00607 0  0j8>??//47 77"DN __ ) ) 5 IIH I6ryc2URRUL$r)rdrQrs rgrb,RootTransaction._deactivated_from_connection s++477ryc:URRU5 gr)rdr%rs rgr&RootTransaction._connection_begin_impl s ##D)ryc8URR5 gr)rdr*rs rg_connection_rollback_impl)RootTransaction._connection_rollback_impl s &&(ryc8URR5 gr)rdr/rs rg_connection_commit_impl'RootTransaction._connection_commit_impl s $$&rycvUR(aUR5 URR(a$URRR 5 UR(dU(aUR 5 URR ULaSURlUR(aeURR ULdeg!UR(dU(aUR 5 URR ULaSURlff=fr)rrrdrS_cancelrrQ)rctry_deactivates rg _close_implRootTransaction._close_impl s 4~~..02233;;=~~002++t3/3,>>!!++4777 ~~002++t3/3,4s A C##AD8c$UR5 grrrs rgreRootTransaction._do_close s ryc"URSS9 g)NT)rrrs rgrhRootTransaction._do_rollback s -rycUR(aURRULdeUR5 URR(a$URRR 5 UR 5 SURlOJURRULaURR5 O[R"S5eUR(aeURRULdeg!URR(a$URRR 5 UR 5 f=f)NThis transaction is inactive) rrdrQrrSrrrrrrs rgrkRootTransaction._do_commit s >>??//47 77 3,,. ??66OO77??A002 ,0DOO (++t3446--.LMM>>!!++4777!??66OO77??A002s DAE)Nrr8r6r9)rrr.r/)rFrGrHrIrJrZrWrhrrNrbrrrrrerhrkrPrryrgrrY sU*H+IJ88*)'8 .8ryrc\rSrSr%SrSrS\S'SSjrSSSjjr\ SSj5r SS jr SS jr SS jr SS jrSS jrSrg)ri aPRepresent a 'nested', or SAVEPOINT transaction. The :class:`.NestedTransaction` object is created by calling the :meth:`_engine.Connection.begin_nested` method of :class:`_engine.Connection`. When using :class:`.NestedTransaction`, the semantics of "begin" / "commit" / "rollback" are as follows: * the "begin" operation corresponds to the "BEGIN SAVEPOINT" command, where the savepoint is given an explicit name that is part of the state of this object. * The :meth:`.NestedTransaction.commit` method corresponds to a "RELEASE SAVEPOINT" operation, using the savepoint identifier associated with this :class:`.NestedTransaction`. * The :meth:`.NestedTransaction.rollback` method corresponds to a "ROLLBACK TO SAVEPOINT" operation, using the savepoint identifier associated with this :class:`.NestedTransaction`. The rationale for mimicking the semantics of an outer transaction in terms of savepoints so that code may deal with a "savepoint" transaction and an "outer" transaction in an agnostic way. .. seealso:: :ref:`session_begin_nested` - ORM version of the SAVEPOINT API. )rdr _savepoint_previous_nestedrrcURceUR(a[R"U5 XlURR 5UlSUlURUl Xlgr) rQrLrrrdr5rrrSrr^s rgrhNestedTransaction.__init__ s_&&222  , , 1 1* =$//99; * > >)-&rycURRULaURURlgU(a[R"S5 gg)Nz7nested transaction already deassociated from connection)rdrSrr!r)rcrs rgr-NestedTransaction._deactivate_from_connection s= ?? . .$ 6262G2GDOO /  III ryc2URRUL$r)rdrSrs rgrb.NestedTransaction._deactivated_from_connection s22$>>rycSUlUR5 UR(aURR5 ggNF)rrrrrs rgrNestedTransaction._cancel s7 ((*   ! ! ) ) + !rycUR(aeURR(aJURRR(a%URRUR5 SUlU(aUR US9 UR(aeU(aURR ULdegg!SUlU(aUR US9 ff=f)NF)r)rrdrQr:rrrS)rcdeactivate_from_connectionwarn_already_deactives rgrNestedTransaction._close_impl s MOO00OO00::;;DOOL"DN)006K0L>>!! %??66dB BB & #DN)006K0L*s A6C C,c(URSS5 g)NTFrrs rgreNestedTransaction._do_close s u%ryc(URSS5 grrrs rgrhNestedTransaction._do_rollback s t$rycLUR(a>URRUR5 SUlUR 5 gURR ULaURR 5 g[R"S5e!SUlf=f)NFz#This nested transaction is inactive) rrdr?rrrSrrrrs rgrkNestedTransaction._do_commit" s~ >> '77H "'  , , .22d:446--9"'s %B B#)rrrdrNrT)rrr.r/r6r8)rrrrr.r/)rFrGrHrIrJrWrKrhrrNrbrrrerhrkrPrryrgrr sg>NIO.??,C*.CGKC C(&%ryrch^\rSrSr%SrSrS\S'S U4SjjrS SjrS Sjr S S jr S S jr S r U=r $)ri7 a Represent a two-phase transaction. A new :class:`.TwoPhaseTransaction` object may be procured using the :meth:`_engine.Connection.begin_twophase` method. The interface is the same as that of :class:`.Transaction` with the addition of the :meth:`prepare` method. )r _is_preparedrrc>>SUlX l[TU] U5 gr)rrsuperrh)rcrdr __class__s rgrhTwoPhaseTransaction.__init__F s! $rycUR(d[R"S5eURR UR 5 SUlg)zaPrepare this :class:`.TwoPhaseTransaction`. After a PREPARE, the transaction can be committed. rTN)rrrrdrIrrrs rgprepareTwoPhaseTransaction.prepareK s; ~~))*HI I ..txx8 ryc:URRU5 gr)rdrCrs rgr*TwoPhaseTransaction._connection_begin_implV s ,,T2rycdURRURUR5 gr)rdrOrrrs rgr-TwoPhaseTransaction._connection_rollback_implY s  //$:K:KLrycdURRURUR5 gr)rdrSrrrs rgr+TwoPhaseTransaction._connection_commit_impl\ s  --dhh8I8IJry)rr)rdrGrrr8)rFrGrHrIrJrWrKrhrrrrrP __classcell__)rs@rgrr7 s5(I H% !3MKKryrcn\rSrSr%SrS\S'S\S'\rS\S'S rS \S '\ r S \S 'Sr S\S'S r S \S'Sr S\S'S\S'S\S'S\S'S\S'S \S'S3S4SjjrS5Sjr\S6S j5rS7S!jrS8S"jr\S#S#S#S#S#S$.S9S%jj5r\S:S&j5rS:S'jrS;S(jr\SS,jjr\R>S?S@S-jj5r \R>SAS.j5r!SBS/jr"SCS0jr#SDS1jr$S2r%g)Er,i` a^ 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.Engine` object is instantiated publicly using the :func:`~sqlalchemy.create_engine` function. .. seealso:: :doc:`/core/engines` :ref:`connections_toplevel` rJrKr3rr,rOFrrazType[Connection]_connection_clszsqlalchemy.engine.EnginerrL _is_futureNr0rzType[OptionEngine] _option_clsr/rIr6rr2urlrc XlX0lX lU(aX@lXPlXlUS:wa$[ R"X`RS9Ul OSUl [R"XS9 U(aUR"S0UD6 gg)Nr) size_alertechoflagr) rrrI logging_nameechorr!LRUCache_lru_size_alertrr instance_loggerupdate_execution_options) rcrrIrrrquery_cache_sizerrs rgrhEngine.__init__ s{   ,  . q #'== -A-A$D $(D  D0   ) ) >,= > rycUR5(a1URRS[U5UR5 gg)NziCompiled cache size pruning from %d items to %d. Increase cache size to reduce the frequency of pruning.)r^rprqrcapacity)rccaches rgrEngine._lru_size_alert s<  " " KK  JE    #rycU$)zReturns this :class:`.Engine`. Used for legacy schemes that accept :class:`.Connection` / :class:`.Engine` objects within the same variable. rrs rgrU Engine.engine s  ryc\UR(aURR5 gg)a[Clear the compiled cache associated with the dialect. This applies **only** to the built-in cache that is established via the :paramref:`_engine.create_engine.query_cache_size` parameter. It will not impact any dictionary caches that were passed via the :paramref:`.Connection.execution_options.compiled_cache` parameter. .. versionadded:: 1.4 N)rclearrs rgclear_compiled_cacheEngine.clear_compiled_cache s$     & & ( ryc URRX5 URRU5UlURRX5 g)aUpdate the default execution_options dictionary of this :class:`_engine.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:`_sa.create_engine`. .. seealso:: :meth:`_engine.Connection.execution_options` :meth:`_engine.Engine.execution_options` N)rKset_engine_execution_optionsrOrrIrs rgrEngine.update_execution_options sA" 224="&"9"9"?"?"D 11$J  II   II&&(  %%d+ryc#x# UcUR5nUv SSS5 gUv g!,(df  g=f7fr)connect)rcrdrYs rg_optional_conn_ctx_manager!Engine._optional_conn_ctx_manager s3  4    s:): 7:c## UR5nUR5 Uv SSS5 SSS5 g!,(df  N=f!,(df  g=f7f)aReturn a context manager delivering a :class:`_engine.Connection` with a :class:`.Transaction` established. E.g.:: with engine.begin() as conn: conn.execute(text("insert into table (x, y, z) values (1, 2, 3)")) conn.execute(text("my_special_procedure(5)")) Upon successful operation, the :class:`.Transaction` is committed. If an error is raised, the :class:`.Transaction` is rolled back. .. seealso:: :meth:`_engine.Engine.connect` - procure a :class:`_engine.Connection` from an :class:`_engine.Engine`. :meth:`_engine.Connection.begin` - start a :class:`.Transaction` for a particular :class:`_engine.Connection`. N)rr)rcrYs rgr Engine.begin s92\\^t ^^s/AA :A  A A A  AAc ~UR5nUR"X40UD6 SSS5 g!,(df  g=fr)rr')rcr$r%r&rYs rgr'Engine._run_ddl_visitor s, ZZ\T  ! !/ Ef E\\s. <c$URU5$)aReturn a new :class:`_engine.Connection` object. The :class:`_engine.Connection` acts as a Python context manager, so the typical use of this method looks like:: with engine.connect() as connection: connection.execute(text("insert into table values ('foo')")) connection.commit() Where above, after the block is completed, the connection is "closed" and its underlying DBAPI resources are returned to the connection pool. This also has the effect of rolling back any transaction that was explicitly begun or was begun via autobegin, and will emit the :meth:`_events.ConnectionEvents.rollback` event if one was started and is still in progress. .. seealso:: :meth:`_engine.Engine.begin` )rrs rgrEngine.connect s.##D))ryc6URR5$)aReturn 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:`_engine.Connection` is not needed. When a :class:`_engine.Connection` object is already present, the DBAPI connection is available using the :attr:`_engine.Connection.connection` accessor. .. seealso:: :ref:`dbapi_connections` )rrrs rgrVEngine.raw_connection s,yy  ""ry)rrOrIrrrrr)NNiNF)rr6rIr/rr2rr1rzOptional[_EchoFlagType]rr4rzOptional[Mapping[str, Any]]rr)rzutil.LRUCache[Any, Any]r.r/)r.r,r8rrr.r/)rr3rrrrrr4rr0rrr. OptionEngine)rrr.rr5)r.rr)rrr.r/r)rdrVr.Iterator[Connection])r.r rEr2r7)&rFrGrHrIrJrKrDrOrarGrrLrrrhrrNrUrrr rrrrr echo_propertyrrr contextlibcontextmanagerrrr'rrVrPrryrgr,r,` sD 1000*??K(2O%2"<C<J>B;B##  J H'+(, #9= %??? ? $ ? & ??7??8 )=*7: *-*-AD 4   (  %( ?     @@N+` '!!##    D*(,T15. 8F,F!F F  F*2#ryr,c\rSrSr%SrS\S'S\S'S\S'S \S 'S \S 'S \S'S\S'SSjrSSjr\R(d?\ SSj5r \ RSSj5r \ SSj5r \ RSSj5r SrgSrg)OptionEngineMixini FrJrKr3rr/rIr6rr2rrrzlog.echo_propertyrcXlURUlURUlURUlURUlUR UlUR Ul[R"XRS9 URRUR5Ul URUl UR"S0UD6 g)Nrr) _proxiedrrIrrrrr rrKr`rOr)rcproxiedrs rgrhOptionEngineMixin.__init__ s ;; #00LL &66&66 D995 ++G,<,<= ")"<"< %%:(9:ryc [5err\rs rgr*OptionEngineMixin.update_execution_options r`ryc.URR$rrrrs rgrOptionEngineMixin.pool s==%% %ryc$XRlgrr)rcrs rgrr s !%MM ryctURR=(d URRSS5$)NraF)rra__dict__rrs rgraOptionEngineMixin._has_events s/==,, 0A0Au1 ryc XRS'g)Nra)r)rcrs rgrar s+0MM- (ry) rrOrrIrKrrrrN)rr,rr.r)r.r6)rr6r.r/r6)rrr.r/)rFrGrHrI_sa_propagate_class_eventsrKrhrtyping TYPE_CHECKINGrNrsetterrarPrryrgrr s!&0000  J H ;;2M;:$     &  &  &  &        1  1% ryrc\rSrSrSSjrSrg)ri% c 2[R"U40UD6 gr)r,rrs rgr%OptionEngine.update_execution_options& s''44ryrNr)rFrGrHrIrrPrryrgrr% s5ryr)brJ __future__rr r rrrrrrr r r r r rrrr interfacesrrrrrrrr!rrrrrrr sqlr"rrr#r$r%r&r'r(r)r*r+r,r-r.r/r0 reflectionr1rr2eventr3r4rr5r6r7r8 sql._typingr9 sql.compilerr:sql.ddlr;r< sql.functionsr= sql.schemar>r?r@sql.selectablerArB EMPTY_DICTrDrKrE InspectablerGrrYrrr Identifiedr,rrrrryrgr2s# ".#($(&$%&" -213425+-7#2%"#', ''.'/-*,1 T)-8 $ /A%#')?)? )LA%#HJ,'+,'^M&M`i8ki8Xo od&K/&KRA#CNNJ,B,B;,OA#H >1>1B5$f5 "ry