o

���g
w�@
s�
dd
lm
Z

ddlZddlmZ
ddlmZ
ddlmZ
ddlmZ
ddlmZ
ddlm	Z	
dd	lm
Z

dd
lmZ
ddlm
Z
d
dlmZ
d
dlmZ
d
dlmZ
d
dlmZ
d
dlmZ
d
dlmZ
d
dlmZ
d
dlmZ
d
dlmZ
d
dlmZ
d
dlmZ
d
dlmZ
d
dl m!Z!
d
dl m"Z"
e
r�d
dlm#Z#
d
dlm$Z$
d
dlm%Z%
eded �Z&ed!e	ed"fd �Z'Gd#d$�d$ee�Z(Gd%d&�d&ee(ee'�Z)Gd'd(�d(e(e�Z*Gd)d*�d*ee(e�Z+Gd+d,�d,e(eej,�Z-ed-d.d �Z.d5d3d4�Z/dS)6�)
�annotationsN)
�Any)
�
AsyncIterator)
�Optional)
�overload)
�Sequence)
�Tuple)
�
TYPE_CHECKING)
�TypeVar�
)
�exc�)
�util)
�Result)
�_NO_ROW)
�_R)
�	_WithKeys)
�FilterResult)
�FrozenResult)
�ResultMetaData)
�Row)
�
RowMapping)
�_generative)
�greenlet_spawn)
�Literal)
�Self)
�CursorResult)
�
_KeyIndexType)
�_UniqueFilterType�_T)
�bound�_TP.c@
s:eZ
dZUd
Zded<ded<ddd	�Zeddd��
Zd
S)�AsyncCommon��Result[Any]�_real_resultr�	_metadata�return�Nonec

�
s�
t|j
j�
Id
H
d
S)zClose this result.N)rr%�close�
�selfr#r#�H/usr/local/lib/python3.10/dist-packages/sqlalchemy/ext/asyncio/result.pyr)2s�zAsyncCommon.close�boolc


C
s|jj
S)
z�proxies the .closed attribute of the underlying result object,
        if any, else raises ``AttributeError``.

        .. versionadded:: 2.0.0b3

        )r%�closedr*r#r#r,r.7szAsyncCommon.closedN)r'r()r'r-)�__name__�
__module__�__qualname__�	__slots__�__annotations__r)�propertyr.r#r#r#r,r",s




r"c@
s�
eZ
dZUd
ZdZded<dUdd�ZedVd
d��
ZdVdd
�Z	e
dWdXdd��
ZdYdd�Z	dWdZdd�Z
d[dd�Zd\d!d"�Z	dWd]d#d$�Zd[d%d&�Zd^d(d)�Zd_d+d,�Zd\d-d.�Zd\d/d0�Zed`d4d5��
Zedad7d5��
Zdad8d5�Zedbd:d;��
Zedcd=d;��
Zdcd>d;�Zd_d?d@�ZedbdAdB��
ZedadCdB��
ZdadDdB�ZdddFdG�ZededKdL��
ZedfdMdL��
ZedgdhdPdL��
ZdgdhdQdL�ZdidSdT�ZdS)j�AsyncResultalAn asyncio wrapper around a :class:`_result.Result` object.

    The :class:`_asyncio.AsyncResult` only applies to statement executions that
    use a server-side cursor.  It is returned only from the
    :meth:`_asyncio.AsyncConnection.stream` and
    :meth:`_asyncio.AsyncSession.stream` methods.

    .. note:: As is the case with :class:`_engine.Result`, this object is
       used for ORM results returned by :meth:`_asyncio.AsyncSession.execute`,
       which can yield instances of ORM mapped objects either individually or
       within tuple-like rows.  Note that these result objects do not
       deduplicate instances or rows automatically as is the case with the
       legacy :class:`_orm.Query` object. For in-Python de-duplication of
       instances or rows, use the :meth:`_asyncio.AsyncResult.unique` modifier
       method.

    .. versionadded:: 1.4

    r#�Result[_TP]r%�real_resultcC
