o h@sddlZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlmZddlmZddlmZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZGd ddeZGdddedZd2ddddddddddddddeejdddddddZGdddZGdddZ Gddde j!Z"Gdd d Z#Gd!d"d"Z$e%d#gd$Z&d%e&_'e%d&gd'Z(d(e(_'d)d*Z)d3d,d-Z*d.d/Z+d0d1Z,da-dS)4N)compat) connect_utils)cursor) exceptions) introspection) prepared_stmt)protocol) serverversion) transaction)utilsc@seZdZddZdS)ConnectionMetacCst|j}t|vp t|vSN)type__mro__ Connection_ConnectionProxy)clsinstancemrorf/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/asyncpg/connection.py__instancecheck__&s z ConnectionMeta.__instancecheck__N)__name__ __module__ __qualname__rrrrrr $s r c@seZdZdZdZdejdejfddZddZ d d Z d d Z d dZ ddZ ddZddZddZddZddZddZddZdd d d!d"d#Zd$d%Zdd&d'ed(ed)efd*d+Zdd&d,ed(efd-d.Zd d/d dd0d1d2Zd3d4Zd5d6Zdddd7d8d9Zdddd:d;d<Zddd dd=d>e fd?d@Z!dddAd)e"fdBdCZ#dDddEdFdGZ$dddAdHdIZ%dddAd(efdJdKZ&dddddddddddddL dMdNZ'dddddddddddO dPdQZ(dddddddddddddddddRdSdTZ)dddddUdVdWZ*dXdYZ+dddddddddddddZ d[d\Z,d]d^Z-d_d`Z.dadbdcdddeZ/dadfdgdhZ0daddcdidjZ1dkdlZ2dd&dmdnZ3dodpZ4dqdrZ5dd&dsdtZ6dudvZ7dwdxZ8dydzZ9d{d|Z:d}d~Z;ddZddZ?ddZ@ddZAddZBddZCddZDddZEddZFddZGdddZHddZIddZJddZKddZLddZMd d ddddZNeOjPddZQeOjPddZRd d ddddZS dddZT /dd ddddZUdS)rzyA representation of a database session. Connections are created by calling :func:`~asyncpg.connection.connect`. ) _protocol _transport_loop _top_xact_aborted_pool_release_ctr _stmt_cache_stmts_to_close_stmt_cache_enabled _listeners_server_version _server_caps _intro_query _reset_query_proxy_stmt_exclusive_section_config_params_addr_log_listeners_termination_listeners_cancellations_source_traceback_query_loggers __weakref__configparamsc Cs ||_||_||_d|_d|_d|_||_||_||_t ||j t t t||jd|_t|_|j dk|_i|_t|_t|_t|_t|_|j}|j}t||_t|j||_ |jdkrit!j"|_#nt!j$|_#d|_%d|_&t'|_(|)rt*|_+dSd|_+dS)NFr)loopmax_size on_remove max_lifetime)r),rrrrr r!r.r,r-_StatementCachestatement_cache_size functoolspartial_weak_maybe_gc_stmtweakrefrefmax_cached_statement_lifetimer"setr#r$r%r/r1r0r3 get_settingsserver_versionr split_server_version_stringr&_detect_server_capabilitiesr'rINTRO_LOOKUP_TYPES_13r(INTRO_LOOKUP_TYPESr)r*_Atomicr+ get_debug_extract_stackr2) selfr transportr7addrr5r6settings ver_stringrrr__init__;sP        zConnection.__init__cCs`|s*|jdur,|jrd||j}nd|}t|t|js.|dSdSdSdS)Nz)unclosed connection {!r}; created at: {}z^unclosed connection {!r}; run in asyncio debug mode to show the traceback of connection origin) is_closedrr2formatwarningswarnResourceWarningr terminate)rNmsgrrr__del__{s    zConnection.__del__csV|||jvr|dt|IdHt|j|<|j|t |dS)aUAdd a listener for Postgres notifications. :param str channel: Channel to listen on. :param callable callback: A callable or a coroutine function receiving the following arguments: **connection**: a Connection the callback is registered with; **pid**: PID of the Postgres server that sent the notification; **channel**: name of the channel the notification was sent to; **payload**: the payload. .. versionchanged:: 0.24.0 The ``callback`` argument may be a coroutine function. z LISTEN {}N) _check_openr%fetchrUr _quote_identrDadd _Callback from_callable)rNchannelcallbackrrr add_listeners   zConnection.add_listenercs~|rdS||jvrdSt|}||j|vrdS|j|||j|s=|j|=|dt|IdHdSdS)z5Remove a listening callback on the specified channel.Nz UNLISTEN {}) rTr%r`raremover]rUr r^)rNrbrccbrrrremove_listeners    zConnection.remove_listenercCs(|r td|jt|dS)a{Add a listener for Postgres log messages. It will be called when asyncronous NoticeResponse is received from the connection. Possible message types are: WARNING, NOTICE, DEBUG, INFO, or LOG. :param callable callback: A callable or a coroutine function receiving the following arguments: **connection**: a Connection the callback is registered with; **message**: the `exceptions.PostgresLogMessage` message. .. versionadded:: 0.12.0 .. versionchanged:: 0.24.0 The ``callback`` argument may be a coroutine function. connection is closedN)rTrInterfaceErrorr/r_r`rarNrcrrradd_log_listeners zConnection.add_log_listenercC|jt|dS)zXRemove a listening callback for log messages. .. versionadded:: 0.12.0 N)r/discardr`rarjrrrremove_log_listenerszConnection.remove_log_listenercCrl)aAdd a listener that will be called when the connection is closed. :param callable callback: A callable or a coroutine function receiving one argument: **connection**: a Connection the callback is registered with. .. versionadded:: 0.21.0 .. versionchanged:: 0.24.0 The ``callback`` argument may be a coroutine function. N)r0r_r`rarjrrradd_termination_listeners z#Connection.add_termination_listenercCrl)aRemove a listening callback for connection termination. :param callable callback: The callable or coroutine function that was passed to :meth:`Connection.add_termination_listener`. .. versionadded:: 0.21.0 N)r0rmr`rarjrrrremove_termination_listener z&Connection.remove_termination_listenercCrl)aaAdd a logger that will be called when queries are executed. :param callable callback: A callable or a coroutine function receiving one argument: **record**, a LoggedQuery containing `query`, `args`, `timeout`, `elapsed`, `exception`, `conn_addr`, and `conn_params`. .. versionadded:: 0.29.0 N)r3r_r`rarjrrradd_query_loggers zConnection.add_query_loggercCrl)zRemove a query logger callback. :param callable callback: The callable or coroutine function that was passed to :meth:`Connection.add_query_logger`. .. versionadded:: 0.29.0 N)r3rmr`rarjrrrremove_query_loggerrqzConnection.remove_query_loggercC |jS)zAReturn the PID of the Postgres server the connection is bound to.)rget_server_pidrNrrrrus zConnection.get_server_pidcC|jS)avReturn the version of the connected PostgreSQL server. The returned value is a named tuple similar to that in ``sys.version_info``: .. code-block:: pycon >>> con.get_server_version() ServerVersion(major=9, minor=6, micro=1, releaselevel='final', serial=0) .. versionadded:: 0.8.0 )r&rvrrrget_server_versionszConnection.get_server_versioncCrt)z\Return connection settings. :return: :class:`~asyncpg.ConnectionSettings`. )rrErvrrrrEs zConnection.get_settingsNF) isolationreadonly deferrablecCs|t||||S)alCreate a :class:`~transaction.Transaction` object. Refer to `PostgreSQL documentation`_ on the meaning of transaction parameters. :param isolation: Transaction isolation mode, can be one of: `'serializable'`, `'repeatable_read'`, `'read_uncommitted'`, `'read_committed'`. If not specified, the behavior is up to the server and session, which is usually ``read_committed``. :param readonly: Specifies whether or not this transaction is read-only. :param deferrable: Specifies whether or not this transaction is deferrable. .. _`PostgreSQL documentation`: https://www.postgresql.org/docs/ current/static/sql-set-transaction.html )r\r Transaction)rNryrzr{rrrr szConnection.transactioncCrt)zReturn True if Connection is currently inside a transaction. :return bool: True if inside transaction, False otherwise. .. versionadded:: 0.16.0 )ris_in_transactionrvrrrr}1s zConnection.is_in_transaction)timeoutqueryr~returncs||s:|jr.|||||j||IdH}Wd|S1s'wY|S|j||IdH}|S|j||d|ddIdH\}}}|S)aExecute an SQL command (or commands). This method can execute many SQL commands at once, when no arguments are provided. Example: .. code-block:: pycon >>> await con.execute(''' ... CREATE TABLE mytab (a int); ... INSERT INTO mytab (a) VALUES (100), (200), (300); ... ''') INSERT 0 3 >>> await con.execute(''' ... INSERT INTO mytab (a) VALUES ($1), ($2) ... ''', 10, 20) INSERT 0 2 :param args: Query arguments. :param float timeout: Optional timeout value in seconds. :return str: Status of the last SQL command. .. versionchanged:: 0.5.4 Made it possible to pass query arguments. NrT) return_status)r\r3 _time_and_logrr_executedecode)rNrr~argsresult_statusrrrexecute:s( zConnection.executecommandcs|||||IdHS)aExecute an SQL *command* for each sequence of arguments in *args*. Example: .. code-block:: pycon >>> await con.executemany(''' ... INSERT INTO mytab (a) VALUES ($1, $2, $3); ... ''', [(1, 2, 3), (4, 5, 6)]) :param command: Command to execute. :param args: An iterable containing sequences of arguments. :param float timeout: Optional timeout value in seconds. :return None: This method discards the results of the operations. .. versionadded:: 0.7.0 .. versionchanged:: 0.11.0 `timeout` became a keyword-only parameter. .. versionchanged:: 0.22.0 ``executemany()`` is now an atomic operation, which means that either all executions succeed, or none at all. This is in contrast to prior versions, where the effect of already-processed iterations would remain in place when an error has occurred, unless ``executemany()`` was called in a transaction. Nr\ _executemany)rNrrr~rrr executemanyiszConnection.executemanyT)named use_cacheignore_custom_codec record_classcsn|dur |j}nt||r0|j|||f}|dur |S|jo/|jj p/t||jjk}t |t r8|}n |s<|rB| d}nd}|jj |||||dIdH}d} | } d} | r|j} || |IdH\} }| | |j ox|j } | } | d7} | dkrtd| | s\|| s|js|js||r|j|||f||jr|IdH|S) NstmtrrFrrzCcould not resolve query result and/or argument types in {} attempts)rget_record_class_check_record_classr"getr$r,max_cacheable_statement_sizelen isinstancestr_get_unique_idprepare _init_typesrE_introspect_typesregister_data_typesnamerInternalClientErrorrU _init_codecsmark_unpreparedputr#_cleanup_stmts)rNrr~rrrr statement stmt_nameneed_repreparetypes_with_missing_codecstriesrQtypes intro_stmtrrr_get_statementsv         zConnection._get_statementcs|jjr)z|jddd|ddIdH\}}|dd}Wntjy(d}Ynwd}|j|jt|fd|ddIdH}|dkrN|jd|fd|ddIdH|S) Nz SELECT current_setting('jit') AS cur, set_config('jit', 'off', false) AS new rrT)rcuroffzY SELECT set_config('jit', $1, false) )r'jit_Connection__executerUndefinedObjectErrorr(list)rNtypeoidsr~cfgrowr jit_staterrrrrs>    zConnection._introspect_typescs|dkr#|tjvr#tj|}|jtj|gddddIdH}n|jtj||gddddIdH}|s=td|||dS)N pg_catalogrT)limitr~rrzunknown type: {}.{}) lowerr BUILTIN_TYPE_NAME_MAPrr TYPE_BY_OID TYPE_BY_NAME ValueErrorrU)rNtypenameschematypeoidrowsrrr_introspect_types.  zConnection._introspect_type)prefetchr~rc Gs|t||d||||S)aReturn a *cursor factory* for the specified query. :param args: Query arguments. :param int prefetch: The number of rows the *cursor iterator* will prefetch (defaults to ``50``.) :param float timeout: Optional timeout in seconds. :param type record_class: If specified, the class to use for records returned by this cursor. Must be a subclass of :class:`~asyncpg.Record`. If not specified, a per-connection *record_class* is used. :return: A :class:`~cursor.CursorFactory` object. .. versionchanged:: 0.22.0 Added the *record_class* parameter. N)r\r CursorFactory)rNrrr~rrrrrr4szConnection.cursor)rr~rcs|j|||d|dIdHS)a}Create a *prepared statement* for the specified query. :param str query: Text of the query to create a prepared statement for. :param str name: Optional name of the returned prepared statement. If not specified, the name is auto-generated. :param float timeout: Optional timeout value in seconds. :param type record_class: If specified, the class to use for records returned by the prepared statement. Must be a subclass of :class:`~asyncpg.Record`. If not specified, a per-connection *record_class* is used. :return: A :class:`~prepared_stmt.PreparedStatement` instance. .. versionchanged:: 0.22.0 Added the *record_class* parameter. .. versionchanged:: 0.25.0 Added the *name* parameter. Frr~rrN)_prepare)rNrrr~rrrrr[s  zConnection.preparerrcs>||j|||durdn|||dIdH}t|||S)NT)rrr)r\rrPreparedStatement)rNrrr~rrrrrrrs  zConnection._prepare)r~rcs$||j||d||dIdHS)aRun a query and return the results as a list of :class:`Record`. :param str query: Query text. :param args: Query arguments. :param float timeout: Optional timeout value in seconds. :param type record_class: If specified, the class to use for records returned by this method. Must be a subclass of :class:`~asyncpg.Record`. If not specified, a per-connection *record_class* is used. :return list: A list of :class:`~asyncpg.Record` instances. If specified, the actual type of list elements would be *record_class*. .. versionchanged:: 0.22.0 Added the *record_class* parameter. rrNr\r)rNrr~rrrrrr]s zConnection.fetchr)columnr~cs4||||d|IdH}|sdS|d|S)aRun a query and return a value in the first row. :param str query: Query text. :param args: Query arguments. :param int column: Numeric index within the record of the value to return (defaults to 0). :param float timeout: Optional timeout value in seconds. If not specified, defaults to the value of ``command_timeout`` argument to the ``Connection`` instance constructor. :return: The value of the specified column of the first record, or None if no records were returned by the query. rNrr)rNrrr~rdatarrrfetchvals  zConnection.fetchvalcs4||j||d||dIdH}|sdS|dS)aRun a query and return the first row. :param str query: Query text :param args: Query arguments :param float timeout: Optional timeout value in seconds. :param type record_class: If specified, the class to use for the value returned by this method. Must be a subclass of :class:`~asyncpg.Record`. If not specified, a per-connection *record_class* is used. :return: The first row as a :class:`~asyncpg.Record` instance, or None if no records were returned by the query. If specified, *record_class* is used as the type for the result value. .. versionchanged:: 0.22.0 Added the *record_class* parameter. rrNrr)rNrr~rrrrrrfetchrows zConnection.fetchrowcs$||j|||d|dIdHS)aaRun a query for each sequence of arguments in *args* and return the results as a list of :class:`Record`. :param query: Query to execute. :param args: An iterable containing sequences of arguments for the query. :param float timeout: Optional timeout value in seconds. :param type record_class: If specified, the class to use for records returned by this method. Must be a subclass of :class:`~asyncpg.Record`. If not specified, a per-connection *record_class* is used. :return list: A list of :class:`~asyncpg.Record` instances. If specified, the actual type of list elements would be *record_class*. Example: .. code-block:: pycon >>> rows = await con.fetchmany(''' ... INSERT INTO mytab (a, b) VALUES ($1, $2) RETURNING a; ... ''', [('x', 1), ('y', 2), ('z', 3)]) >>> rows [, , ] .. versionadded:: 0.30.0 T) return_rowsrNr)rNrrr~rrrr fetchmanys !  zConnection.fetchmany) columns schema_namer~rUoids delimiternullheaderquoteescape force_quoteencodingc  st|}|rt|d|}|r!dddd|D}nd}|j|||| | | | | |d }dj|||d }||||Id HS) aCopy table contents to a file or file-like object. :param str table_name: The name of the table to copy data from. :param output: A :term:`path-like object `, or a :term:`file-like object `, or a :term:`coroutine function ` that takes a ``bytes`` instance as a sole argument. :param list columns: An optional list of column names to copy. :param str schema_name: An optional schema name to qualify the table. :param float timeout: Optional timeout value in seconds. The remaining keyword arguments are ``COPY`` statement options, see `COPY statement documentation`_ for details. :return: The status string of the COPY command. Example: .. code-block:: pycon >>> import asyncpg >>> import asyncio >>> async def run(): ... con = await asyncpg.connect(user='postgres') ... result = await con.copy_from_table( ... 'mytable', columns=('foo', 'bar'), ... output='file.csv', format='csv') ... print(result) ... >>> asyncio.run(run()) 'COPY 100' .. _`COPY statement documentation`: https://www.postgresql.org/docs/current/static/sql-copy.html .. versionadded:: 0.11.0 .({}), cs|]}t|VqdSrr r^.0crrr Vz-Connection.copy_from_table..r rUrrrrrrrrz!COPY {tab}{cols} TO STDOUT {opts})tabcolsoptsN)r r^rUjoin_format_copy_opts _copy_out)rN table_nameoutputrrr~rUrrrrrrrrtabnamerr copy_stmtrrrcopy_from_tables$ 3zConnection.copy_from_table) r~rUrrrrrrrrc  sX|j|||||| | | | d }| rt||| IdH}dj||d}||||IdHS)aCopy the results of a query to a file or file-like object. :param str query: The query to copy the results of. :param args: Query arguments. :param output: A :term:`path-like object `, or a :term:`file-like object `, or a :term:`coroutine function ` that takes a ``bytes`` instance as a sole argument. :param float timeout: Optional timeout value in seconds. The remaining keyword arguments are ``COPY`` statement options, see `COPY statement documentation`_ for details. :return: The status string of the COPY command. Example: .. code-block:: pycon >>> import asyncpg >>> import asyncio >>> async def run(): ... con = await asyncpg.connect(user='postgres') ... result = await con.copy_from_query( ... 'SELECT foo, bar FROM mytable WHERE foo > $1', 10, ... output='file.csv', format='csv') ... print(result) ... >>> asyncio.run(run()) 'COPY 10' .. _`COPY statement documentation`: https://www.postgresql.org/docs/current/static/sql-copy.html .. versionadded:: 0.11.0 rNzCOPY ({query}) TO STDOUT {opts})rr)rr _mogrifyrUr)rNrrr~rUrrrrrrrrrrrrrrcopy_from_queryes0zConnection.copy_from_query)rrr~rUrfreezerrrrrrforce_not_null force_nullrwherec st|}|rt|d|}|r!dddd|D}nd}||}|j|||| | | | | |||d }dj||||d }||||Id HS) aTCopy data to the specified table. :param str table_name: The name of the table to copy data to. :param source: A :term:`path-like object `, or a :term:`file-like object `, or an :term:`asynchronous iterable ` that returns ``bytes``, or an object supporting the :ref:`buffer protocol `. :param list columns: An optional list of column names to copy. :param str schema_name: An optional schema name to qualify the table. :param str where: An optional SQL expression used to filter rows when copying. .. note:: Usage of this parameter requires support for the ``COPY FROM ... WHERE`` syntax, introduced in PostgreSQL version 12. :param float timeout: Optional timeout value in seconds. The remaining keyword arguments are ``COPY`` statement options, see `COPY statement documentation`_ for details. :return: The status string of the COPY command. Example: .. code-block:: pycon >>> import asyncpg >>> import asyncio >>> async def run(): ... con = await asyncpg.connect(user='postgres') ... result = await con.copy_to_table( ... 'mytable', source='datafile.tbl') ... print(result) ... >>> asyncio.run(run()) 'COPY 140000' .. _`COPY statement documentation`: https://www.postgresql.org/docs/current/static/sql-copy.html .. versionadded:: 0.11.0 .. versionadded:: 0.29.0 Added the *where* parameter. rrrcsrrrrrrrrrz+Connection.copy_to_table..r) rUrrrrrrrrrr)COPY {tab}{cols} FROM STDIN {opts} {cond}rrrcondN)r r^rUr_format_copy_wherer_copy_in)rNrsourcerrr~rUrrrrrrrrrrrrrrrrrrrr copy_to_tables( A zConnection.copy_to_table)rrr~rcst|}|rt|d|}|r#ddd|D}d|} nd}d} dj||d } |j| d d Id H} ||} d } dj|| | | d}|j|d d || j|Id HS)a Copy a list of records to the specified table using binary COPY. :param str table_name: The name of the table to copy data to. :param records: An iterable returning row tuples to copy into the table. :term:`Asynchronous iterables ` are also supported. :param list columns: An optional list of column names to copy. :param str schema_name: An optional schema name to qualify the table. :param str where: An optional SQL expression used to filter rows when copying. .. note:: Usage of this parameter requires support for the ``COPY FROM ... WHERE`` syntax, introduced in PostgreSQL version 12. :param float timeout: Optional timeout value in seconds. :return: The status string of the COPY command. Example: .. code-block:: pycon >>> import asyncpg >>> import asyncio >>> async def run(): ... con = await asyncpg.connect(user='postgres') ... result = await con.copy_records_to_table( ... 'mytable', records=[ ... (1, 'foo', 'bar'), ... (2, 'ham', 'spam')]) ... print(result) ... >>> asyncio.run(run()) 'COPY 2' Asynchronous record iterables are also supported: .. code-block:: pycon >>> import asyncpg >>> import asyncio >>> async def run(): ... con = await asyncpg.connect(user='postgres') ... async def record_gen(size): ... for i in range(size): ... yield (i,) ... result = await con.copy_records_to_table( ... 'mytable', records=record_gen(100)) ... print(result) ... >>> asyncio.run(run()) 'COPY 100' .. versionadded:: 0.11.0 .. versionchanged:: 0.24.0 The ``records`` argument may be an asynchronous iterable. .. versionadded:: 0.29.0 Added the *where* parameter. rrcsrrrrrrrrMrz3Connection.copy_records_to_table..r*rz SELECT {cols} FROM {tab} LIMIT 1)rrT)rNz(FORMAT binary)rr) r r^rrUrrrcopy_in_state)rNrrecordsrrr~rrcol_listr intro_queryintro_psrrrrrrcopy_records_to_tables* M   z Connection.copy_records_to_tablecCs.|r |jjs td|rd|}|Sd}|S)Nz5the `where` parameter requires PostgreSQL 12 or laterzWHERE r)r'sql_copy_from_whererUnsupportedServerFeatureError)rNr where_clauserrrras zConnection._format_copy_where) rUrrrrrrrrrrrc Cstt} | dg}| dur!t| tr!| d| r!|d| D]4\}}|durY|dvr@dddd|Dd }n|d vrIt|}nt |}|d | |q%|redd|d Sd S) NrNrz FORCE_QUOTE *)rrr(rcsrrrrrrrr}rz/Connection._format_copy_opts..))rrrz{} {}r) dictlocalspoprboolappenditemsrrr _quote_literalrUupper)rNrUrrrrrrrrrrrkwargsrkvrrrrms&      zConnection._format_copy_optscszt|}Wn tyd}Ynwd}d}|jj|dur-dt|dIdHd}nt|dr5|nt|r<|}n tdt |j |durSfdd}|}z|j |||IdHW|rf SS|rn ww)NFwbTwritez_output is expected to be a file-like object, a path-like object or a coroutine function, not {}csdj|IdHdSr)r)rfrun_in_executorrr_writersz%Connection._copy_out.._writer)osfspath TypeErrorrropenhasattrcallablerUrrrcopy_outclose)rNrrr~pathwriter opened_by_usrrrrrs<     zConnection._copy_outc szt|}Wn tyd}Ynwdd}d}d}|jj|dur1dt|dIdHd}nt|dr9|n t|tj j rC|}n|}durVGfddd}|}z|j |||dd|IdHW|rqdj IdHSS|r~dj IdHww)NFrbTreadcs"eZdZddZfddZdS)z$Connection._copy_in.._ReadercSs|Srrrvrrr __aiter__sz.Connection._copy_in.._Reader.__aiter__cs*djdIdH}t|dkrt|S)Nir)r)rStopAsyncIteration)rNrrrr __anext__s  z.Connection._copy_in.._Reader.__anext__N)rrrr*r,rrrr_Readersr-)rrrrrr r!r collectionsabc AsyncIterablerrr$) rNrrr~r%readerrr'r-rrrrs>     zConnection._copy_inpublictext)rrUc s||j}|||IdH}g}t|rd} n-t|r>|dkr-tjdddd} | |dfd IdH\}} n t d |d |d t |rWtjd ddd|d} | | |||| |||| dS)a2Set an encoder/decoder pair for the specified data type. :param typename: Name of the data type the codec is for. :param schema: Schema name of the data type the codec is for (defaults to ``'public'``) :param format: The type of the argument received by the *decoder* callback, and the type of the *encoder* callback return value. If *format* is ``'text'`` (the default), the exchange datum is a ``str`` instance containing valid text representation of the data type. If *format* is ``'binary'``, the exchange datum is a ``bytes`` instance containing valid _binary_ representation of the data type. If *format* is ``'tuple'``, the exchange datum is a type-specific ``tuple`` of values. The table below lists supported data types and their format for this mode. +-----------------+---------------------------------------------+ | Type | Tuple layout | +=================+=============================================+ | ``interval`` | (``months``, ``days``, ``microseconds``) | +-----------------+---------------------------------------------+ | ``date`` | (``date ordinal relative to Jan 1 2000``,) | | | ``-2^31`` for negative infinity timestamp | | | ``2^31-1`` for positive infinity timestamp. | +-----------------+---------------------------------------------+ | ``timestamp`` | (``microseconds relative to Jan 1 2000``,) | | | ``-2^63`` for negative infinity timestamp | | | ``2^63-1`` for positive infinity timestamp. | +-----------------+---------------------------------------------+ | ``timestamp | (``microseconds relative to Jan 1 2000 | | with time zone``| UTC``,) | | | ``-2^63`` for negative infinity timestamp | | | ``2^63-1`` for positive infinity timestamp. | +-----------------+---------------------------------------------+ | ``time`` | (``microseconds``,) | +-----------------+---------------------------------------------+ | ``time with | (``microseconds``, | | time zone`` | ``time zone offset in seconds``) | +-----------------+---------------------------------------------+ | any composite | Composite value elements | | type | | +-----------------+---------------------------------------------+ :param encoder: Callable accepting a Python object as a single argument and returning a value encoded according to *format*. :param decoder: Callable accepting a single argument encoded according to *format* and returning a decoded Python object. Example: .. code-block:: pycon >>> import asyncpg >>> import asyncio >>> import datetime >>> from dateutil.relativedelta import relativedelta >>> async def run(): ... con = await asyncpg.connect(user='postgres') ... def encoder(delta): ... ndelta = delta.normalized() ... return (ndelta.years * 12 + ndelta.months, ... ndelta.days, ... ((ndelta.hours * 3600 + ... ndelta.minutes * 60 + ... ndelta.seconds) * 1000000 + ... ndelta.microseconds)) ... def decoder(tup): ... return relativedelta(months=tup[0], days=tup[1], ... microseconds=tup[2]) ... await con.set_type_codec( ... 'interval', schema='pg_catalog', encoder=encoder, ... decoder=decoder, format='tuple') ... result = await con.fetchval( ... "SELECT '2 years 3 mons 1 day'::interval") ... print(result) ... print(datetime.datetime(2002, 1, 1) + result) ... >>> asyncio.run(run()) relativedelta(years=+2, months=+3, days=+1) 2004-04-02 00:00:00 .. versionadded:: 0.12.0 Added the ``format`` keyword argument and support for 'tuple' format. .. versionchanged:: 0.12.0 The ``binary`` keyword argument is deprecated in favor of ``format``. .. versionchanged:: 0.13.0 The ``binary`` keyword argument was removed in favor of ``format``. .. versionchanged:: 0.29.0 Custom codecs for composite types are now supported with ``format='tuple'``. .. note:: It is recommended to use the ``'binary'`` or ``'tuple'`` *format* whenever possible and if the underlying type supports it. Asyncpg currently does not support text I/O for composite and range types, and some other functionality, such as :meth:`Connection.copy_to_table`, does not support types with text codecs. Nscalartuplez7only tuple-format codecs can be used on composite typeszUse `set_type_codec(..., format='tuple')` and pass/interpret data as a Python tuple. See an example at https://magicstack.github.io/asyncpg/current/usage.html#example-decoding-complex-types)hint compositeoid z cannot use custom codec on type rz2: it is neither a scalar type nor a composite typez/custom codecs on domain types are not supportedzSet the codec on the base type.zePostgreSQL does not distinguish domains from their base types in query results at the protocol level.)r6detail)r\rrErris_scalar_typeis_composite_typerUnsupportedClientFeatureErrorrriis_domain_typeadd_python_codec_drop_local_statement_cache) rNrrencoderdecoderrUrQtypeinfofull_typeinfoskindrr8rrrset_type_codecs@y        zConnection.set_type_codec)rcs8|||IdH}|j|d|||dS)a'Reset *typename* codec to the default implementation. :param typename: Name of the data type the codec is for. :param schema: Schema name of the data type the codec is for (defaults to ``'public'``) .. versionadded:: 0.12.0 Nr8)rrrEremove_python_codecr@)rNrrrCrrrreset_type_codecs    zConnection.reset_type_codeccsf||||IdH}t|std|||d}|j |||d||| dS)aSet a builtin codec for the specified scalar data type. This method has two uses. The first is to register a builtin codec for an extension type without a stable OID, such as 'hstore'. The second use is to declare that an extension type or a user-defined type is wire-compatible with a certain builtin data type and should be exchanged as such. :param typename: Name of the data type the codec is for. :param schema: Schema name of the data type the codec is for (defaults to ``'public'``). :param codec_name: The name of the builtin codec to use for the type. This should be either the name of a known core type (such as ``"int"``), or the name of a supported extension type. Currently, the only supported extension type is ``"pg_contrib.hstore"``. :param format: If *format* is ``None`` (the default), all formats supported by the target codec are declared to be supported for *typename*. If *format* is ``'text'`` or ``'binary'``, then only the specified format is declared to be supported for *typename*. .. versionchanged:: 0.18.0 The *codec_name* argument can be the name of any known core data type. Added the *format* keyword argument. Nz"cannot alias non-scalar type {}.{}r8r4) r\rrr;rrirUrrEset_builtin_type_codecr@)rNrr codec_namerUrCr8rrrrIs#    z!Connection.set_builtin_type_codeccCs|jp|j S)zReturn ``True`` if the connection is closed, ``False`` otherwise. :return bool: ``True`` if the connection is closed, ``False`` otherwise. )r r is_connectedrvrrrrTszConnection.is_closedc sZz&z|s|j|IdHWnttjfy |wW|dS|w)zClose the connection gracefully. :param float timeout: Optional timeout value in seconds. .. versionchanged:: 0.14.0 Added the *timeout* parameter. N)rTrr$ ExceptionasyncioCancelledError_abort_cleanup)rNr~rrrr$s zConnection.closecCs|s||dS)z:Terminate the connection without waiting for pending data.N)rTrOrPrvrrrrYs zConnection.terminatecsx||j|j|js|jdur:|jdus"|jjs-|j dd |id|_| dIdHdSdS)Nmessagez4Resetting connection with an active transaction {!r}ROLLBACK) r\r%clearr/rr}r_managedrcall_exception_handlerrUrrvrrr_resets  zConnection._resetc st|4IdH,|IdH|}|r+||IdHWdIdHdSWdIdHdS1IdHs`_ registrations are removed, all session configuration variables are reset to their default values, and all advisory locks are released. Note that the above describes the default query returned by :meth:`Connection.get_reset_query`. If one overloads the method by subclassing ``Connection``, then this method will do whatever the overloaded method returns, except open transactions are always terminated and any callbacks registered by :meth:`Connection.add_listener` or :meth:`Connection.add_log_listener` are removed. :param float timeout: A timeout for resetting the connection. If not specified, defaults to no timeout. N)rr~rVget_reset_queryr)rNr~ reset_queryrrrresets.zConnection.resetcCsd|_|jd|_dS)NT)r rabortrvrrrrOs  zConnection._abortcCsP||jdur|jj||j|j|j| dSr) _call_termination_listenersr*_holder_release_on_close_mark_stmts_as_closedr%rSr/r3 _clean_tasksrvrrrrP"s      zConnection._cleanupcCs4|jr|jD] }|s|q|jdSdSr)r1donecancelrS)rNfutrrrr_2s zConnection._clean_taskscCs|r tddS)Nrh)rTrrirvrrrr\:s zConnection._check_opencCstd7ad|tS)Nrz__asyncpg_{}_{:x}__)_uidrU)rNprefixrrrr>s zConnection._get_unique_idcCsD|jD]}|q|jD]}|q|j|jdSr)r"iter_statements mark_closedr#rSrNrrrrr^Cs     z Connection._mark_stmts_as_closedcCsL|jdkr |jr"|j|j|j|jfs$||j |dSdSdSdSNr) refsrr"hasrrrrfr#r_rgrrr_maybe_gc_stmtMs  zConnection._maybe_gc_stmtcs4|j}t|_|D] }|j|tjIdHq dSr)r#rDrclose_statementr NO_TIMEOUT)rNto_closerrrrr`s zConnection._cleanup_stmtsc szpztj|j|j|j|jj|jjdIdHWnAty3}z| s)| |WYd}~n+d}~wt j y<Ynt t j fyY}z| sO| |WYd}~nd}~wwW|jt |j| sp|ddSdS|jt |j| s|dww)N)r7rPr6 backend_pidbackend_secret)r_cancelrr.r-rrorpConnectionResetErrorr` set_exceptionrMrNrLr1rm current_task set_result)rNwaiterexrrrrqks>      zConnection._cancelcCs|j|j||dSr)r1r_r create_taskrq)rNrvrrr_cancel_current_commandsz"Connection._cancel_current_commandcCs`|jsdStjj||d}|}|jD]}|jr$|j|||q|j |j||qdS)N)r) r/rPostgresLogMessagenew_unwrapis_asyncrrxrf call_soon)rNfields last_queryrQcon_refrfrrr_process_log_messages zConnection._process_log_messagecCsV|jsdS|}|jD]}|jr|j||q |j|j|q |jdSr)r0r|r}rrxrfr~rS)rNrrfrrrr[s z&Connection._call_termination_listenersc Cs`||jvrdS|}|j|D]}|jr"|j|||||q|j|j||||qdSr)r%r|r}rrxrfr~)rNpidrbpayloadrrfrrr_process_notifications z Connection._process_notificationcCs|jdur |}|S|j}|Sr)r*)rNrrrrr|s zConnection._unwrapcCst|jdur|jS|j}g}|jr|d|jr|d|jr(|jr(|d|jr0|dd|}||_|S)a4Return the query sent to server on connection release. The query returned by this method is used by :meth:`Connection.reset`, which is, in turn, used by :class:`~asyncpg.pool.Pool` before making the connection available to another acquirer. .. versionadded:: 0.30.0 Nz SELECT pg_advisory_unlock_all();z CLOSE ALL;z UNLISTEN *;z RESET ALL; ) r)r'advisory_locksr sql_close_all notificationsplpgsql sql_resetr)rNcapsr)rrrrWs       zConnection.get_reset_querycCs&|jdur|durtd||_dS)Nz5internal asyncpg error: connection is already proxied)r*rri)rNproxyrrr _set_proxys  zConnection._set_proxycCsB|rt|}tdj||||dkrdndd}t|dSdS)NzL{conn!r} is being released to the pool but has {c} active {type} listener{s}rsr)connrrr)rrInterfaceWarningrUrVrW)rN listeners listener_typecountwrrr_check_listenersszConnection._check_listenersrcCs>|jd7_|ttj|jd||jddS)Nr notificationlog) r!rr itertoolschain from_iterabler%valuesr/)rN stacklevelrrr _on_releaseszConnection._on_releasecCs|jdSr)r"rSrvrrrr@sz&Connection._drop_local_statement_cachecC,|jdur|jjj}|dS|dSr)r*r\_pool_drop_statement_cacher@rNpoolrrr_drop_global_statement_cache    z'Connection._drop_global_statement_cachecCs|jdSr)rrEclear_type_cachervrrr_drop_local_type_cachez!Connection._drop_local_type_cachecCrr)r*r\r_drop_type_cacherrrrr_drop_global_type_cacherz"Connection._drop_global_type_cachecs||dS)aWIndicate that the database schema information must be reloaded. For performance reasons, asyncpg caches certain aspects of the database schema, such as the layout of composite types. Consequently, when the database schema changes, and asyncpg is not able to gracefully recover from an error caused by outdated schema assumptions, an :exc:`~asyncpg.exceptions.OutdatedSchemaCacheError` is raised. To prevent the exception, this method may be used to inform asyncpg that the database schema has changed. Example: .. code-block:: pycon >>> import asyncpg >>> import asyncio >>> async def change_type(con): ... result = await con.fetch('SELECT id, info FROM tbl') ... # Change composite's attribute type "int"=>"text" ... await con.execute('ALTER TYPE custom DROP ATTRIBUTE y') ... await con.execute('ALTER TYPE custom ADD ATTRIBUTE y text') ... await con.reload_schema_state() ... for id_, info in result: ... new = (info['x'], str(info['y'])) ... await con.execute( ... 'UPDATE tbl SET info=$2 WHERE id=$1', id_, new) ... >>> async def run(): ... # Initial schema: ... # CREATE TYPE custom AS (x int, y int); ... # CREATE TABLE tbl(id int, info custom); ... con = await asyncpg.connect(user='postgres') ... async with con.transaction(): ... # Prevent concurrent changes in the table ... await con.execute('LOCK TABLE tbl') ... await change_type(con) ... >>> asyncio.run(run()) .. versionadded:: 0.14.0 N)rrrvrrrreload_schema_states* zConnection.reload_schema_state)rrrc sP|j|j|||||||dIdH\}} Wd|S1s!wY|S)N)rrr)r+r) rNrrrr~rrrrrrrrr<s    zConnection._executeccs ||dV||dS)a=Context manager that adds `callback` to the list of query loggers, and removes it upon exit. :param callable callback: A callable or a coroutine function receiving one argument: **record**, a LoggedQuery containing `query`, `args`, `timeout`, `elapsed`, `exception`, `conn_addr`, and `conn_params`. Example: .. code-block:: pycon >>> class QuerySaver: def __init__(self): self.queries = [] def __call__(self, record): self.queries.append(record.query) >>> with con.query_logger(QuerySaver()): >>> await con.execute("SELECT 1") >>> print(log.queries) ['SELECT 1'] .. versionadded:: 0.29.0 N)rrrsrjrrr query_loggerSs zConnection.query_loggerc cst}d}zFzdVWnty}z|}d}~wwWt|}t||||||j|jd}|jD]} | jrC|j | |q4|j | j |q4dSt|}t||||||j|jd}|jD]} | jrs|j | |qd|j | j |qdw)Nrrr~elapsed exception conn_addr conn_params) time monotonic BaseException LoggedQueryr.r-r3r}rrxrfr~) rNrrr~startrrwrrecordrfrrrrqsR     zConnection._time_and_logc sfdd}j|}jr@||j|||||dIdH\} } Wd| | fS1s7wY| | fSj|||||dIdH\} } | | fS)Ncsjj|d|dS)Nr)stater portal_namer return_extrar~)r bind_executerr~rrrrNrrsz&Connection.__execute..r)r _get_timeoutr3r _do_execute) rNrrrr~rrrexecutorrrrrr __executes0  zConnection.__executec sfdd}j|}j6||j||||dIdH\}}Wdn1s3wYWd|SWd|S1sKwY|S)Ncsjj|d|dS)Nr)rrrr~r)rbind_execute_manyrrrrNrrrsz)Connection._executemany..r)rrr+rr) rNrrr~rrrrrrrrrs    zConnection._executemany)rrc s.|dur|j|d||dIdH}nt}|j||||dIdH}t} || |8}| }z7|dur<||dIdH} n z|||IdH} Wt} || |8}nt} || |8}wW| |fSW| |fStjyu|IdHtjy||j s|s|j |||ddIdHYSw)NrF)retry) rrrrOutdatedSchemaCacheErrorrInvalidCachedStatementErrorrrr}r) rNrrr~rrrrbeforeafterrrrrrsT   /)zConnection._do_execute)r)FN)T)Vrrr__doc__ __slots__r_ClientConfiguration_ConnectionParametersrSr[rdrgrkrnrorprrrsrurxrEr r}rfloatrrrrrrrrrrr]rrrrrrrrrrrrFrHrIrTr$rYrVrYrOrPr_r\rr^rkrrqryrr[rr|rWrrrr@rrrrr contextlibcontextmanagerrrrrrrrrrr+s"  @     /$ f*  + ,  $ ) ' I ? Y f  '5 # 2          4     , r) metaclass<di,i<)hostportuserpasswordpassfiledatabaser7r~r=rCrcommand_timeoutssl direct_tlsconnection_classrserver_settingstarget_session_attrs krbsrvnamegsslibc s t|tstd||tjurt||durt }t |4IdHPt j did|d|d|d|d|d|d |d |d |d | d |d|d|d| d| d| d| d|d|d|IdHWdIdHS1IdHs~wYdS)a2A coroutine to establish a connection to a PostgreSQL server. The connection parameters may be specified either as a connection URI in *dsn*, or as specific keyword arguments, or both. If both *dsn* and keyword arguments are specified, the latter override the corresponding values parsed from the connection URI. The default values for the majority of arguments can be specified using `environment variables `_. Returns a new :class:`~asyncpg.connection.Connection` object. :param dsn: Connection arguments specified using as a single string in the `libpq connection URI format`_: ``postgres://user:password@host:port/database?option=value``. The following options are recognized by asyncpg: ``host``, ``port``, ``user``, ``database`` (or ``dbname``), ``password``, ``passfile``, ``sslmode``, ``sslcert``, ``sslkey``, ``sslrootcert``, and ``sslcrl``. Unlike libpq, asyncpg will treat unrecognized options as `server settings`_ to be used for the connection. .. note:: The URI must be *valid*, which means that all components must be properly quoted with :py:func:`urllib.parse.quote_plus`, and any literal IPv6 addresses must be enclosed in square brackets. For example: .. code-block:: text postgres://dbuser@[fe80::1ff:fe23:4567:890a%25eth0]/dbname :param host: Database host address as one of the following: - an IP address or a domain name; - an absolute path to the directory containing the database server Unix-domain socket (not supported on Windows); - a sequence of any of the above, in which case the addresses will be tried in order, and the first successful connection will be returned. If not specified, asyncpg will try the following, in order: - host address(es) parsed from the *dsn* argument, - the value of the ``PGHOST`` environment variable, - on Unix, common directories used for PostgreSQL Unix-domain sockets: ``"/run/postgresql"``, ``"/var/run/postgresl"``, ``"/var/pgsql_socket"``, ``"/private/tmp"``, and ``"/tmp"``, - ``"localhost"``. :param port: Port number to connect to at the server host (or Unix-domain socket file extension). If multiple host addresses were specified, this parameter may specify a sequence of port numbers of the same length as the host sequence, or it may specify a single port number to be used for all host addresses. If not specified, the value parsed from the *dsn* argument is used, or the value of the ``PGPORT`` environment variable, or ``5432`` if neither is specified. :param user: The name of the database role used for authentication. If not specified, the value parsed from the *dsn* argument is used, or the value of the ``PGUSER`` environment variable, or the operating system name of the user running the application. :param database: The name of the database to connect to. If not specified, the value parsed from the *dsn* argument is used, or the value of the ``PGDATABASE`` environment variable, or the computed value of the *user* argument. :param password: Password to be used for authentication, if the server requires one. If not specified, the value parsed from the *dsn* argument is used, or the value of the ``PGPASSWORD`` environment variable. Note that the use of the environment variable is discouraged as other users and applications may be able to read it without needing specific privileges. It is recommended to use *passfile* instead. Password may be either a string, or a callable that returns a string. If a callable is provided, it will be called each time a new connection is established. :param passfile: The name of the file used to store passwords (defaults to ``~/.pgpass``, or ``%APPDATA%\postgresql\pgpass.conf`` on Windows). :param loop: An asyncio event loop instance. If ``None``, the default event loop will be used. :param float timeout: Connection timeout in seconds. :param int statement_cache_size: The size of prepared statement LRU cache. Pass ``0`` to disable the cache. :param int max_cached_statement_lifetime: The maximum time in seconds a prepared statement will stay in the cache. Pass ``0`` to allow statements be cached indefinitely. :param int max_cacheable_statement_size: The maximum size of a statement that can be cached (15KiB by default). Pass ``0`` to allow all statements to be cached regardless of their size. :param float command_timeout: The default timeout for operations on this connection (the default is ``None``: no timeout). :param ssl: Pass ``True`` or an `ssl.SSLContext `_ instance to require an SSL connection. If ``True``, a default SSL context returned by `ssl.create_default_context() `_ will be used. The value can also be one of the following strings: - ``'disable'`` - SSL is disabled (equivalent to ``False``) - ``'prefer'`` - try SSL first, fallback to non-SSL connection if SSL connection fails - ``'allow'`` - try without SSL first, then retry with SSL if the first attempt fails. - ``'require'`` - only try an SSL connection. Certificate verification errors are ignored - ``'verify-ca'`` - only try an SSL connection, and verify that the server certificate is issued by a trusted certificate authority (CA) - ``'verify-full'`` - only try an SSL connection, verify that the server certificate is issued by a trusted CA and that the requested server host name matches that in the certificate. The default is ``'prefer'``: try an SSL connection and fallback to non-SSL connection if that fails. .. note:: *ssl* is ignored for Unix domain socket communication. Example of programmatic SSL context configuration that is equivalent to ``sslmode=verify-full&sslcert=..&sslkey=..&sslrootcert=..``: .. code-block:: pycon >>> import asyncpg >>> import asyncio >>> import ssl >>> async def main(): ... # Load CA bundle for server certificate verification, ... # equivalent to sslrootcert= in DSN. ... sslctx = ssl.create_default_context( ... ssl.Purpose.SERVER_AUTH, ... cafile="path/to/ca_bundle.pem") ... # If True, equivalent to sslmode=verify-full, if False: ... # sslmode=verify-ca. ... sslctx.check_hostname = True ... # Load client certificate and private key for client ... # authentication, equivalent to sslcert= and sslkey= in ... # DSN. ... sslctx.load_cert_chain( ... "path/to/client.cert", ... keyfile="path/to/client.key", ... ) ... con = await asyncpg.connect(user='postgres', ssl=sslctx) ... await con.close() >>> asyncio.run(main()) Example of programmatic SSL context configuration that is equivalent to ``sslmode=require`` (no server certificate or host verification): .. code-block:: pycon >>> import asyncpg >>> import asyncio >>> import ssl >>> async def main(): ... sslctx = ssl.create_default_context( ... ssl.Purpose.SERVER_AUTH) ... sslctx.check_hostname = False ... sslctx.verify_mode = ssl.CERT_NONE ... con = await asyncpg.connect(user='postgres', ssl=sslctx) ... await con.close() >>> asyncio.run(main()) :param bool direct_tls: Pass ``True`` to skip PostgreSQL STARTTLS mode and perform a direct SSL connection. Must be used alongside ``ssl`` param. :param dict server_settings: An optional dict of server runtime parameters. Refer to PostgreSQL documentation for a `list of supported options `_. :param type connection_class: Class of the returned connection object. Must be a subclass of :class:`~asyncpg.connection.Connection`. :param type record_class: If specified, the class to use for records returned by queries on this connection object. Must be a subclass of :class:`~asyncpg.Record`. :param SessionAttribute target_session_attrs: If specified, check that the host has the correct attribute. Can be one of: - ``"any"`` - the first successfully connected host - ``"primary"`` - the host must NOT be in hot standby mode - ``"standby"`` - the host must be in hot standby mode - ``"read-write"`` - the host must allow writes - ``"read-only"`` - the host most NOT allow writes - ``"prefer-standby"`` - first try to find a standby host, but if none of the listed hosts is a standby server, return any of them. If not specified, the value parsed from the *dsn* argument is used, or the value of the ``PGTARGETSESSIONATTRS`` environment variable, or ``"any"`` if neither is specified. :param str krbsrvname: Kerberos service name to use when authenticating with GSSAPI. This must match the server configuration. Defaults to 'postgres'. :param str gsslib: GSS library to use for GSSAPI/SSPI authentication. Can be 'gssapi' or 'sspi'. Defaults to 'sspi' on Windows and 'gssapi' otherwise. :return: A :class:`~asyncpg.connection.Connection` instance. Example: .. code-block:: pycon >>> import asyncpg >>> import asyncio >>> async def run(): ... con = await asyncpg.connect(user='postgres') ... types = await con.fetch('SELECT * FROM pg_type') ... print(types) ... >>> asyncio.run(run()) [.)rrrvrrrre sz_StatementCache.iter_statementscCs<t|j}|j|D] }||||jqdSr)r5rrrSrrr)rNentriesrrrrrS s   z_StatementCache.clearcCs.|||jr|j|j|j||_dSdSr)rrr call_later_on_entry_expiredrrNrrrrr s   z"_StatementCache._set_entry_timeoutcCst|||}|||Sr)rr)rNrrrrrrr s  z_StatementCache._new_entrycCs4|j|j|ur|j|j||jdSdSr)rrrrrrr rrrr  sz!_StatementCache._on_entry_expiredcCs|jdur |jdSdSr)rrar rrrr s z%_StatementCache._clear_entry_callbackcCsPt|j|jkr&|jjdd\}}||||jt|j|jksdSdS)NFr)rrrpopitemrrr)rN old_query old_entryrrrr s   z_StatementCache._maybe_cleanupN)rrrrrSrrrrrrrjrrerSrrr rrrrrrr< s$    r<c@s@eZdZUejded<eed<edejdddfddZdS)r`).Nrfr}rcCs8t|rd}nt|rd}ntd||||S)NTFz7expected a callable or an `async def` function,got {!r})inspectiscoroutinefunctionr"rrirU)rrfr}rrrra* s  z_Callback.from_callableN) rrrtypingCallable__annotations__r classmethodrarrrrr`% s r`c@s(eZdZdZddZddZddZdS) rK _acquiredcC d|_dSrhrrvrrrrS< rz_Atomic.__init__cCs|jrtdd|_dS)Nz:cannot perform operation: another operation is in progressr)rrrirvrrr __enter__? s  z_Atomic.__enter__cCrrhr)rNtrtbrrr__exit__E rz_Atomic.__exit__N)rrrrrSrrrrrrrK9 s  rKc@seZdZdZdS)rrN)rrrrrrrrrI srrrz Log record of an executed query.ServerCapabilitiesrrrrrrrzPostgreSQL server capabilities.c Cst|drd}d}d}d}d}d}d}n;t|dr(d}d}d}d}d}d}d}n't|drrrrr&rr)rrVrArrrrrrrr r r r rr rrrrr< NamedTupler`rKr namedtuplerrrrHrMrr@rcrrrrs          ~ u  1