U
|
¸ý°dO ã @ sÞ d Z ddlmZ ddlZddlZddlZddlZddlZddl m
|
Z
|
ddl m Z ddl mZ ddl m Z dd lmZ dd
|
lmZ dd lmZ dd lmZ dd lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ddlm Z ddl m Z ddl m Z ddl m!Z! ddl m"Z" ddl#m$Z$ dd l#m%Z% dd l&m'Z' dd l(m)Z) dd l(m*Z* dd l(m+Z+ e rdd!l m,Z, G d"d# d#eZ-G d$d% d%e'j.Z/G d&d' d'e Z0G d(d) d)e'j1Z2G d*d+ d+e Z3G d,d- d-e'j4Z5G d.d/ d/e'j6Z7G d0d1 d1e'j8Z9G d2d3 d3eZ:G d4d5 d5eZ;G d6d7 d7e'j<Z=G d8d9 d9e'j>Z?G d:d; d;ej@ZAG d<d= d=ejBZCG d>d? d?e'j@jDZEG d@dA dAe'j@jFZGG dBdC dCe'j@jHZIG dDdE dEejJZKG dFdG dGe'jLZMG dHdI dIeMe'jNZOG dJdK dKe ZPG dLdM dMeZQG dNdO dOe'jRZSG dPdQ dQe jTZUG dRdS dSe jVZWG dTdU dUeZXG dVdW dWeZYG dXdY dYeZZG dZd[ d[Z[G d\d] d]e[Z\G d^d_ d_e$Z]G d`da dae]Z^G dbdc dcZ_G ddde deeZ`e`ZadS )faè
|
.. dialect:: postgresql+asyncpg
|
:name: asyncpg
|
:dbapi: asyncpg
|
:connectstring: postgresql+asyncpg://user:password@host:port/dbname[?key=value&key=value...]
|
:url: https://magicstack.github.io/asyncpg/
|
|
The asyncpg dialect is SQLAlchemy's first Python asyncio dialect.
|
|
Using a special asyncio mediation layer, the asyncpg dialect is usable
|
as the backend for the :ref:`SQLAlchemy asyncio <asyncio_toplevel>`
|
extension package.
|
|
This dialect should normally be used only with the
|
:func:`_asyncio.create_async_engine` engine creation function::
|
|
from sqlalchemy.ext.asyncio import create_async_engine
|
engine = create_async_engine("postgresql+asyncpg://user:pass@hostname/dbname")
|
|
The dialect can also be run as a "synchronous" dialect within the
|
:func:`_sa.create_engine` function, which will pass "await" calls into
|
an ad-hoc event loop. This mode of operation is of **limited use**
|
and is for special testing scenarios only. The mode can be enabled by
|
adding the SQLAlchemy-specific flag ``async_fallback`` to the URL
|
in conjunction with :func:`_sa.create_engine`::
|
|
# for testing purposes only; do not use in production!
|
engine = create_engine("postgresql+asyncpg://user:pass@hostname/dbname?async_fallback=true")
|
|
|
.. versionadded:: 1.4
|
|
.. note::
|
|
By default asyncpg does not decode the ``json`` and ``jsonb`` types and
|
returns them as strings. SQLAlchemy sets default type decoder for ``json``
|
and ``jsonb`` types using the python builtin ``json.loads`` function.
|
The json implementation used can be changed by setting the attribute
|
``json_deserializer`` when creating the engine with
|
:func:`create_engine` or :func:`create_async_engine`.
|
|
|
.. _asyncpg_prepared_statement_cache:
|
|
Prepared Statement Cache
|
--------------------------
|
|
The asyncpg SQLAlchemy dialect makes use of ``asyncpg.connection.prepare()``
|
for all statements. The prepared statement objects are cached after
|
construction which appears to grant a 10% or more performance improvement for
|
statement invocation. The cache is on a per-DBAPI connection basis, which
|
means that the primary storage for prepared statements is within DBAPI
|
connections pooled within the connection pool. The size of this cache
|
defaults to 100 statements per DBAPI connection and may be adjusted using the
|
``prepared_statement_cache_size`` DBAPI argument (note that while this argument
|
is implemented by SQLAlchemy, it is part of the DBAPI emulation portion of the
|
asyncpg dialect, therefore is handled as a DBAPI argument, not a dialect
|
argument)::
|
|
|
engine = create_async_engine("postgresql+asyncpg://user:pass@hostname/dbname?prepared_statement_cache_size=500")
|
|
To disable the prepared statement cache, use a value of zero::
|
|
engine = create_async_engine("postgresql+asyncpg://user:pass@hostname/dbname?prepared_statement_cache_size=0")
|
|
.. versionadded:: 1.4.0b2 Added ``prepared_statement_cache_size`` for asyncpg.
|
|
|
.. warning:: The ``asyncpg`` database driver necessarily uses caches for
|
PostgreSQL type OIDs, which become stale when custom PostgreSQL datatypes
|
such as ``ENUM`` objects are changed via DDL operations. Additionally,
|
prepared statements themselves which are optionally cached by SQLAlchemy's
|
driver as described above may also become "stale" when DDL has been emitted
|
to the PostgreSQL database which modifies the tables or other objects
|
involved in a particular prepared statement.
|
|
The SQLAlchemy asyncpg dialect will invalidate these caches within its local
|
process when statements that represent DDL are emitted on a local
|
connection, but this is only controllable within a single Python process /
|
database engine. If DDL changes are made from other database engines
|
and/or processes, a running application may encounter asyncpg exceptions
|
``InvalidCachedStatementError`` and/or ``InternalServerError("cache lookup
|
failed for type <oid>")`` if it refers to pooled database connections which
|
operated upon the previous structures. The SQLAlchemy asyncpg dialect will
|
recover from these error cases when the driver raises these exceptions by
|
clearing its internal caches as well as those of the asyncpg driver in
|
response to them, but cannot prevent them from being raised in the first
|
place if the cached prepared statement or asyncpg type caches have gone
|
stale, nor can it retry the statement as the PostgreSQL transaction is
|
invalidated when these errors occur.
|
|
.. _asyncpg_prepared_statement_name:
|
|
Prepared Statement Name
|
-----------------------
|
|
By default, asyncpg enumerates prepared statements in numeric order, which
|
can lead to errors if a name has already been taken for another prepared
|
statement. This issue can arise if your application uses database proxies
|
such as PgBouncer to handle connections. One possible workaround is to
|
use dynamic prepared statement names, which asyncpg now supports through
|
an optional ``name`` value for the statement name. This allows you to
|
generate your own unique names that won't conflict with existing ones.
|
To achieve this, you can provide a function that will be called every time
|
a prepared statement is prepared::
|
|
from uuid import uuid4
|
|
engine = create_async_engine(
|
"postgresql+asyncpg://user:pass@hostname/dbname",
|
poolclass=NullPool,
|
connect_args={
|
'prepared_statement_name_func': lambda: f'__asyncpg_{uuid4()}__',
|
},
|
)
|
|
.. seealso::
|
|
https://github.com/MagicStack/asyncpg/issues/837
|
|
https://github.com/sqlalchemy/sqlalchemy/issues/6467
|
|
.. warning:: To prevent a buildup of useless prepared statements in
|
your application, it's important to use the :class:`.NullPool` pool
|
class, and to configure PgBouncer to use `DISCARD <https://www.postgresql.org/docs/current/sql-discard.html>`_
|
when returning connections. The DISCARD command is used to release resources held by the db connection,
|
including prepared statements. Without proper setup, prepared statements can
|
accumulate quickly and cause performance issues.
|
|
Disabling the PostgreSQL JIT to improve ENUM datatype handling
|
---------------------------------------------------------------
|
|
Asyncpg has an `issue <https://github.com/MagicStack/asyncpg/issues/727>`_ when
|
using PostgreSQL ENUM datatypes, where upon the creation of new database
|
connections, an expensive query may be emitted in order to retrieve metadata
|
regarding custom types which has been shown to negatively affect performance.
|
To mitigate this issue, the PostgreSQL "jit" setting may be disabled from the
|
client using this setting passed to :func:`_asyncio.create_async_engine`::
|
|
engine = create_async_engine(
|
"postgresql+asyncpg://user:password@localhost/tmp",
|
connect_args={"server_settings": {"jit": "off"}},
|
)
|
|
.. seealso::
|
|
https://github.com/MagicStack/asyncpg/issues/727
|
|
é )Ú annotationsN)Úcast)Ú TYPE_CHECKINGé )Újson)Úranges)ÚARRAY)Ú_DECIMAL_TYPES)Ú _FLOAT_TYPES)Ú
|
_INT_TYPES)ÚENUM)ÚINTERVAL)ÚOID)Ú
|
PGCompiler)Ú PGDialect)ÚPGExecutionContext)ÚPGIdentifierPreparer)ÚREGCLASS)Ú REGCONFIG)ÚBYTEAé )Úexc)Úpool)Úutil)ÚAdaptedConnection)Ú
|
processors)Úsqltypes)Úasyncio)Úawait_fallback)Ú
|
await_only)ÚIterablec @ s e Zd ZdZdS )Ú AsyncpgARRAYTN©Ú__name__Ú
|
__module__Ú __qualname__Úrender_bind_cast© r' r' ú]d:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/dialects/postgresql/asyncpg.pyr! È s r! c @ s e Zd ZdZdS )Ú AsyncpgStringTNr" r' r' r' r( r) Ì s r) c @ s e Zd ZdZdS )ÚAsyncpgREGCONFIGTNr" r' r' r' r( r* Ð s r* c @ s e Zd ZdZdS )Ú AsyncpgTimeTNr" r' r' r' r( r+ Ô s r+ c @ s e Zd ZdZdS )Ú AsyncpgByteATNr" r' r' r' r( r, Ø s r, c @ s e Zd ZdZdS )Ú AsyncpgDateTNr" r' r' r' r( r- Ü s r- c @ s e Zd ZdZdS )ÚAsyncpgDateTimeTNr" r' r' r' r( r. à s r. c @ s e Zd ZdZdS )ÚAsyncpgBooleanTNr" r' r' r' r( r/ ä s r/ c @ s e Zd ZdZedd ZdS )ÚAsyncPgIntervalTc K s t |jdS )N)Z precision)r0 Zsecond_precision)ÚclsÚintervalÚkwr' r' r( Úadapt_emulated_to_nativeë s z(AsyncPgInterval.adapt_emulated_to_nativeN)r# r$ r% r& Ú classmethodr4 r' r' r' r( r0 è s r0 c @ s e Zd ZdZdS )Ú AsyncPgEnumTNr" r' r' r' r( r6 ñ s r6 c @ s e Zd ZdZdS )ÚAsyncpgIntegerTNr" r' r' r' r( r7 õ s r7 c @ s e Zd ZdZdS )ÚAsyncpgBigIntegerTNr" r' r' r' r( r8 ù s r8 c @ s e Zd ZdZdd ZdS )Ú AsyncpgJSONTc C s d S ©Nr' ©ÚselfÚdialectÚcoltyper' r' r( Úresult_processor s z AsyncpgJSON.result_processorN©r# r$ r% r& r? r' r' r' r( r9 ý s r9 c @ s e Zd ZdZdd ZdS )Ú AsyncpgJSONBTc C s d S r: r' r; r' r' r( r? s z AsyncpgJSONB.result_processorNr@ r' r' r' r( rA s rA c @ s e Zd ZdS )ÚAsyncpgJSONIndexTypeN©r# r$ r% r' r' r' r( rB s rB c @ s e Zd ZdZdZdS )ÚAsyncpgJSONIntIndexTypeZjson_int_indexTN©r# r$ r% Z__visit_name__r& r' r' r' r( rD s rD c @ s e Zd ZdZdZdS )ÚAsyncpgJSONStrIndexTypeZjson_str_indexTNrE r' r' r' r( rF s rF c @ s e Zd Zdd ZdS )ÚAsyncpgJSONPathTypec C s dd }|S )Nc S s, t | tr| S | r$dd | D }|S g S d S )Nc S s g | ] }t |qS r' )Ústr©Ú.0Úelemr' r' r( Ú
|
<listcomp># s zGAsyncpgJSONPathType.bind_processor.<locals>.process.<locals>.<listcomp>)Ú
|
isinstancerH )ÚvalueÚtokensr' r' r( Úprocess s
|
z3AsyncpgJSONPathType.bind_processor.<locals>.processr' )r< r= rP r' r' r( Úbind_processor s z"AsyncpgJSONPathType.bind_processorN)r# r$ r% rQ r' r' r' r( rG s rG c @ s e Zd ZdZdd Zdd ZdS )ÚAsyncpgNumericTc C s d S r: r' )r< r= r' r' r( rQ . s z AsyncpgNumeric.bind_processorc C sv | j rB|tkr t tj| j¡S |tks.|tkr2d S t
|
d| ¡n0|tkrNd S |tks^|tkrdtj S t
|
d| ¡d S )NzUnknown PG numeric type: %d) Z asdecimalr
|
r Z to_decimal_processor_factoryÚdecimalÚDecimalZ _effective_decimal_return_scaler r r ZInvalidRequestErrorZto_floatr; r' r' r( r? 1 s$ ÿÿÿz AsyncpgNumeric.result_processorN)r# r$ r% r& rQ r? r' r' r' r( rR + s rR c @ s e Zd ZdZdZdS )Ú AsyncpgFloatÚfloatTNrE r' r' r' r( rU J s rU c @ s e Zd ZdZdS )ÚAsyncpgREGCLASSTNr" r' r' r' r( rW O s rW c @ s e Zd ZdZdS )Ú
|
AsyncpgOIDTNr" r' r' r' r( rX S s rX c @ s e Zd ZdZdS )Ú AsyncpgCHARTNr" r' r' r' r( rY W s rY c @ s e Zd Zdd Zdd ZdS )Ú _AsyncpgRangec s |j jj fdd}|S )Nc s< t | tjr8 | j| j| jd dk| jd dk| jd} | S ©Nr ú[r ú])Ú lower_incÚ upper_incÚempty©rM r ÚRangeÚlowerÚupperÚboundsr` ©rN ©Ú asyncpg_Ranger' r( Úto_range_ s ûz._AsyncpgRange.bind_processor.<locals>.to_range)ÚdbapiÚasyncpgrb ©r< r= ri r' rg r( rQ \ s
|
z _AsyncpgRange.bind_processorc C s dd }|S )Nc S sL | d k rH| j }tj| j| j|s$| jr(dnd |s:| jr:dnd |d} | S ©Nr\ ú(r] ú))re r` ©Zisemptyr rb rc rd r^ r_ )rN r` r' r' r( ri m s &ûz0_AsyncpgRange.result_processor.<locals>.to_ranger' )r< r= r> ri r' r' r( r? l s z _AsyncpgRange.result_processorN©r# r$ r% rQ r? r' r' r' r( rZ [ s rZ c @ s e Zd Zdd Zdd ZdS )Ú_AsyncpgMultiRangec s$ |j jjtd fdd}|S )Nc s6 t | tfr| S fdd fddtd| D S )Nc s< t | tjr8 | j| j| jd dk| jd dk| jd} | S r[ ra rf rg r' r( ri s ûzE_AsyncpgMultiRange.bind_processor.<locals>.to_range.<locals>.to_rangec s g | ] } |qS r' r' )rJ Úelement©ri r' r( rL s ÿzG_AsyncpgMultiRange.bind_processor.<locals>.to_range.<locals>.<listcomp>zIterable[ranges.Range])rM rH r rf ©ZNoneTyperh rt r( ri s
|
þz3_AsyncpgMultiRange.bind_processor.<locals>.to_range)rj rk rb Útyperl r' ru r( rQ } s
|
z!_AsyncpgMultiRange.bind_processorc C s dd }|S )Nc s& dd | d k r" fdd| D } | S )Nc S sL | d k rH| j }tj| j| j|s$| jr(dnd |s:| jr:dnd |d} | S rm rp )Zrvaluer` r' r' r( ri s &ûzM_AsyncpgMultiRange.result_processor.<locals>.to_range_array.<locals>.to_rangec s g | ] } |qS r' r' rI rt r' r( rL § s zO_AsyncpgMultiRange.result_processor.<locals>.to_range_array.<locals>.<listcomp>r' rf r' rt r( Úto_range_array s z;_AsyncpgMultiRange.result_processor.<locals>.to_range_arrayr' )r< r= r> rw r' r' r( r? s z#_AsyncpgMultiRange.result_processorNrq r' r' r' r( rr | s rr c @ s$ e Zd Zdd Zdd Zdd ZdS )ÚPGExecutionContext_asyncpgc C s( t || jjj| jjjfr$| j ¡ d S r: )rM r= rj ÚInvalidCachedStatementErrorÚInternalServerErrorÚ_invalidate_schema_cache)r< Úer' r' r( Úhandle_dbapi_exception¯ s þþz1PGExecutionContext_asyncpg.handle_dbapi_exceptionc C s* | j r| j ¡ | jj| j_| js&d S d S r: )Zisddlr= r{ Ú _invalidate_schema_cache_asofÚcursorZcompiled©r< r' r' r( Úpre_exec¹ s
|
ÿz#PGExecutionContext_asyncpg.pre_execc C s | j jddS )NT)Ú server_side)Z_dbapi_connectionr r r' r' r( Úcreate_server_side_cursorÄ s z4PGExecutionContext_asyncpg.create_server_side_cursorN)r# r$ r% r} r r r' r' r' r( rx ® s
|
rx c @ s e Zd ZdS )ÚPGCompiler_asyncpgNrC r' r' r' r( r È s r c @ s e Zd ZdS )Ú PGIdentifierPreparer_asyncpgNrC r' r' r' r( r
Ì s r
c @ sx e Zd ZdZdZdd Zdd Zdd Zd d
|
Zd d Z d ddZ
|
dd Z dd Z dd Z dd Zd ddZdd Zd S ) ÚAsyncAdapt_asyncpg_cursor)Ú_adapt_connectionÚ _connectionÚ_rowsÚ descriptionÚ arraysizeÚrowcountÚ_cursorr~ Fc C s6 || _ |j| _g | _d | _d | _d| _d| _d| _d S )Nr éÿÿÿÿr )r r r r r r r r~ ©r< Úadapt_connectionr' r' r( Ú__init__Þ s z"AsyncAdapt_asyncpg_cursor.__init__c C s g | j d d
< d S r: ©r r r' r' r( Úcloseè s z AsyncAdapt_asyncpg_cursor.closec C s | j |¡ d S r: )r Ú_handle_exception©r< Úerrorr' r' r( r ë s z+AsyncAdapt_asyncpg_cursor._handle_exceptionc à s | j }|j4 I d H î |js*| ¡ I d H |d kr6d}z| || j¡I d H \}}|rfdd |D | _nd | _| jr|j| I d H | _ d| _
|
nB|j | I d H | _ | ¡ }t d|¡}|rÈt| d¡| _
|
nd| _
|
W n, tk
|
rü } z| |¡ W 5 d }~X Y nX W 5 Q I d H R X d S )Nr' c S s$ g | ] }|j |jjd d d d d fqS r: )Únamerv Úoid)rJ Úattrr' r' r( rL ÿ s
|
øùzBAsyncAdapt_asyncpg_cursor._prepare_and_execute.<locals>.<listcomp>r z)(?:SELECT|UPDATE|DELETE|INSERT \d+) (\d+)r )r Ú_execute_mutexÚ_startedÚ_start_transactionÚ_preparer~ r r r r r Úfetchr Z get_statusmsgÚreÚmatchÚintÚgroupÚ Exceptionr ) r< Ú operationÚ
|
parametersr Ú prepared_stmtÚ
|
attributesÚstatusÚregr r' r' r( Ú_prepare_and_executeî s< ÿ
|
ö
|
ÿ
|
z.AsyncAdapt_asyncpg_cursor._prepare_and_executec à s¦ | j }|j4 I d H | | j¡I d H |js<| ¡ I d H z(| j ||¡I d H W W 5 Q I d H R £ S tk
|
r } z| |¡ W 5 d }~X Y nX W 5 Q I d H R X d S r: )
|
r r Ú _check_type_cache_invalidationr~ r r r Ú executemanyr£ r )r< r¤ Úseq_of_parametersr r r' r' r( Ú _executemany s ÿ
|
ÿ z&AsyncAdapt_asyncpg_cursor._executemanyNc C s | j | ||¡¡ d S r: )r Úawait_rª )r< r¤ r¥ r' r' r( Úexecute2 s
|
ÿz!AsyncAdapt_asyncpg_cursor.executec C s | j | ||¡¡S r: )r r¯ r® ©r< r¤ r r' r' r( r¬ 7 s
|
ÿz%AsyncAdapt_asyncpg_cursor.executemanyc G s
|
t d S r: ©ÚNotImplementedError)r< Z
|
inputsizesr' r' r( Ú setinputsizes< s z'AsyncAdapt_asyncpg_cursor.setinputsizesc c s | j r| j d¡V q d S ©Nr ©r Úpopr r' r' r( Ú__iter__? s z"AsyncAdapt_asyncpg_cursor.__iter__c C s | j r| j d¡S d S d S rµ r¶ r r' r' r( ÚfetchoneC s z"AsyncAdapt_asyncpg_cursor.fetchonec C s8 |d kr| j }| jd|
}| j|d
| jd d
< |S rµ )r r )r< ÚsizeÚretvalr' r' r( Ú fetchmanyI s
|
z#AsyncAdapt_asyncpg_cursor.fetchmanyc C s | j d d
}g | j d d
< |S r: r )r< r» r' r' r( ÚfetchallQ s z"AsyncAdapt_asyncpg_cursor.fetchall)N)N)r# r$ r% Ú __slots__r r r r rª r® r° r¬ r´ r¸ r¹ r¼ r½ r' r' r' r( r Ð s
|
2
|
|
r c sn e Zd ZdZdZ fddZdd Zdd Zd d
|
Zd d Z d d Z
|
dddZ dd Z dd Z dd Z ZS )Ú AsyncAdapt_asyncpg_ss_cursorT)Ú
|
_rowbufferc s t |¡ d | _d S r: )Úsuperr rÀ r ©Ú __class__r' r( r \ s z%AsyncAdapt_asyncpg_ss_cursor.__init__c C s d | _ d | _d S r: )r rÀ r r' r' r( r ` s z"AsyncAdapt_asyncpg_ss_cursor.closec C s$ | j | j d¡¡}t |¡| _d S )Né2 )r r¯ r r Ú collectionsÚdequerÀ )r< Znew_rowsr' r' r( Ú _buffer_rowsd s z)AsyncAdapt_asyncpg_ss_cursor._buffer_rowsc C s | S r: r' r r' r' r( Ú __aiter__h s z&AsyncAdapt_asyncpg_ss_cursor.__aiter__c C s8 | j s| ¡ | j r"| j ¡ V q| ¡ | j sq4qd S r: ©rÀ rÇ Úpopleftr r' r' r( Ú __anext__k s z&AsyncAdapt_asyncpg_ss_cursor.__anext__c C s" | j s| ¡ | j sd S | j ¡ S r: rÉ r r' r' r( r¹ w s
|
z%AsyncAdapt_asyncpg_ss_cursor.fetchoneNc C sz |d kr| ¡ S | js | ¡ t| j}t|}||krV| | j | j || ¡¡¡ |d|
}t
|
||d
¡| _|S rµ ) r½ rÀ rÇ ÚlistÚlenÚextendr r¯ r r rÅ rÆ )r< rº ÚbufZlbÚresultr' r' r( r¼ ~ s
|
ÿ z&AsyncAdapt_asyncpg_ss_cursor.fetchmanyc C s, t | jt | j | ¡ ¡ }| j ¡ |S r: )rÌ rÀ r r¯ Ú_allÚclear)r< Úretr' r' r( r½ s
|
|
ÿ
|
z%AsyncAdapt_asyncpg_ss_cursor.fetchallc à s0 g }| j d¡I d H }|r,| |¡ qqq,q|S )Niè )r r rÎ )r< ÚrowsÚbatchr' r' r( rÑ s
|
z!AsyncAdapt_asyncpg_ss_cursor._allc C s t dd S )Nz2server side cursor doesn't support executemany yetr² r± r' r' r( r¬ ¥ s ÿz(AsyncAdapt_asyncpg_ss_cursor.executemany)N)r# r$ r% r r¾ r r rÇ rÈ rË r¹ r¼ r½ rÑ r¬ Ú __classcell__r' r' r r( r¿ W s
|
r¿ c @ s¢ e Zd ZdZeeZd"ddZdd Zdd Z d
|
d Z
|
e d d Z e j dd Z dd Zdd Zdd Zd#ddZdd Zdd Zd d Zd d Zed d! ZdS )$Ú AsyncAdapt_asyncpg_connection) rj Úisolation_levelÚ_isolation_settingÚreadonlyÚ
|
deferrableÚ _transactionr Ú_prepared_statement_cacheÚ _prepared_statement_name_funcr~ r éd Nc C st || _ || _d | _| _d| _d| _d | _d| _t ¡ | _ t
|
¡ | _ |rVt |¡| _nd | _|rh|| _n| j| _d S )NÚread_committedF)rj r rØ rÙ rÚ rÛ rÜ r Útimer~ r ÚLockr r ZLRUCacherÝ rÞ Ú_default_name_func)r< rj Ú
|
connectionÚ prepared_statement_cache_sizeÚ prepared_statement_name_funcr' r' r( r ¼ s"
|
|
ÿz&AsyncAdapt_asyncpg_connection.__init__c à s$ || j kr | j ¡ I d H || _ d S r: )r~ r Zreload_schema_state)r< Úinvalidate_timestampr' r' r( r« Ù s
|
z<AsyncAdapt_asyncpg_connection._check_type_cache_invalidationc à sª | |¡I d H | j}|d krH| jj|| ¡ dI d H }| ¡ }||fS ||krn|| \}}}||krn||fS | jj|| ¡ dI d H }| ¡ }||t ¡ f||< ||fS )N)r )r« rÝ r ÚpreparerÞ Zget_attributesrá )r< r¤ rç Úcacher¦ r§ Zcached_timestampr' r' r( r Þ s( ÿ ÿ z&AsyncAdapt_asyncpg_connection._preparec C s | j ¡ rd | _d| _t|tjsz| jj}t |j
|
D ]>}||kr4|| dt ||f }t |dd |_ |_ ||q4|n|d S )NFz%s: %sÚsqlstate)r Ú is_closedrÜ r rM ÚAsyncAdapt_asyncpg_dbapiÚErrorrj Ú_asyncpg_error_translaterv Ú__mro__ÚgetattrZpgcoderê )r< r Zexception_mappingZsuper_Ztranslated_errorr' r' r( r ý s
|
ÿ
|
þz/AsyncAdapt_asyncpg_connection._handle_exceptionc C s
|
| j dkS ©NÚ
|
autocommit)rØ r r' r' r( rò s z(AsyncAdapt_asyncpg_connection.autocommitc C s |r d| _ n| j| _ d S rñ )rØ rÙ ©r< rN r' r' r( rò s c
|
C sH z| | j d¡¡}W n, tk
|
rB } z| |¡ W 5 d }~X Y nX d S )Nú;)r¯ r Zfetchrowr£ r )r< Ú_r r' r' r( Úping s z"AsyncAdapt_asyncpg_connection.pingc C s | j r| ¡ | | _| _d S r: )r ÚrollbackrØ rÙ )r< Úlevelr' r' r( Úset_isolation_level$ s z1AsyncAdapt_asyncpg_connection.set_isolation_levelc
|
à st | j dkrd S z.| jj| j | j| jd| _| j ¡ I d H W n, tk
|
rh } z| |¡ W 5 d }~X Y nX d| _ d S )Nrò )Z isolationrÚ rÛ T)
|
rØ r Z transactionrÚ rÛ rÜ Ústartr£ r r r r' r' r( r ) s
|
ý z0AsyncAdapt_asyncpg_connection._start_transactionFc C s |r t | S t| S d S r: )r¿ r )r< r r' r' r( r 9 s z$AsyncAdapt_asyncpg_connection.cursorc
|
C s` | j r\zFz| | j ¡ ¡ W n, tk
|
rH } z| |¡ W 5 d }~X Y nX W 5 d | _d| _ X d S ©NF)r rÜ r¯ r÷ r£ r r r' r' r( r÷ ? s z&AsyncAdapt_asyncpg_connection.rollbackc
|
C s` | j r\zFz| | j ¡ ¡ W n, tk
|
rH } z| |¡ W 5 d }~X Y nX W 5 d | _d| _ X d S rû )r rÜ r¯ Úcommitr£ r r r' r' r( rü I s z$AsyncAdapt_asyncpg_connection.commitc C s | ¡ | | j ¡ ¡ d S r: )r÷ r¯ r r r r' r' r( r S s z#AsyncAdapt_asyncpg_connection.closec C s | j ¡ d| _d S rû )r Ú terminater r r' r' r( rý X s
|
z'AsyncAdapt_asyncpg_connection.terminatec C s d S r: r' r' r' r' r( rã \ s z0AsyncAdapt_asyncpg_connection._default_name_func)rß N)F)r# r$ r% r¾ Ú staticmethodr r¯ r r« r r Úpropertyrò Úsetterrö rù r r r÷ rü r rý rã r' r' r' r( r× « s, û
|
|
|
|
|
|
r× c @ s e Zd ZdZeeZdS )Ú%AsyncAdaptFallback_asyncpg_connectionr' N)r# r$ r% r¾ rþ r r¯ r' r' r' r( r a s r c @ s e Zd Zdd Zdd ZG dd deZG dd deZG d d
|
d
|
eZG d d d eZ G d d de Z
|
G dd de Z G dd de Z G dd de Z G dd de ZG dd de ZG dd de
|
ZG dd d eZe d ¡Ze d ¡Ze d ¡Zejd d! Zd"d# Zd$S )%rì c C s || _ d| _d S )NÚnumeric_dollar)rk Z
|
paramstyle©r< rk r' r' r( r h s z!AsyncAdapt_asyncpg_dbapi.__init__c O sn | dd¡}| dd¡}| dd ¡}t |¡rLt| t| jj||||dS t| t| jj||||dS d S )NÚasync_fallbackFrå rß ræ )rå ræ ) r· r Úasboolr r rk Úconnectr× r )r< Úargr3 r rå ræ r' r' r( r l s, ÿ ÿ
|
üüz AsyncAdapt_asyncpg_dbapi.connectc @ s e Zd ZdS )z AsyncAdapt_asyncpg_dbapi.ErrorNrC r' r' r' r( rí s rí c @ s e Zd ZdS )z AsyncAdapt_asyncpg_dbapi.WarningNrC r' r' r' r( ÚWarning s r c @ s e Zd ZdS )z'AsyncAdapt_asyncpg_dbapi.InterfaceErrorNrC r' r' r' r( ÚInterfaceError s r c @ s e Zd ZdS )z&AsyncAdapt_asyncpg_dbapi.DatabaseErrorNrC r' r' r' r( Ú DatabaseError s r
|
c @ s e Zd ZdS )z&AsyncAdapt_asyncpg_dbapi.InternalErrorNrC r' r' r' r( Ú InternalError s r c @ s e Zd ZdS )z)AsyncAdapt_asyncpg_dbapi.OperationalErrorNrC r' r' r' r( ÚOperationalError s r c @ s e Zd ZdS )z)AsyncAdapt_asyncpg_dbapi.ProgrammingErrorNrC r' r' r' r( ÚProgrammingError s r c @ s e Zd ZdS )z'AsyncAdapt_asyncpg_dbapi.IntegrityErrorNrC r' r' r' r( ÚIntegrityError s r c @ s e Zd ZdS )z"AsyncAdapt_asyncpg_dbapi.DataErrorNrC r' r' r' r( Ú DataError s r c @ s e Zd ZdS )z*AsyncAdapt_asyncpg_dbapi.NotSupportedErrorNrC r' r' r' r( ÚNotSupportedError s r c @ s e Zd ZdS )z,AsyncAdapt_asyncpg_dbapi.InternalServerErrorNrC r' r' r' r( rz ¢ s rz c s e Zd Z fddZ ZS )z4AsyncAdapt_asyncpg_dbapi.InvalidCachedStatementErrorc s t |d ¡ d S )Nzc (SQLAlchemy asyncpg dialect will now invalidate all prepared caches in response to this exception))rÁ r )r< Úmessager r' r( r ¦ s ÿz=AsyncAdapt_asyncpg_dbapi.InvalidCachedStatementError.__init__)r# r$ r% r rÖ r' r' r r( ry ¥ s ry ÚSTRINGÚNUMBERÚDATETIMEc C sH dd l }|jj| j|jj| j|jj| j|jj| j|jj | j |jj
|
| j
|
iS rµ ) rk Ú
|
exceptionsZ!IntegrityConstraintViolationErrorr Z PostgresErrorrí ZSyntaxOrAccessErrorr r ry rz r r' r' r( rî ² s úz1AsyncAdapt_asyncpg_dbapi._asyncpg_error_translatec C s |S r: r' ró r' r' r( ÚBinary¿ s z AsyncAdapt_asyncpg_dbapi.BinaryN)r# r$ r% r r r£ rí r r r
|
r r r r r r rz ry r Úsymbolr r r Úmemoized_propertyrî r r' r' r' r( rì g s(
|
|
|
|
rì c 7 s e Zd ZdZdZdZdZdZdZdZ e
|
Z e Z eZe ejejeejeeeeje ej e ej e ej!e"e#e"ej$e%ej&e'ej(e)ej*e+ej,e-ej.e/ej0e1e2j3e4ej.j5e6ej.j7e8ej.j9e:ej.j;e<ej=e>e?e@eAeBejCeDeEjFeGeEjHeIi¡ZdZJdZKdd ZLejMdd ZNeOd
|
d ZPejMd d ZQdd ZRdd ZSdd ZTdd ZUdd ZVdd ZWddd d ZXd d ZYd d! ZZeOd"d# Z[d$d% Z\d&d' Z]d(d) Z^ fd*d+Z_d,d- Z` ZaS ).ÚPGDialect_asyncpgrk Tr Fr c C s t ¡ | _d S r: )rá r~ r r' r' r( r{ ô s z*PGDialect_asyncpg._invalidate_schema_cachec C s8 | j r0t| j dr0tdd t d| j j¡D S dS d S )NÚ __version__c S s g | ] }t |qS r' )r¡ )rJ Úxr' r' r( rL û s ÿz4PGDialect_asyncpg._dbapi_version.<locals>.<listcomp>z(\d+)(?:[-\.]?|$))éc r r )rj ÚhasattrÚtupler Úfindallr r r' r' r( Ú_dbapi_version÷ s ÿþÿ z PGDialect_asyncpg._dbapi_versionc C s t tdS )Nrk )rì Ú
|
__import__)r1 r' r' r( Ú import_dbapi s z PGDialect_asyncpg.import_dbapic C s dddddS )Nrò rà Zrepeatable_readZ serializable)Z
|
AUTOCOMMITzREAD COMMITTEDzREPEATABLE READZ SERIALIZABLEr' r r' r' r( Ú_isolation_lookup s
|
üz#PGDialect_asyncpg._isolation_lookupc C s
|
t | jS r: )rÌ r# ©r< Údbapi_connectionr' r' r( Úget_isolation_level_values s z,PGDialect_asyncpg.get_isolation_level_valuesc C s | | j| ¡ d S r: )rù r# )r< r% rø r' r' r( rù s z%PGDialect_asyncpg.set_isolation_levelc C s
|
||_ d S r: ©rÚ ©r< rä rN r' r' r( Ú set_readonly s z PGDialect_asyncpg.set_readonlyc C s |j S r: r' ©r< rä r' r' r( Ú get_readonly s z PGDialect_asyncpg.get_readonlyc C s
|
||_ d S r: ©rÛ r( r' r' r( Úset_deferrable s z PGDialect_asyncpg.set_deferrablec C s |j S r: r, r* r' r' r( Úget_deferrable! s z PGDialect_asyncpg.get_deferrableÚNone)Úreturnc C s | ¡ d S r: )rý r$ r' r' r( Ú do_terminate$ s z PGDialect_asyncpg.do_terminatec C s< |j dd}| |j¡ t |dt¡ t |dt¡ g |fS )NÚuser)Úusernamerå Úport)Ztranslate_connect_argsÚupdateÚqueryr Zcoerce_kw_typer¡ )r< ÚurlÚoptsr' r' r( Úcreate_connect_args' s
|
z%PGDialect_asyncpg.create_connect_argsc C s | ¡ dS )NT)rö r$ r' r' r( Údo_ping/ s zPGDialect_asyncpg.do_pingc C s( |j dd¡}t |¡r tjS tjS d S )Nr F)r6 Úgetr r r Z FallbackAsyncAdaptedQueuePoolZAsyncAdaptedQueuePool)r1 r7 r r' r' r( Úget_pool_class3 s
|
z PGDialect_asyncpg.get_pool_classc C s, |r|j ¡ S t|| jjo&dt|kS d S )Nzconnection is closed)r rë rM rj r rH )r< r| rä r r' r' r( Ú is_disconnect= s
|
ÿ
|
þz PGDialect_asyncpg.is_disconnectc s> |j }| jptj fdd}|jdtj|dddI dH dS )z®set up JSON codec for asyncpg.
|
|
This occurs for all new connections and
|
can be overridden by third party dialects.
|
|
.. versionadded:: 1.4.27
|
|
c s | ¡ S r: ©Údecode©Z bin_value©Z deserializerr' r( Ú _json_decoderR s zAPGDialect_asyncpg.setup_asyncpg_json_codec.<locals>._json_decoderr Ú
|
pg_catalogÚbinary©ÚencoderÚdecoderZschemaÚformatN)r Ú_json_deserializerÚ_py_jsonÚloadsÚset_type_codecrH Úencode)r< ÚconnÚasyncpg_connectionrB r' rA r( Úsetup_asyncpg_json_codecE s
|
ûz*PGDialect_asyncpg.setup_asyncpg_json_codecc sP |j }| jptj dd }| jp$tj fdd}|jd||dddI d H d S )
|
z¯set up JSONB codec for asyncpg.
|
|
This occurs for all new connections and
|
can be overridden by third party dialects.
|
|
.. versionadded:: 1.4.27
|
|
c S s d| ¡ S )Nó )rM )Z str_valuer' r' r( Ú_jsonb_encoderj s zCPGDialect_asyncpg.setup_asyncpg_jsonb_codec.<locals>._jsonb_encoderc s | dd
¡ S )Nr r> r@ rA r' r( Ú_jsonb_decoderq s zCPGDialect_asyncpg.setup_asyncpg_jsonb_codec.<locals>._jsonb_decoderZjsonbrC rD rE N)r rI rJ rK rL )r< rN rO rR rS r' rA r( Úsetup_asyncpg_jsonb_codec] s
|
ûz+PGDialect_asyncpg.setup_asyncpg_jsonb_codecc s t ¡ fdd}|S )zöon_connect for asyncpg
|
|
A major component of this for asyncpg is to set up type decoders at the
|
asyncpg level.
|
|
See https://github.com/MagicStack/asyncpg/issues/623 for
|
notes on JSON/JSONB implementation.
|
|
c s4 | | ¡¡ | | ¡¡ d k r0| d S r: )r¯ rP rT )rN ©r< Z super_connectr' r( r s z-PGDialect_asyncpg.on_connect.<locals>.connect)rÁ Ú
|
on_connect)r< r r rU r( rV ~ s
|
z PGDialect_asyncpg.on_connectc C s |j S r: )r r* r' r' r( Úget_driver_connection s z'PGDialect_asyncpg.get_driver_connection)br# r$ r% ZdriverZsupports_statement_cacheZ supports_server_side_cursorsr& Z has_terminateZdefault_paramstyleZ supports_sane_multi_rowcountrx Zexecution_ctx_clsr Zstatement_compilerr
Úpreparerr Z update_copyr Zcolspecsr ÚStringr) r r! r r* ÚTimer+ ÚDater- ÚDateTimer. ZIntervalr0 r ÚBooleanr/ ÚIntegerr7 Ú
|
BigIntegerr8 ÚNumericrR ÚFloatrU ÚJSONr9 Z LargeBinaryr, r ÚJSONBrA Ú JSONPathTyperG Ú JSONIndexTyperB ÚJSONIntIndexTyperD ÚJSONStrIndexTyperF ÚEnumr6 r rX r rW ÚCHARrY r Z AbstractRangerZ ZAbstractMultiRangerr Zis_asyncr~ r{ r r r5 r" r# r& rù r) r+ r- r. r1 r9 r: r< r= rP rT rV rW rÖ r' r' r r( r à s¶ æþ
|
|
|
|
! r )bÚ__doc__Ú
|
__future__r rÅ rS r rJ r rá Útypingr r Ú r Úarrayr ZPGARRAYÚbaser r
|
r r r r r r r r r r Útypesr r r r Zenginer r Zsqlr Zutil.concurrencyr r r r r! rY r) r* rZ r+ r, r[ r- r\ r. r] r/ r0 r6 r^ r7 r_ r8 rb r9 rc rA re rB rf rD rg rF rd rG r` rR ra rU rW rX ri rY ZAbstractRangeImplrZ ZAbstractMultiRangeImplrr rx r r
r r¿ r× r rì r r= r' r' r' r( Ú<module> s !2 T 7\ U
|