s@|
|_|
j
|_
|
j|_d|_d
|
jvr|�d
|
jd
�
dSdS)N�_row_getter)r%r&�_unique_filter_state�_post_creational_filter�__dict__�_set_memoized_attribute)r+r7r#r#r,�__init__[s






��zAsyncResult.__init__r'�AsyncTupleResult[_TP]c


C
�|S)
z�Apply a "typed tuple" typing filter to returned rows.

        The :attr:`_asyncio.AsyncResult.t` attribute is a synonym for
        calling the :meth:`_asyncio.AsyncResult.tuples` method.

        .. versionadded:: 2.0

        r#r*r#r#r,�
tis
z
AsyncResult.tc


C
r?)
aBApply a "typed tuple" typing filter to returned rows.

        This method returns the same :class:`_asyncio.AsyncResult` object
        at runtime,
        however annotates as returning a :class:`_asyncio.AsyncTupleResult`
        object that will indicate to :pep:`484` typing tools that plain typed
        ``Tuple`` instances are returned rather than rows.  This allows
        tuple unpacking and ``__getitem__`` access of :class:`_engine.Row`
        objects to by typed, for those cases where the statement invoked
        itself included typing information.

        .. versionadded:: 2.0

        :return: the :class:`_result.AsyncTupleResult` type at typing time.

        .. seealso::

            :attr:`_asyncio.AsyncResult.t` - shorter synonym

            :attr:`_engine.Row.t` - :class:`_engine.Row` version

        r#r*r#r#r,�tuplesuszAsyncResult.tuplesN�strategy�Optional[_UniqueFilterType]rcC
�t�|
f|_
|S)
z�Apply unique filtering to the objects returned by this
        :class:`_asyncio.AsyncResult`.

        Refer to :meth:`_engine.Result.unique` in the synchronous
        SQLAlchemy API for a complete behavioral description.

        ��setr9�r+rBr#r#r,�unique�s	
zAsyncResult.unique�col_expressionsrc
G
�
|�|
�
S)
z�Establish the columns that should be returned in each row.

        Refer to :meth:`_engine.Result.columns` in the synchronous
        SQLAlchemy API for a complete behavioral description.

        �
�_column_slices�r+rIr#r#r,�columns�s
zAsyncResult.columns�size�
Optional[int]�!AsyncIterator[Sequence[Row[_TP]]]cC
�.�|j}	t
|||
�IdH}|r|V
ndSq)a�
Iterate through sub-lists of rows of the size given.

        An async iterator is returned::

            async def scroll_results(connection):
                result = await connection.stream(select(users_table))

                async for partition in result.partitions(100):
                    print("list of rows: %s" % partition)

        Refer to :meth:`_engine.Result.partitions` in the synchronous
        SQLAlchemy API for a complete behavioral description.

        TN��_manyrow_getterr�r+rO�getter�	partitionr#r#r,�
partitions�s�


�zAsyncResult.partitions�Sequence[Row[_TP]]c

�
��
t|j
�
Id
HS)zcA synonym for the :meth:`_asyncio.AsyncResult.all` method.

        .. versionadded:: 2.0

        N�r�_allrowsr*r#r#r,�fetchall�s�zAsyncResult.fetchall�Optional[Row[_TP]]c
�
�$�
t|j
|�Id
H}
|
turd
S|
S)a�
Fetch one row.

        When all rows are exhausted, returns None.

        This method is provided for backwards compatibility with
        SQLAlchemy 1.x.x.

        To fetch the first row of a result only, use the
        :meth:`_asyncio.AsyncResult.first` method.  To iterate through all
        rows, iterate the :class:`_asyncio.AsyncResult` object directly.

        :return: a :class:`_engine.Row` object if no filters are applied,
         or ``None`` if no rows remain.

        N�r�_onerow_getterr�r+�rowr#r#r,�fetchone�s
