U
|
¸ý°dK¹ ã @ sº d dl mZ d dlZd dlZd dlmZ d dlmZ d dlmZ d dlmZ d dlm Z d dlm
|
Z
|
d d lm Z d d
|
lm Z d d lm Z d d lmZ d d lmZ d dlmZ d dlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ddlm Z ddlmZ ddlm Z ddlm Z dd l m!Z! dd l m"Z# dd l m$Z% dd l m&Z& dd l'm(Z( dd!l'm)Z) dd"l*m+Z+ erbdd#l,m-Z- dd$l.m/Z/ dd%l.m0Z0 dd&l.m1Z1 dd'l.m2Z2 dd(l.m3Z3 dd)l.m4Z4 dd*l.m5Z5 dd+l.m6Z6 dd,l.m7Z7 dd-l8m9Z9 dd.l:m;Z; dd/l<m=Z= dd0l<m>Z> dd1l?m@Z@ dd2lAmBZB dd3lCmDZD ed4ed5ZEd6d7d8d9d:d;ZFdnd=d>d7d8d?d@dAZGd6d7dBdCdDdEZHG dFdG dGZIe jJe!dHdIg g dJdKdLdMgdNG dOdP dPee! edP eIZKe jJe&dQdRg dSdTdUgdVdWdLdXdYdZd[gdNG d\d8 d8ee& eIZLG d]d^ d^ee) ed^ ZMe d8d_d`dadbZNe dPdcd`dddbZNdedfd`dgdbZNe OeK¡dPdhdidjdkZPe OeL¡d8dhdidldmZQdS )oé )Ú annotationsN)ÚAny)Ú AsyncIterator)ÚCallable)ÚDict)Ú Generator)ÚNoReturn)ÚOptional)Úoverload)ÚTuple)ÚType)Ú TYPE_CHECKING)ÚTypeVar)ÚUnioné )Úexc)Úasyncstartablecontext)ÚGeneratorStartableContext)ÚProxyComparable)ÚStartableContext)Ú_ensure_sync_result)Ú AsyncResult)ÚAsyncScalarResulté )Ú
|
inspection)Úutil)Ú
|
Connection)Ú create_engine)Úcreate_pool_from_url)ÚEngine)ÚNestedTransaction)Ú Transaction)Úgreenlet_spawn)Ú CursorResult)Ú_CoreAnyExecuteParams)Ú_CoreSingleExecuteParams)Ú_DBAPIAnyExecuteParams)Ú_ExecuteOptions)ÚCompiledCacheType)ÚCoreExecuteOptionsParameter)ÚDialect)ÚIsolationLevel)ÚSchemaTranslateMapType)Ú ScalarResult)ÚURL)ÚPool)ÚPoolProxiedConnection)Ú _InfoType)Ú
|
Executable)ÚTypedReturnsRowsÚ_T)ÚboundzUnion[str, URL]r Ú AsyncEngine)ÚurlÚkwÚreturnc K s2 | dd¡rt d¡d|d< t| f|}t|S )aE Create a new async engine instance.
|
|
Arguments passed to :func:`_asyncio.create_async_engine` are mostly
|
identical to those passed to the :func:`_sa.create_engine` function.
|
The specified dialect must be an asyncio-compatible dialect
|
such as :ref:`dialect-postgresql-asyncpg`.
|
|
.. versionadded:: 1.4
|
|
Zserver_side_cursorsFz}Can't set server_side_cursors for async engine globally; use the connection.stream() method for an async streaming result setTÚ _is_async)ÚgetÚ async_excZAsyncMethodRequiredÚ_create_enginer6 )r7 r8 Ú sync_engine© r? úTd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/ext/asyncio/engine.pyÚcreate_async_engineB s ÿ rA ú sqlalchemy.zDict[str, Any]Ústr)Ú configurationÚprefixÚkwargsr9 c s> fdd| ¡ D }d|d< | |¡ | d¡}t|f|S )a¬ Create a new AsyncEngine instance using a configuration dictionary.
|
|
This function is analogous to the :func:`_sa.engine_from_config` function
|
in SQLAlchemy Core, except that the requested dialect must be an
|
asyncio-compatible dialect such as :ref:`dialect-postgresql-asyncpg`.
|
The argument signature of the function is identical to that
|
of :func:`_sa.engine_from_config`.
|
|
.. versionadded:: 1.4.29
|
|
c s, i | ]$\}}| ¡r|t d
|qS ©N)Ú
|
startswithÚlen)Ú.0ÚkeyÚvalue©rE r? r@ Ú
|
<dictcomp>g s
|
þ z,async_engine_from_config.<locals>.<dictcomp>TZ_coerce_configr7 )ÚitemsÚupdateÚpoprA )rD rE rF Úoptionsr7 r? rM r@ Úasync_engine_from_configY s
|
þ
|
|
rS r/ )r7 rF r9 c K s d|d< t | f|S )aV Create a new async engine instance.
|
|
Arguments passed to :func:`_asyncio.create_async_pool_from_url` are mostly
|
identical to those passed to the :func:`_sa.create_pool_from_url` function.
|
The specified dialect must be an asyncio-compatible dialect
|
such as :ref:`dialect-postgresql-asyncpg`.
|
|
.. versionadded:: 2.0.10
|
|
Tr: )Ú_create_pool_from_url)r7 rF r? r? r@ Úcreate_async_pool_from_urlr s rU c @ s" e Zd ZdZeddddZdS )ÚAsyncConnectable)Z_slots_dispatchÚ __weakref__r ©r9 c C s t dd S )Nz asynchronous events are not implemented at this time. Apply synchronous listeners to the AsyncEngine.sync_engine or AsyncConnection.sync_connection attributes.)ÚNotImplementedError)Úclsr? r? r@ Ú_no_async_engine_events s ÿz(AsyncConnectable._no_async_engine_eventsN)Ú__name__Ú
|
__module__Ú __qualname__Ú __slots__Ú classmethodr[ r? r? r? r@ rV s rV z:class:`_engine.Connection`z!:class:`_asyncio.AsyncConnection`ÚclosedÚ invalidatedÚdialectÚdefault_isolation_level)Z classmethodsÚmethodsÚ
|
attributesc @ s" e Zd ZU dZdZddddddZded < d
|
ed < ed d d ddZddd dddZ e
|
ddddZ ddddZ e jd dd d Ze jd dd d Zd!dd"d#Zd!dd$d%Zdd&d'd(d)d*Zd+dd,d-Zddd.d/Zddd0d1Zd2dd3d4Zd2dd5d6Zed7d7d7ddd7d7d7d7d8 d9d:d+ddd;d;d;d<d=d d> d?d@Zed=d dAdBd@Zd=d dAdCd@Zd'ddDdEZd'ddFdGZ d'ddHdIZ dd:dJdKdLdMdNdOZ edddPdQdRdKdSdMdTdUZ edddPdVdRdKdWdMdXdUZ e dddPdVdRdKdYdMdZdUZ edddPdQdRdKd[dMd\d]Z!edddPdVdRdKdLdMd^d]Z!dddPdVdRdKdLdMd_d]Z!edddPd`dadKdbdMdcddZ"edddPdVdadKd=dMdeddZ"dddPdVdadKd=dMdfddZ"edddPd`dRdKdgdMdhdiZ#edddPdVdRdKdjdMdkdiZ#dddPdVdRdKdjdMdldiZ#edddPd`dadKdmdMdndoZ$edddPdVdadKdpdMdqdoZ$e dddPdVdadKdrdMdsdoZ$dtd=d=d=dudvdwZ%dxddydzZ&d=d=d=d'd{d|d}Z'e
|
d=dd~dZ(e
|
d=dddZ)e
|
d=dddZ*e*j+d=d'dd
dZ*e
|
d=dddZ,dS )ÚAsyncConnectionaà An asyncio proxy for a :class:`_engine.Connection`.
|
|
:class:`_asyncio.AsyncConnection` is acquired using the
|
:meth:`_asyncio.AsyncEngine.connect`
|
method of :class:`_asyncio.AsyncEngine`::
|
|
from sqlalchemy.ext.asyncio import create_async_engine
|
engine = create_async_engine("postgresql+asyncpg://user:pass@host/dbname")
|
|
async with engine.connect() as conn:
|
result = await conn.execute(select(table))
|
|
.. versionadded:: 1.4
|
|
)Úenginer> Úsync_connectionNr6 zOptional[Connection])Ú async_engineri c C s || _ |j| _| |¡| _d S rG )rh r> Ú_assign_proxiedri )Úselfrj ri r? r? r@ Ú__init__º s zAsyncConnection.__init__ri r r> r ©Útargetr9 c C s t t |j¡|S rG )rg r6 Ú_retrieve_proxy_for_targetrh ©rZ ro r? r? r@ Ú _regenerate_proxy_for_targetÜ s
|
ÿz,AsyncConnection._regenerate_proxy_for_targetFÚbool©Ú is_ctxmanagerr9 c à s. | j rt d¡| t| jjI dH ¡| _ | S )zzStart this :class:`_asyncio.AsyncConnection` object's context
|
outside of using a Python ``with:`` block.
|
|
z connection is already startedN)ri r ÚInvalidRequestErrorrk r" r> Úconnect©rl ru r? r? r@ Ústartä s
|
ÿzAsyncConnection.startr rX c C s t d¡dS )zeNot implemented for async; call
|
:meth:`_asyncio.AsyncConnection.get_raw_connection`.
|
z¡AsyncConnection.connection accessor is not implemented as the attribute may need to reconnect on an invalidated connection. Use the get_raw_connection() method.N)r rv ©rl r? r? r@ Ú
|
connectionð s ÿzAsyncConnection.connectionr0 c à s t t| jdI dH S )a Return the pooled DBAPI-level connection in use by this
|
:class:`_asyncio.AsyncConnection`.
|
|
This is a SQLAlchemy connection-pool proxied connection
|
which then has the attribute
|
:attr:`_pool._ConnectionFairy.driver_connection` that refers to the
|
actual driver connection. Its
|
:attr:`_pool._ConnectionFairy.dbapi_connection` refers instead
|
to an :class:`_engine.AdaptedConnection` instance that
|
adapts the driver connection to the DBAPI protocol.
|
|
r{ N)r" ÚgetattrÚ_proxiedrz r? r? r@ Úget_raw_connectionû s z"AsyncConnection.get_raw_connectionr1 c C s | j jS )a Return the :attr:`_engine.Connection.info` dictionary of the
|
underlying :class:`_engine.Connection`.
|
|
This dictionary is freely writable for user-defined state to be
|
associated with the database connection.
|
|
This attribute is only available if the :class:`.AsyncConnection` is
|
currently connected. If the :attr:`.AsyncConnection.closed` attribute
|
is ``True``, then accessing this attribute will raise
|
:class:`.ResourceClosedError`.
|
|
.. versionadded:: 1.4.0b2
|
|
)r} Úinforz r? r? r@ r s zAsyncConnection.infoc C s | j s| ¡ | j S rG )ri Ú_raise_for_not_startedrz r? r? r@ r} s zAsyncConnection._proxiedÚAsyncTransactionc C s | j s
|
tt| S )z1Begin a transaction prior to autobegin occurring.©r} ÚAssertionErrorr rz r? r? r@ Úbegin# s
|
zAsyncConnection.beginc C s | j s
|
tt| ddS )z;Begin a nested transaction and return a transaction handle.T)Únestedr rz r? r? r@ Ú begin_nested( s
|
z AsyncConnection.begin_nestedzOptional[BaseException]ÚNone)Ú exceptionr9 c à s t | jj|dI dH S )zÔInvalidate the underlying DBAPI connection associated with
|
this :class:`_engine.Connection`.
|
|
See the method :meth:`_engine.Connection.invalidate` for full
|
detail on this method.
|
|
)r N)r" r} Ú
|
invalidate)rl r r? r? r@ r - s ÿzAsyncConnection.invalidater+ c à s t | jjI d H S rG )r" r} Úget_isolation_levelrz r? r? r@ r = s z#AsyncConnection.get_isolation_levelc C s
|
| j ¡ S )z,Return True if a transaction is in progress.)r} Úin_transactionrz r? r? r@ r @ s z AsyncConnection.in_transactionc C s
|
| j ¡ S )zYReturn True if a transaction is in progress.
|
|
.. versionadded:: 1.4.0b2
|
|
)r} Úin_nested_transactionrz r? r? r@ r E s z%AsyncConnection.in_nested_transactionzOptional[AsyncTransaction]c C s$ | j ¡ }|dk r t |¡S dS dS )a Return an :class:`.AsyncTransaction` representing the current
|
transaction, if any.
|
|
This makes use of the underlying synchronous connection's
|
:meth:`_engine.Connection.get_transaction` method to get the current
|
:class:`_engine.Transaction`, which is then proxied in a new
|
:class:`.AsyncTransaction` object.
|
|
.. versionadded:: 1.4.0b2
|
|
N)r} Úget_transactionr rp ©rl Ztransr? r? r@ r M s
|
|
z AsyncConnection.get_transactionc C s$ | j ¡ }|dk r t |¡S dS dS )a¡ Return an :class:`.AsyncTransaction` representing the current
|
nested (savepoint) transaction, if any.
|
|
This makes use of the underlying synchronous connection's
|
:meth:`_engine.Connection.get_nested_transaction` method to get the
|
current :class:`_engine.Transaction`, which is then proxied in a new
|
:class:`.AsyncTransaction` object.
|
|
.. versionadded:: 1.4.0b2
|
|
N)r} Úget_nested_transactionr rp r r? r? r@ r ` s
|
|
z&AsyncConnection.get_nested_transaction.) Úcompiled_cacheÚ logging_tokenÚisolation_levelÚ no_parametersÚstream_resultsÚmax_row_bufferÚ yield_perÚinsertmanyvalues_page_sizeÚschema_translate_mapúOptional[CompiledCacheType]rC Úintú Optional[SchemaTranslateMapType]r ) r r r r r r r r r Úoptr9 c Ë s d S rG r? ) rl r r r r r r r r r r r? r? r@ Úexecution_optionss s z!AsyncConnection.execution_options©r r9 c Ë s d S rG r? ©rl r r? r? r@ r s c Ë s* | j }t|jf|I dH }||ks&t| S )a' Set non-SQL options for the connection which take effect
|
during execution.
|
|
This returns this :class:`_asyncio.AsyncConnection` object with
|
the new options added.
|
|
See :meth:`_engine.Connection.execution_options` for full details
|
on this method.
|
|
N)r} r" r r )rl r ÚconnÚc2r? r? r@ r s c à s t | jjI dH dS )aÓ Commit 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.
|
|
N©r" r} Úcommitrz r? r? r@ r£ s zAsyncConnection.commitc à s t | jjI dH dS )a& Roll 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.
|
|
|
N©r" r} Úrollbackrz r? r? r@ r¥ § s zAsyncConnection.rollbackc à s t | jjI dH dS )zClose this :class:`_asyncio.AsyncConnection`.
|
|
This has the effect of also rolling back the transaction if one
|
is in place.
|
|
N©r" r} Úcloserz r? r? r@ r§ · s zAsyncConnection.closez Optional[_DBAPIAnyExecuteParams]z%Optional[CoreExecuteOptionsParameter]zCursorResult[Any])Ú statementÚ
|
parametersr r9 c à s. t | jj|||ddI dH }t|| jI dH S )zaExecutes a driver-level SQL string and return buffered
|
:class:`_engine.Result`.
|
|
T)Ú_require_awaitN)r" r} Úexec_driver_sqlr ©rl r¨ r© r Úresultr? r? r@ r« À s û z AsyncConnection.exec_driver_sql©r zTypedReturnsRows[_T]z Optional[_CoreAnyExecuteParams]z*GeneratorStartableContext[AsyncResult[_T]]c C s d S rG r? ©rl r¨ r© r r? r? r@ ÚstreamÕ s zAsyncConnection.streamr2 z+GeneratorStartableContext[AsyncResult[Any]]c C s d S rG r? r¯ r? r? r@ r° ß s z AsyncIterator[AsyncResult[Any]]c C s t | jj||tj |ddi¡ddI dH }|jjs6tt |}z
|
|V W n t
|
k
|
r\ Y n X t | ¡ ¡}t |¡I dH dS )aL Execute a statement and return an awaitable yielding a
|
:class:`_asyncio.AsyncResult` object.
|
|
E.g.::
|
|
result = await conn.stream(stmt):
|
async for row in result:
|
print(f"{row}")
|
|
The :meth:`.AsyncConnection.stream`
|
method supports optional context manager use against the
|
:class:`.AsyncResult` object, as in::
|
|
async with conn.stream(stmt) as result:
|
async for row in result:
|
print(f"{row}")
|
|
In the above pattern, the :meth:`.AsyncResult.close` method is
|
invoked unconditionally, even if the iterator is interrupted by an
|
exception throw. Context manager use remains optional, however,
|
and the function may be called in either an ``async with fn():`` or
|
``await fn()`` style.
|
|
.. versionadded:: 2.0.0b3 added context manager support
|
|
|
:return: an awaitable object that will yield an
|
:class:`_asyncio.AsyncResult` object.
|
|
.. seealso::
|
|
:meth:`.AsyncConnection.stream_scalars`
|
|
r T©r rª N)r" r} Úexecuter Ú
|
EMPTY_DICTZ
|
merge_withÚcontextZ_is_server_sider r Ú GeneratorExitÚasyncioÚ create_taskr§ Úshield)rl r¨ r© r r ÚarÚtaskr? r? r@ r° é s$ + ÿù
|
zCursorResult[_T]c à s d S rG r? r¯ r? r? r@ r² ' s zAsyncConnection.executec à s d S rG r? r¯ r? r? r@ r² 1 s c à s. t | jj|||ddI dH }t|| jI dH S )a» Executes a SQL statement construct and return a buffered
|
:class:`_engine.Result`.
|
|
:param object: 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.
|
|
Tr± N)r" r} r² r r¬ r? r? r@ r² ; s &û zTypedReturnsRows[Tuple[_T]]z"Optional[_CoreSingleExecuteParams]z Optional[_T]c à s d S rG r? r¯ r? r? r@ Úscalarj s zAsyncConnection.scalarc à s d S rG r? r¯ r? r? r@ r» t s c à s | j |||dI dH }| ¡ S )au Executes 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.
|
|
r® N)r² r» r¬ r? r? r@ r» ~ s ÿ zScalarResult[_T]c à s d S rG r? r¯ r? r? r@ Úscalars s zAsyncConnection.scalarszScalarResult[Any]c à s d S rG r? r¯ r? r? r@ r¼ s c à s | j |||dI dH }| ¡ S )ai Executes a SQL statement construct and returns a scalar objects.
|
|
This method is shorthand for invoking the
|
:meth:`_engine.Result.scalars` method after invoking the
|
:meth:`_engine.Connection.execute` method. Parameters are equivalent.
|
|
:return: a :class:`_engine.ScalarResult` object.
|
|
.. versionadded:: 1.4.24
|
|
r® N)r² r¼ r¬ r? r? r@ r¼ ¨ s ÿ z0GeneratorStartableContext[AsyncScalarResult[_T]]c C s d S rG r? r¯ r? r? r@ Ústream_scalars¿ s z AsyncConnection.stream_scalarsz1GeneratorStartableContext[AsyncScalarResult[Any]]c C s d S rG r? r¯ r? r? r@ r½ É s z%AsyncIterator[AsyncScalarResult[Any]]c
|
C s8 | j |||d4 I dH }| ¡ V W 5 Q I dH R X dS )af Execute a statement and return an awaitable yielding a
|
:class:`_asyncio.AsyncScalarResult` object.
|
|
E.g.::
|
|
result = await conn.stream_scalars(stmt)
|
async for scalar in result:
|
print(f"{scalar}")
|
|
This method is shorthand for invoking the
|
:meth:`_engine.AsyncResult.scalars` method after invoking the
|
:meth:`_engine.Connection.stream` method. Parameters are equivalent.
|
|
The :meth:`.AsyncConnection.stream_scalars`
|
method supports optional context manager use against the
|
:class:`.AsyncScalarResult` object, as in::
|
|
async with conn.stream_scalars(stmt) as result:
|
async for scalar in result:
|
print(f"{scalar}")
|
|
In the above pattern, the :meth:`.AsyncScalarResult.close` method is
|
invoked unconditionally, even if the iterator is interrupted by an
|
exception throw. Context manager use remains optional, however,
|
and the function may be called in either an ``async with fn():`` or
|
``await fn()`` style.
|
|
.. versionadded:: 2.0.0b3 added context manager support
|
|
:return: an awaitable object that will yield an
|
:class:`_asyncio.AsyncScalarResult` object.
|
|
.. versionadded:: 1.4.24
|
|
.. seealso::
|
|
:meth:`.AsyncConnection.stream`
|
|
r® N)r° r¼ r¬ r? r? r@ r½ Ó s 0 ÿzCallable[..., Any])ÚfnÚargr8 r9 c Ï s t || jf||I dH S )aY Invoke the given synchronous (i.e. not async) callable,
|
passing a synchronous-style :class:`_engine.Connection` as the first
|
argument.
|
|
This method allows traditional synchronous SQLAlchemy functions to
|
run within the context of an asyncio application.
|
|
E.g.::
|
|
def do_something_with_core(conn: Connection, arg1: int, arg2: str) -> str:
|
'''A synchronous function that does not require awaiting
|
|
:param conn: a Core SQLAlchemy Connection, used synchronously
|
|
:return: an optional return value is supported
|
|
'''
|
conn.execute(
|
some_table.insert().values(int_col=arg1, str_col=arg2)
|
)
|
return "success"
|
|
|
async def do_something_async(async_engine: AsyncEngine) -> None:
|
'''an async function that uses awaiting'''
|
|
async with async_engine.begin() as async_conn:
|
# run do_something_with_core() with a sync-style
|
# Connection, proxied into an awaitable
|
return_code = await async_conn.run_sync(do_something_with_core, 5, "strval")
|
print(return_code)
|
|
This method maintains the asyncio event loop all the way through
|
to the database connection by running the given callable in a
|
specially instrumented greenlet.
|
|
The most rudimentary use of :meth:`.AsyncConnection.run_sync` is to
|
invoke methods such as :meth:`_schema.MetaData.create_all`, given
|
an :class:`.AsyncConnection` that needs to be provided to
|
:meth:`_schema.MetaData.create_all` as a :class:`_engine.Connection`
|
object::
|
|
# run metadata.create_all(conn) with a sync-style Connection,
|
# proxied into an awaitable
|
with async_engine.begin() as conn:
|
await conn.run_sync(metadata.create_all)
|
|
.. note::
|
|
The provided callable is invoked inline within the asyncio event
|
loop, and will block on traditional IO calls. IO within this
|
callable should only call into SQLAlchemy's asyncio database
|
APIs which will be properly adapted to the greenlet context.
|
|
.. seealso::
|
|
:meth:`.AsyncSession.run_sync`
|
|
:ref:`session_run_sync`
|
|
N)r" r} )rl r¾ r¿ r8 r? r? r@ Úrun_sync s AzAsyncConnection.run_syncz%Generator[Any, None, AsyncConnection]c C s | ¡ ¡ S rG )ry Ú __await__rz r? r? r@ rÁ K s zAsyncConnection.__await__©Útype_rL Ú tracebackr9 c à s" t | ¡ ¡}t |¡I d H d S rG )r¶ r· r§ r¸ )rl rà rL rÄ rº r? r? r@ Ú __aexit__N s zAsyncConnection.__aexit__c C s | j jS )zÜReturn True if this connection is closed.
|
|
.. container:: class_bases
|
|
Proxied for the :class:`_engine.Connection` class
|
on behalf of the :class:`_asyncio.AsyncConnection` class.
|
|
)r} ra rz r? r? r@ ra W s zAsyncConnection.closedc C s | j jS )aT Return True if this connection was invalidated.
|
|
.. container:: class_bases
|
|
Proxied for the :class:`_engine.Connection` class
|
on behalf of the :class:`_asyncio.AsyncConnection` class.
|
|
This does not indicate whether or not the connection was
|
invalidated at the pool level, however
|
|
|
)r} rb rz r? r? r@ rb d s zAsyncConnection.invalidatedc C s | j jS )zProxy for the :attr:`_engine.Connection.dialect` attribute
|
on behalf of the :class:`_asyncio.AsyncConnection` class.
|
|
©r} rc rz r? r? r@ rc u s zAsyncConnection.dialect©Úattrr9 c C s || j _d S rG rÆ ©rl rÈ r? r? r@ rc ~ s c C s | j jS )a The initial-connection time isolation level associated with the
|
:class:`_engine.Dialect` in use.
|
|
.. container:: class_bases
|
|
Proxied for the :class:`_engine.Connection` class
|
on behalf of the :class:`_asyncio.AsyncConnection` class.
|
|
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
|
|
|
)r} rd rz r? r? r@ rd s "z'AsyncConnection.default_isolation_level)N)F)N)NN)N)N)N)N)N)N)N)N)N)N)N)N)N)N)N)-r\ r] r^ Ú__doc__r_ rm Ú__annotations__r` rr ry Úpropertyr{ r~ r Úro_non_memoized_propertyr r} r r r r r r r r r
|
r r£ r¥ r§ r« r° r r² r» r¼ r½ rÀ rÁ rÅ ra rb rc Úsetterrd r? r? r? r@ rg s
|
ý
|
ÿõ( ü ýû ýû ýû= ýû ýû ýû/ ýû ýû ýû ýû ýû ýû ýû ýû ýû4C rg z:class:`_engine.Engine`z :class:`_asyncio.AsyncEngine`Úclear_compiled_cacheÚupdate_execution_optionsÚget_execution_optionsr7 Úpoolrh ÚnameÚdriverÚechoc
|
@ sô e Zd ZU dZdZeZded< ded< ddddZe j
|
dd d
|
d Z e dd d d dZ ejdd ddZdd ddZdd ddZeddddddddd d d d d d d!d"Zed d d#d$d"Zd d d#d%d"ZdJd'd(d)d*d+Zd(d d,d-Zd d(d#d.d/Zd0d d1d2Zed3d d4d5Zejd3d(d6d7d5Zed8d d9d:Z e jd8d(d6d;d:Z ed<d d=d>Z e jd<d(d6d?d>Z ed d d@dAZ ed d dBdCZ ed d dDdEZ ed d dFdGZ!e!jd d(d6dHdGZ!dIS )Kr6 aP An asyncio proxy for a :class:`_engine.Engine`.
|
|
:class:`_asyncio.AsyncEngine` is acquired using the
|
:func:`_asyncio.create_async_engine` function::
|
|
from sqlalchemy.ext.asyncio import create_async_engine
|
engine = create_async_engine("postgresql+asyncpg://user:pass@host/dbname")
|
|
.. versionadded:: 1.4
|
|
r> zType[AsyncConnection]Ú_connection_clsr ©r> c C s. |j js t d|j jd¡| |¡| _d S )NzFThe asyncio extension requires an async driver to be used. The loaded z is not async.)rc Zis_asyncr rv rÔ rk r> )rl r> r? r? r@ rm Ö s
|
ÿzAsyncEngine.__init__rX c C s | j S rG r× rz r? r? r@ r} Þ s zAsyncEngine._proxiedrn c C s t |S rG )r6 rq r? r? r@ rr â s z(AsyncEngine._regenerate_proxy_for_targetz AsyncIterator[AsyncConnection]c C sR | ¡ }|4 I dH . | ¡ 4 I dH |V W 5 Q I dH R X W 5 Q I dH R X dS )a¹ Return a context manager which when entered will deliver an
|
:class:`_asyncio.AsyncConnection` with an
|
:class:`_asyncio.AsyncTransaction` established.
|
|
E.g.::
|
|
async with async_engine.begin() as conn:
|
await conn.execute(
|
text("insert into table (x, y, z) values (1, 2, 3)")
|
)
|
await conn.execute(text("my_special_procedure(5)"))
|
|
|
N)rw r )rl r r? r? r@ r æ s zAsyncEngine.beginrg c C s
|
| | ¡S )a Return an :class:`_asyncio.AsyncConnection` object.
|
|
The :class:`_asyncio.AsyncConnection` will procure a database
|
connection from the underlying connection pool when it is entered
|
as an async context manager::
|
|
async with async_engine.connect() as conn:
|
result = await conn.execute(select(user_table))
|
|
The :class:`_asyncio.AsyncConnection` may also be started outside of a
|
context manager by invoking its :meth:`_asyncio.AsyncConnection.start`
|
method.
|
|
)rÖ rz r? r? r@ rw ü s zAsyncEngine.connectr0 c à s t | jjI dH S )zReturn a "raw" DBAPI connection from the connection pool.
|
|
.. seealso::
|
|
:ref:`dbapi_connections`
|
|
N)r" r> Úraw_connectionrz r? r? r@ rØ s zAsyncEngine.raw_connection.)r r r r r r rC r+ r r r )r r r r r r r9 c K s d S rG r? )rl r r r r r r r? r? r@ r s z AsyncEngine.execution_optionsr c K s d S rG r? r r? r? r@ r % s c K s t | jjf |S )a Return a new :class:`_asyncio.AsyncEngine` that will provide
|
:class:`_asyncio.AsyncConnection` objects with the given execution
|
options.
|
|
Proxied from :meth:`_engine.Engine.execution_options`. See that
|
method for details.
|
|
)r6 r> r r r? r? r@ r ) s
|
Trs r )r§ r9 c à s t | jj|dI dH dS )aE Dispose of the connection pool used by this
|
:class:`_asyncio.AsyncEngine`.
|
|
:param close: if left at its default of ``True``, 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.Engine`,
|
so when they are closed individually, eventually the
|
:class:`_pool.Pool` which they are associated with will
|
be garbage collected and they will be closed out fully, if
|
not already closed on checkin.
|
|
If set to ``False``, the previous connection pool is de-referenced,
|
and otherwise not touched in any way.
|
|
.. seealso::
|
|
:meth:`_engine.Engine.dispose`
|
|
)r§ N)r" r> Údispose)rl r§ r? r? r@ rÙ 5 s zAsyncEngine.disposec C s
|
| j ¡ S )a* Clear the compiled cache associated with the dialect.
|
|
.. container:: class_bases
|
|
Proxied for the :class:`_engine.Engine` class on
|
behalf of the :class:`_asyncio.AsyncEngine` class.
|
|
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.query_cache` parameter.
|
|
.. versionadded:: 1.4
|
|
|
)r} rÏ rz r? r? r@ rÏ T s z AsyncEngine.clear_compiled_cachec K s | j jf |S )a Update the default execution_options dictionary
|
of this :class:`_engine.Engine`.
|
|
.. container:: class_bases
|
|
Proxied for the :class:`_engine.Engine` class on
|
behalf of the :class:`_asyncio.AsyncEngine` class.
|
|
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`
|
|
|
)r} rÐ r r? r? r@ rÐ h s z$AsyncEngine.update_execution_optionsr' c C s
|
| j ¡ S )aU Get the non-SQL options which will take effect during execution.
|
|
.. container:: class_bases
|
|
Proxied for the :class:`_engine.Engine` class on
|
behalf of the :class:`_asyncio.AsyncEngine` class.
|
|
.. versionadded: 1.3
|
|
.. seealso::
|
|
:meth:`_engine.Engine.execution_options`
|
|
)r} rÑ rz r? r? r@ rÑ s z!AsyncEngine.get_execution_optionsr. c C s | j jS )zzProxy for the :attr:`_engine.Engine.url` attribute
|
on behalf of the :class:`_asyncio.AsyncEngine` class.
|
|
©r} r7 rz r? r? r@ r7 s zAsyncEngine.urlrÇ c C s || j _d S rG rÚ rÉ r? r? r@ r7 s r/ c C s | j jS )z{Proxy for the :attr:`_engine.Engine.pool` attribute
|
on behalf of the :class:`_asyncio.AsyncEngine` class.
|
|
©r} rÒ rz r? r? r@ rÒ ¡ s zAsyncEngine.poolc C s || j _d S rG rÛ rÉ r? r? r@ rÒ ª s r* c C s | j jS )z~Proxy for the :attr:`_engine.Engine.dialect` attribute
|
on behalf of the :class:`_asyncio.AsyncEngine` class.
|
|
rÆ rz r? r? r@ rc ® s zAsyncEngine.dialectc C s || j _d S rG rÆ rÉ r? r? r@ rc · s c C s | j jS )aI Returns this :class:`.Engine`.
|
|
.. container:: class_bases
|
|
Proxied for the :class:`_engine.Engine` class
|
on behalf of the :class:`_asyncio.AsyncEngine` class.
|
|
Used for legacy schemes that accept :class:`.Connection` /
|
:class:`.Engine` objects within the same variable.
|
|
|
)r} rh rz r? r? r@ rh » s zAsyncEngine.enginec C s | j jS )a String name of the :class:`~sqlalchemy.engine.interfaces.Dialect`
|
in use by this :class:`Engine`.
|
|
.. container:: class_bases
|
|
Proxied for the :class:`_engine.Engine` class
|
on behalf of the :class:`_asyncio.AsyncEngine` class.
|
|
|
)r} rÓ rz r? r? r@ rÓ Ì s zAsyncEngine.namec C s | j jS )a Driver name of the :class:`~sqlalchemy.engine.interfaces.Dialect`
|
in use by this :class:`Engine`.
|
|
.. container:: class_bases
|
|
Proxied for the :class:`_engine.Engine` class
|
on behalf of the :class:`_asyncio.AsyncEngine` class.
|
|
|
)r} rÔ rz r? r? r@ rÔ Û s zAsyncEngine.driverc C s | j jS )a3 When ``True``, enable log output for this element.
|
|
.. container:: class_bases
|
|
Proxied for the :class:`_engine.Engine` class
|
on behalf of the :class:`_asyncio.AsyncEngine` class.
|
|
This has the effect of setting the Python logging level for the namespace
|
of this element's class and object reference. A value of boolean ``True``
|
indicates that the loglevel ``logging.INFO`` will be set for the logger,
|
whereas the string value ``debug`` will set the loglevel to
|
``logging.DEBUG``.
|
|
©r} rÕ rz r? r? r@ rÕ ê s zAsyncEngine.echoc C s || j _d S rG rÜ rÉ r? r? r@ rÕ ý s N)T)"r\ r] r^ rÊ r_ rg rÖ rË rm r rÍ r} r` rr Ú
|
contextlibÚasynccontextmanagerr rw rØ r
|
r rÙ rÏ rÐ rÑ rÌ r7 rÎ rÒ rc rh rÓ rÔ rÕ r? r? r? r@ r6 © sb
|
|
ù c @ sÜ e Zd ZU dZdZded< ded< ded< d'ddd
|
d d Zed d dddZe j
|
d dddZ e ddddZ e ddddZddddZdddd Zddd d Zd(dd d d d!Zd"d"d"dd#d$d%Zd&S ))r z4An asyncio proxy for a :class:`_engine.Transaction`.©r{ Úsync_transactionr
zOptional[Transaction]rà rg r{ rs r
F)r{ r
c C s || _ d | _|| _d S rG rß )rl r{ r
r? r? r@ rm s zAsyncTransaction.__init__r! rn c C sP |j }|}t|t}t |¡}|d k s*t| | ¡}||_ | |¡|_||_ |S rG )
|
r{ Ú
|
isinstancer rg rp r Ú__new__rk rà r
)rZ ro ri rà r
Zasync_connectionÚobjr? r? r@ rr s
|
ÿ
|
z-AsyncTransaction._regenerate_proxy_for_targetrX c C s | j s| ¡ | j S rG )rà r rz r? r? r@ r} ' s zAsyncTransaction._proxiedc C s | j jS rG )r} Úis_validrz r? r? r@ rä - s zAsyncTransaction.is_validc C s | j jS rG )r} Ú is_activerz r? r? r@ rå 1 s zAsyncTransaction.is_activer c à s t | jjI dH dS )a@ Close this :class:`.AsyncTransaction`.
|
|
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.
|
|
Nr¦ rz r? r? r@ r§ 5 s zAsyncTransaction.closec à s t | jjI dH dS )z*Roll back this :class:`.AsyncTransaction`.Nr¤ rz r? r? r@ r¥ B s zAsyncTransaction.rollbackc à s t | jjI dH dS )z'Commit this :class:`.AsyncTransaction`.Nr¢ rz r? r? r@ r£ F s zAsyncTransaction.commitrt c à s> | t| jr| jjjn| jjjI dH ¡| _|r:| j ¡ | S )z{Start this :class:`_asyncio.AsyncTransaction` object's context
|
outside of using a Python ``with:`` block.
|
|
N) rk r" r
r{ r} r r rà Ú __enter__rx r? r? r@ ry K s ÿ ýÿ
|
zAsyncTransaction.startr r c à s t | jj|||I d H d S rG )r" r} Ú__exit__)rl rà rL rÄ r? r? r@ rÅ \ s zAsyncTransaction.__aexit__N)F)F)r\ r] r^ rÊ r_ rË rm r` rr r rÍ r} rÌ rä rå r§ r¥ r£ ry rÅ r? r? r? r@ r s&
|
r r )rj r9 c C s d S rG r? ©rj r? r? r@ Ú _get_sync_engine_or_connection` s ré r c C s d S rG r? rè r? r? r@ ré e s z#Union[AsyncEngine, AsyncConnection]zUnion[Engine, Connection]c
|
C sP t | tr| jS z| jW S tk
|
rJ } zt d| ¡|W 5 d }~X Y nX d S )Nz AsyncEngine expected, got %r)rá rg r} r> ÚAttributeErrorr Ú ArgumentError)rj Úer? r? r@ ré l s
|
ÿþr )Úsubjectr9 c C s t jdddd S )Nz©Inspection on an AsyncConnection is currently not supported. Please use ``run_sync`` to pass a callable where it's possible to call ``inspect`` on the passed connection.Úxd3s©Úcode©r ZNoInspectionAvailable©rí r? r? r@ Ú_no_insp_for_async_conn_yetz s üró c C s t jdddd S )NzÃInspection on an AsyncEngine is currently not supported. Please obtain a connection then use ``conn.run_sync`` to pass a callable where it's possible to call ``inspect`` on the passed connection.rî rï rñ rò r? r? r@ Ú _no_insp_for_async_engine_xyet s ûrô )rB )RÚ
|
__future__r r¶ rÝ Útypingr r r r r r r r
|
r r r r r Ú r r< Úbaser r r r r r r r r r rh r r r= r rT r Z engine.baser r! Zutil.concurrencyr" Z engine.cursorr# Zengine.interfacesr$ r% r& r' r( r) r* r+ r, Z engine.resultr- Z
|
engine.urlr. rÒ r/ r0 Z sql._typingr1 Zsql.baser2 Zsql.selectabler3 r4 rA rS rU rV Zcreate_proxy_methodsrg r6 r ré Z _inspectsró rô r? r? r? r@ Ú<module> sÖ ÿ üú
|
ý ýö Q
|
ÿ\
|