�

zAsyncResult.fetchonec�
��
t|j
||
�Id
HS)a�
Fetch many rows.

        When all rows are exhausted, returns an empty list.

        This method is provided for backwards compatibility with
        SQLAlchemy 1.x.x.

        To fetch rows in groups, use the
        :meth:`._asyncio.AsyncResult.partitions` method.

        :return: a list of :class:`_engine.Row` objects.

        .. seealso::

            :meth:`_asyncio.AsyncResult.partitions`

        N�rrT�r+rOr#r#r,�	fetchmany�s�zAsyncResult.fetchmanyc

�
rZ)z�Return all rows in a list.

        Closes the result set after invocation.   Subsequent invocations
        will return an empty list.

        :return: a list of :class:`_engine.Row` objects.

        Nr[r*r#r#r,�all�s�
zAsyncResult.all�AsyncResult[_TP]c


C
r?�
Nr#r*r#r#r,�	__aiter__

�
zAsyncResult.__aiter__�Row[_TP]c
�
�&�
t|j
|�IdH}
|
turt��
|
Srk�rrar�StopAsyncIterationrbr#r#r,�	__anext__
�
�


zAsyncResult.__anext__c

�
��
t|j
d
d
d
�IdHS)a�Fetch the first row or ``None`` if no row is present.

        Closes the result set and discards remaining rows.

        .. note::  This method returns one **row**, e.g. tuple, by default.
           To return exactly one single scalar value, that is, the first
           column of the first row, use the
           :meth:`_asyncio.AsyncResult.scalar` method,
           or combine :meth:`_asyncio.AsyncResult.scalars` and
           :meth:`_asyncio.AsyncResult.first`.

           Additionally, in contrast to the behavior of the legacy  ORM
           :meth:`_orm.Query.first` method, **no limit is applied** to the
           SQL query which was invoked to produce this
           :class:`_asyncio.AsyncResult`;
           for a DBAPI driver that buffers results in memory before yielding
           rows, all rows will be sent to the Python process and all but
           the first row will be discarded.

           .. seealso::

                :ref:`migration_20_unify_select`

        :return: a :class:`_engine.Row` object, or None
         if no rows remain.

        .. seealso::

            :meth:`_asyncio.AsyncResult.scalar`

            :meth:`_asyncio.AsyncResult.one`

        FN�r�
_only_one_rowr*r#r#r,�first
s�"zAsyncResult.firstc

�
��
t|j
d
dd�IdHS)a�
Return at most one result or raise an exception.

        Returns ``None`` if the result has no rows.
        Raises :class:`.MultipleResultsFound`
        if multiple rows are returned.

        .. versionadded:: 1.4

        :return: The first :class:`_engine.Row` or ``None`` if no row
         is available.

        :raises: :class:`.MultipleResultsFound`

        .. seealso::

            :meth:`_asyncio.AsyncResult.first`

            :meth:`_asyncio.AsyncResult.one`

        TFNrur*r#r#r,�one_or_none/
s�zAsyncResult.one_or_noner+�AsyncResult[Tuple[_T]]rc


�
��
dSrkr#r*r#r#r,�
scalar_oneF
��
zAsyncResult.scalar_onerc


�
r{rkr#r*r#r#r,r|I
r}c

�
rt)aB
Return exactly one scalar result or raise an exception.

        This is equivalent to calling :meth:`_asyncio.AsyncResult.scalars` and
        then :meth:`_asyncio.AsyncScalarResult.one`.

        .. seealso::

            :meth:`_asyncio.AsyncScalarResult.one`

            :meth:`_asyncio.AsyncResult.scalars`

        TNrur*r#r#r,r|L
��
�Optional[_T]c


�
r{rkr#r*r#r#r,�scalar_one_or_none[
��zAsyncResult.scalar_one_or_none�
Optional[Any]c


�
r{rkr#r*r#r#r,r�`
r}c

�
s�
t|j
d
dd
�IdHS)aH
Return exactly one scalar result or ``None``.

        This is equivalent to calling :meth:`_asyncio.AsyncResult.scalars` and
        then :meth:`_asyncio.AsyncScalarResult.one_or_none`.

        .. seealso::

            :meth:`_asyncio.AsyncScalarResult.one_or_none`

            :meth:`_asyncio.AsyncResult.scalars`

        TFNrur*r#r#r,r�c
r~c

�
��
t|j
d
d
d�IdHS)a�Return exactly one row or raise an exception.

        Raises :class:`.NoResultFound` if the result returns no
        rows, or :class:`.MultipleResultsFound` if multiple rows
        would be returned.

        .. note::  This method returns one **row**, e.g. tuple, by default.
           To return exactly one single scalar value, that is, the first
           column of the first row, use the
           :meth:`_asyncio.AsyncResult.scalar_one` method, or combine
           :meth:`_asyncio.AsyncResult.scalars` and
           :meth:`_asyncio.AsyncResult.one`.

        .. versionadded:: 1.4

        :return: The first :class:`_engine.Row`.

        :raises: :class:`.MultipleResultsFound`, :class:`.NoResultFound`

        .. seealso::

            :meth:`_asyncio.AsyncResult.first`

            :meth:`_asyncio.AsyncResult.one_or_none`

            :meth:`_asyncio.AsyncResult.scalar_one`

        TFNrur*r#r#r,�oner
s�zAsyncResult.onec


�
r{rkr#r*r#r#r,�scalar�
r}zAsyncResult.scalarc


�
r{rkr#r*r#r#r,r��
r}c

�
r�)a�
Fetch the first column of the first row, and close the result set.

        Returns ``None`` if there are no rows to fetch.

        No validation is performed to test if additional rows remain.

        After calling this method, the object is fully closed,
        e.g. the :meth:`_engine.CursorResult.close`
        method will have been called.

        :return: a Python scalar value, or ``None`` if no rows remain.

        FTNrur*r#r#r,r��
s��FrozenResult[_TP]c

�
s�
tt
|�Id
HS)aReturn a callable object that will produce copies of this
        :class:`_asyncio.AsyncResult` when invoked.

        The callable object returned is an instance of
        :class:`_engine.FrozenResult`.

        This is used for result set caching.  The method must be called
        on the result when it has been unconsumed, and calling the method
        will consume the result fully.   When the :class:`_engine.FrozenResult`
        is retrieved from a cache, it can be called any number of times where
        it will produce a new :class:`_engine.Result` object each time
        against its stored set of rows.

        .. seealso::

            :ref:`do_orm_execute_re_executing` - example usage within the
            ORM to implement a result-set cache.

        N)rrr*r#r#r,�freeze�
s�zAsyncResult.freeze�index�
Literal[0]�AsyncScalarResult[_T]c
C
�dSrkr#�r+r�r#r#r,�scalars�
szAsyncResult.scalarsc


C
r�rkr#r*r#r#r,r��
rmr
�AsyncScalarResult[Any]c
C
r�rkr#r�r#r#r,r��
rmcC
st|j
|
�S)
a>Return an :class:`_asyncio.AsyncScalarResult` filtering object which
        will return single elements rather than :class:`_row.Row` objects.

        Refer to :meth:`_result.Result.scalars` in the synchronous
        SQLAlchemy API for a complete behavioral description.

        :param index: integer or row key indicating the column to be fetched
         from each row, defaults to ``0`` indicating the first column.

        :return: a new :class:`_asyncio.AsyncScalarResult` filtering object
         referring to this :class:`_asyncio.AsyncResult` object.

        )�AsyncScalarResultr%r�r#r#r,r��
s�AsyncMappingResultc

C
s
t|j
�
S)
a�
Apply a mappings filter to returned rows, returning an instance of
        :class:`_asyncio.AsyncMappingResult`.

        When this filter is applied, fetching rows will return
        :class:`_engine.RowMapping` objects instead of :class:`_engine.Row`
        objects.

        :return: a new :class:`_asyncio.AsyncMappingResult` filtering object
         referring to the underlying :class:`_result.Result` object.

        )r�r%r*r#r#r,�mappings�
s

zAsyncResult.mappings)r7r6)r'r>rk�rBrCr'r�rIrr'r)rOrPr'rQ)r'rY)r'r^)rOrPr'rY)r'rj)r'rn)r+rzr'r�r'r)r+rzr'r�r'r�)r'r�)r+rzr�r�r'r�)r+rzr'r�)
r
)r�rr'r��r'r�)r/r0r1�__doc__r2r3r=r4r@rArrHrNrXr]rdrhrirlrrrwryrr|r�r�r�r�r�r�r#r#r#r,r5Bs^







�

	�




$













r5c@
s�eZ
dZd
ZdZdZd*dd	�Z	
d+d,dd�Z	
d+d-dd�Zd.dd�Z	d+d/dd�Z
d.dd�Zd0dd�Zd1d!d"�Z
d2d$d%�Zd2d&d'�Zd1d(d)�Zd
S)3r�a�
A wrapper for a :class:`_asyncio.AsyncResult` that returns scalar values
    rather than :class:`_row.Row` values.

    The :class:`_asyncio.AsyncScalarResult` object is acquired by calling the
    :meth:`_asyncio.AsyncResult.scalars` method.

    Refer to the :class:`_result.ScalarResult` object in the synchronous
    SQLAlchemy API for a complete behavioral description.

    .. versionadded:: 1.4

    r#Fr7r$r�rcC
sD|
|_|
j
r|
j|_d|_n|
j�|g
�
|_t�d
�
|_|
j|_dS�Nr
)r%�_source_supports_scalarsr&r:�_reduce�operator�
itemgetterr9)r+r7r�r#r#r,r=�
s



zAsyncScalarResult.__init__NrBrCr'rcC
rD)
z�Apply unique filtering to the objects returned by this
        :class:`_asyncio.AsyncScalarResult`.

        See :meth:`_asyncio.AsyncResult.unique` for usage details.

        rErGr#r#r,rH�

zAsyncScalarResult.uniquerOrP�AsyncIterator[Sequence[_R]]cC
rR)z�Iterate through sub-lists of elements of the size given.

        Equivalent to :meth:`_asyncio.AsyncResult.partitions` except that
        scalar values, rather than :class:`_engine.Row` objects,
        are returned.

        TNrSrUr#r#r,rX��


�zAsyncScalarResult.partitions�Sequence[_R]c

�
rZ)z@A synonym for the :meth:`_asyncio.AsyncScalarResult.all` method.Nr[r*r#r#r,r](��zAsyncScalarResult.fetchallc�
re)z�Fetch many objects.

        Equivalent to :meth:`_asyncio.AsyncResult.fetchmany` except that
        scalar values, rather than :class:`_engine.Row` objects,
        are returned.

        Nrfrgr#r#r,rh-s�zAsyncScalarResult.fetchmanyc

�
rZ)z�Return all scalar values in a list.

        Equivalent to :meth:`_asyncio.AsyncResult.all` except that
        scalar values, rather than :class:`_engine.Row` objects,
        are returned.

        Nr[r*r#r#r,ri7s�zAsyncScalarResult.all�AsyncScalarResult[_R]c


C
r?rkr#r*r#r#r,rlArmzAsyncScalarResult.__aiter__rc
�
rorkrprbr#r#r,rrDrszAsyncScalarResult.__anext__�Optional[_R]c

�
rt)z�Fetch the first object or ``None`` if no object is present.

        Equivalent to :meth:`_asyncio.AsyncResult.first` except that
        scalar values, rather than :class:`_engine.Row` objects,
        are returned.

        FNrur*r#r#r,rwK��zAsyncScalarResult.firstc

�
rx)z�Return at most one object or raise an exception.

        Equivalent to :meth:`_asyncio.AsyncResult.one_or_none` except that
        scalar values, rather than :class:`_engine.Row` objects,
        are returned.

        TFNrur*r#r#r,ryUr�zAsyncScalarResult.one_or_nonec

�
r�)z�Return exactly one object or raise an exception.

        Equivalent to :meth:`_asyncio.AsyncResult.one` except that
        scalar values, rather than :class:`_engine.Row` objects,
        are returned.

        TFNrur*r#r#r,r�_r�zAsyncScalarResult.one)r7r$r�rrkr��rOrPr'r��r'r��rOrPr'r�)r'r��r'r�r'r�)r/r0r1r�r2�_generate_rowsr=rHrXr]rhrirlrrrwryr�r#r#r#r,r��
s"


��









r�c@
s�eZ
dZd
ZdZdZe�d�
Zd.dd�Z			d/d0dd�Z
d1dd�Z		d/d2dd�Zd3dd�Z
d4dd�Z		d/d5dd �Zd3d!d"�Zd6d#d$�Zd7d&d'�Zd4d(d)�Zd4d*d+�Zd7d,d-�Zd	S)8r�a�
A wrapper for a :class:`_asyncio.AsyncResult` that returns dictionary
    values rather than :class:`_engine.Row` values.

    The :class:`_asyncio.AsyncMappingResult` object is acquired by calling the
    :meth:`_asyncio.AsyncResult.mappings` method.

    Refer to the :class:`_result.MappingResult` object in the synchronous
    SQLAlchemy API for a complete behavioral description.

    .. versionadded:: 1.4

    r#T�_mapping�resultr$cC
s4|
|_|
j
|_
|
j|_|
jr|j�d
g
�
|_dSdSr�)r%r9r&r�r�)r+r�r#r#r,r=~s




�zAsyncMappingResult.__init__NrBrCr'rcC
rD)
z�Apply unique filtering to the objects returned by this
        :class:`_asyncio.AsyncMappingResult`.

        See :meth:`_asyncio.AsyncResult.unique` for usage details.

        rErGr#r#r,rH�r�zAsyncMappingResult.uniquerIrc
G
rJ)
z:Establish the columns that should be returned in each row.rKrMr#r#r,rN�s
zAsyncMappingResult.columnsrOrP�#AsyncIterator[Sequence[RowMapping]]cC
rR)z�Iterate through sub-lists of elements of the size given.

        Equivalent to :meth:`_asyncio.AsyncResult.partitions` except that
        :class:`_engine.RowMapping` values, rather than :class:`_engine.Row`
        objects, are returned.

        TNrSrUr#r#r,rX�r�zAsyncMappingResult.partitions�Sequence[RowMapping]c

�
rZ)zAA synonym for the :meth:`_asyncio.AsyncMappingResult.all` method.Nr[r*r#r#r,r]�r�zAsyncMappingResult.fetchall�Optional[RowMapping]c
�
r_)z�Fetch one object.

        Equivalent to :meth:`_asyncio.AsyncResult.fetchone` except that
        :class:`_engine.RowMapping` values, rather than :class:`_engine.Row`
        objects, are returned.

        Nr`rbr#r#r,rd�s
�	

zAsyncMappingResult.fetchonec�
re)z�Fetch many rows.

        Equivalent to :meth:`_asyncio.AsyncResult.fetchmany` except that
        :class:`_engine.RowMapping` values, rather than :class:`_engine.Row`
        objects, are returned.

        Nrfrgr#r#r,rh�s�zAsyncMappingResult.fetchmanyc

�
rZ)z�Return all rows in a list.

        Equivalent to :meth:`_asyncio.AsyncResult.all` except that
        :class:`_engine.RowMapping` values, rather than :class:`_engine.Row`
        objects, are returned.

        Nr[r*r#r#r,ri�s�	zAsyncMappingResult.allc


C
r?rkr#r*r#r#r,rl�rmzAsyncMappingResult.__aiter__rc
�
rorkrprbr#r#r,rr�rszAsyncMappingResult.__anext__c

�
rt)z�Fetch the first object or ``None`` if no object is present.

        Equivalent to :meth:`_asyncio.AsyncResult.first` except that
        :class:`_engine.RowMapping` values, rather than :class:`_engine.Row`
        objects, are returned.

        FNrur*r#r#r,rw�r�zAsyncMappingResult.firstc

�
rx)z�Return at most one object or raise an exception.

        Equivalent to :meth:`_asyncio.AsyncResult.one_or_none` except that
        :class:`_engine.RowMapping` values, rather than :class:`_engine.Row`
        objects, are returned.

        TFNrur*r#r#r,ry�r�zAsyncMappingResult.one_or_nonec

�
r�)z�Return exactly one object or raise an exception.

        Equivalent to :meth:`_asyncio.AsyncResult.one` except that
        :class:`_engine.RowMapping` values, rather than :class:`_engine.Row`
        objects, are returned.

        TFNrur*r#r#r,r��r�zAsyncMappingResult.one)r�r$rkr�r�)rOrPr'r�)r'r�)r'r�)rOrPr'r�r�)r'r)r/r0r1r�r2r�r��
attrgetterr:r=rHrNrXr]rdrhrirlrrrwryr�r#r#r#r,r�js*



	�

�

�






r�c@
s�eZ
dZd
ZdZerz	d2d3dd	�Zd4dd�Zd5dd�Zd2d6dd�Z	d5dd�Z
d7dd�Zd8dd�Zd4dd�Z
d4dd�Zd8dd�Zed9d#d$��
Zed:d&d$��
Zd:d'd$�Zed;d)d*��
Zed<d,d*��
Zd<d-d*�Zed;d.d/��
Zed:d0d/��
Zd:d1d/�ZdSdS)=�AsyncTupleResulta
A :class:`_asyncio.AsyncResult` that's typed as returning plain
    Python tuples instead of rows.

    Since :class:`_engine.Row` acts like a tuple in every way already,
    this class is a typing only class, regular :class:`_asyncio.AsyncResult` is
    still used at runtime.

    r#NrOrPr'r�c
�
��
d
S)z�Iterate through sub-lists of elements of the size given.

            Equivalent to :meth:`_result.Result.partitions` except that
            tuple values, rather than :class:`_engine.Row` objects,
            are returned.

            Nr#rgr#r#r,rX
s�
zAsyncTupleResult.partitionsr�c


�
r�)z�Fetch one tuple.

            Equivalent to :meth:`_result.Result.fetchone` except that
            tuple values, rather than :class:`_engine.Row`
            objects, are returned.

            Nr#r*r#r#r,rd��zAsyncTupleResult.fetchoner�c


�
r�)z:A synonym for the :meth:`_engine.ScalarResult.all` method.Nr#r*r#r#r,r]#s�zAsyncTupleResult.fetchallc
�
r�)z�Fetch many objects.

            Equivalent to :meth:`_result.Result.fetchmany` except that
            tuple values, rather than :class:`_engine.Row` objects,
            are returned.

            Nr#rgr#r#r,rh'r�zAsyncTupleResult.fetchmanyc


�
r�)z�Return all scalar values in a list.

            Equivalent to :meth:`_result.Result.all` except that
            tuple values, rather than :class:`_engine.Row` objects,
            are returned.

            Nr#r*r#r#r,ri1r�zAsyncTupleResult.all�AsyncIterator[_R]c


�
r{rkr#r*r#r#r,rl;��zAsyncTupleResult.__aiter__rc


�
r{rkr#r*r#r#r,rr=r�zAsyncTupleResult.__anext__c


�
r�)z�Fetch the first object or ``None`` if no object is present.

            Equivalent to :meth:`_result.Result.first` except that
            tuple values, rather than :class:`_engine.Row` objects,
            are returned.


            Nr#r*r#r#r,rw?s�	zAsyncTupleResult.firstc


�
r�)z�Return at most one object or raise an exception.

            Equivalent to :meth:`_result.Result.one_or_none` except that
            tuple values, rather than :class:`_engine.Row` objects,
            are returned.

            Nr#r*r#r#r,ryJr�zAsyncTupleResult.one_or_nonec


�
r�)z�Return exactly one object or raise an exception.

            Equivalent to :meth:`_result.Result.one` except that
            tuple values, rather than :class:`_engine.Row` objects,
            are returned.

            Nr#r*r#r#r,r�Tr�zAsyncTupleResult.oner+�AsyncTupleResult[Tuple[_T]]rc


�
r{rkr#r*r#r#r,r|^r}zAsyncTupleResult.scalar_onerc


�
r{rkr#r*r#r#r,r|ar}c


�
r�)aL
Return exactly one scalar result or raise an exception.

            This is equivalent to calling :meth:`_engine.Result.scalars`
            and then :meth:`_engine.AsyncScalarResult.one`.

            .. seealso::

                :meth:`_engine.AsyncScalarResult.one`

                :meth:`_engine.Result.scalars`

            Nr#r*r#r#r,r|d��
rc


�
r{rkr#r*r#r#r,r�sr�z#AsyncTupleResult.scalar_one_or_noner�c


�
r{rkr#r*r#r#r,r�xr}c


�
r�)aL
Return exactly one or no scalar result.

            This is equivalent to calling :meth:`_engine.Result.scalars`
            and then :meth:`_engine.AsyncScalarResult.one_or_none`.

            .. seealso::

                :meth:`_engine.AsyncScalarResult.one_or_none`

                :meth:`_engine.Result.scalars`

            Nr#r*r#r#r,r�{r�c


�
r{rkr#r*r#r#r,r��r�zAsyncTupleResult.scalarc


�
r{rkr#r*r#r#r,r��r}c


�
r�)a�
Fetch the first column of the first row, and close the result
            set.

            Returns ``None`` if there are no rows to fetch.

            No validation is performed to test if additional rows remain.

            After calling this method, the object is fully closed,
            e.g. the :meth:`_engine.CursorResult.close`
            method will have been called.

            :return: a Python scalar value , or ``None`` if no rows remain.

            Nr#r*r#r#r,r��s�rkr�r�r�r�)r'r�r�)r+r�r'rr�)r+r�r'rr�)r/r0r1r�r2r	rXrdr]rhrirlrrrwryr�rr|r�r�r#r#r#r,r��s@
	�




















��r��_RTr$r��calling_methodrr'c�
s|�
z|j}Wnt
y


|YSw|st|d
d�}n|}|r<|jjr<t|j�
IdH
t�d|
j	j
j|
j|
j	j
jf�
�
|S)N�rawzuCan't use the %s.%s() method with a server-side cursor. Use the %s.stream() method for an async streaming result set.)�
_is_cursor�AttributeError�getattr�context�_is_server_siderr)�	async_exc�AsyncMethodRequired�__self__�	__class__r/)r�r��	is_cursor�
cursor_resultr#r#r,�_ensure_sync_result�s(�


�






���r�)r�r�r�rr'r�)0�
__future__rr��typingrrrrrrr	r
�rr�r�enginer�
engine.resultrrrrrr�
engine.rowrr�sql.baser�util.concurrencyr�util.typingrrrrrrr!r"r5r�r��
TypingOnlyr�r�r�r#r#r#r,�<module>
sX

























*&