U
|
¸ý°d:{ ã @ s d dl mZ d dlZd dlmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlm Z d d lm
|
Z
|
d d
|
lm Z d d 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 dl m Z d dl m Z d dl m!Z! d dl m"Z" e
|
rRd d lm#Z# d d lm$Z$ d d lm%Z% e d ed Z&e d!e ed"f d Z'G d#d$ d$ee Z(G d%d& d&ee(ee' Z)G d'd( d(e(e Z*G d)d* d*ee(e Z+G d+d, d,e(e ej,Z-e d-d.d Z.d-d/d-d0d1d2Z/dS )3é )Ú 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 @ sB e Zd ZU dZded< ded< dddd Zed
|
dd d Zd S )Ú AsyncCommon© ú Result[Any]Ú _real_resultr Ú _metadataÚNone©Úreturnc à s t | jjI dH dS )zClose this result.N)r r% Úclose©Úselfr# r# úTd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/ext/asyncio/result.pyr* 2 s zAsyncCommon.closeÚboolc C s | j jS )zproxies the .closed attribute of the underlying result object,
|
if any, else raises ``AttributeError``.
|
|
.. versionadded:: 2.0.0b3
|
|
)r% Úclosedr+ r# r# r- r/ 7 s zAsyncCommon.closedN)Ú__name__Ú
|
__module__Ú __qualname__Ú __slots__Ú__annotations__r* Úpropertyr/ r# r# r# r- r" , s
|
r" c @ s e Zd ZU dZdZded< ddddZedd d
|
d Zdd d d Z e
|
dVdddddZ dddddZ dWddddd Z d d d d Zd d d!d"ZdXdd dd#d$Zd d d%d&Zd'd d(d)Zd*d d+d,Zd d d-d.Zd d d/d0Zed1d2d3d4d5Zed6d d7d5Zd6d d8d5Zed1d9d3d:d;Zed<d d=d;Zd<d d>d;Zd*d d?d@Zed1d9d3dAdBZed6d dCdBZd6d dDdBZdEd dFdGZed1dHdIdJdKdLZ ed1dId3dMdLZ edYddOdPdQdLZ dZddOdPdRdLZ dSd dTdUZ dS )[Ú AsyncResultal An 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# z Result[_TP]r% )Ú real_resultc C s< || _ |j| _|j| _d | _d|jkr8| d|jd ¡ d S )NZ _row_getter)r% r& Ú_unique_filter_stateÚ_post_creational_filterÚ__dict__Z_set_memoized_attribute)r, r7 r# r# r- Ú__init__[ s
|
ÿzAsyncResult.__init__zAsyncTupleResult[_TP]r( c C s | 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- Úti s
|
z AsyncResult.tc C s | S )aB Apply 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- Útuplesu s zAsyncResult.tuplesNúOptional[_UniqueFilterType]r ©Ústrategyr) c C s 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.
|
|
©Úsetr8 ©r, r@ r# r# r- Úunique s zAsyncResult.uniquer ©Úcol_expressionsr) c G s
|
| |¡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.
|
|
©Z_column_slices©r, rF r# r# r- Úcolumns s zAsyncResult.columnsú Optional[int]z!AsyncIterator[Sequence[Row[_TP]]]©Úsizer) c C s, | j }t|| |I dH }|r(|V qq(qdS )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.
|
|
N©Ú_manyrow_getterr ©r, rL ÚgetterÚ partitionr# r# r- Ú
|
partitions¤ s
|
zAsyncResult.partitionszSequence[Row[_TP]]c às t | jI dH S )zcA synonym for the :meth:`_asyncio.AsyncResult.all` method.
|
|
.. versionadded:: 2.0
|
|
N©r Z_allrowsr+ r# r# r- Úfetchall¿ s zAsyncResult.fetchallzOptional[Row[_TP]]c à s& t | j| I dH }|tkr dS |S dS )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 à s t | j| |I dH S )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©r rN ©r, rL r# r# r- Ú fetchmanyÞ s zAsyncResult.fetchmanyc à s t | jI dH S )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.
|
|
NrS r+ r# r# r- Úallõ s
|
zAsyncResult.allzAsyncResult[_TP]c C s | S ©Nr# r+ r# r# r- Ú __aiter__ s zAsyncResult.__aiter__zRow[_TP]c à s* t | j| I d H }|tkr"t n|S d S r^ ©r rV r ÚStopAsyncIterationrW r# r# r- Ú __anext__ s zAsyncResult.__anext__c à s t | jdddI dH S )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 Z _only_one_rowr+ r# r# r- Úfirst s "zAsyncResult.firstc à s t | jdddI dH S )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`
|
|
TFNrc r+ r# r# r- Ú one_or_none/ s zAsyncResult.one_or_nonezAsyncResult[Tuple[_T]]r ©r, r) c à s d S r^ r# r+ r# r# r- Ú
|
scalar_oneF s zAsyncResult.scalar_oner c às d S r^ r# r+ r# r# r- rg J s c às t | jdddI dH S )a6 Return exactly one scalar result or raise an exception.
|
|
This is equivalent to calling :meth:`_asyncio.AsyncResult.scalars` and
|
then :meth:`_asyncio.AsyncResult.one`.
|
|
.. seealso::
|
|
:meth:`_asyncio.AsyncResult.one`
|
|
:meth:`_asyncio.AsyncResult.scalars`
|
|
TNrc r+ r# r# r- rg N s ú Optional[_T]c à s d S r^ r# r+ r# r# r- Úscalar_one_or_none] s z AsyncResult.scalar_one_or_noneú Optional[Any]c à s d S r^ r# r+ r# r# r- ri c s c à s t | jdddI dH S )a< Return exactly one scalar result or ``None``.
|
|
This is equivalent to calling :meth:`_asyncio.AsyncResult.scalars` and
|
then :meth:`_asyncio.AsyncResult.one_or_none`.
|
|
.. seealso::
|
|
:meth:`_asyncio.AsyncResult.one_or_none`
|
|
:meth:`_asyncio.AsyncResult.scalars`
|
|
TFNrc r+ r# r# r- ri g s c às t | jdddI dH S )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`
|
|
TFNrc r+ r# r# r- Úonev s zAsyncResult.onec à s d S r^ r# r+ r# r# r- Úscalar s zAsyncResult.scalarc à s d S r^ r# r+ r# r# r- rl s c à s t | jdddI dH S )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.
|
|
FTNrc r+ r# r# r- rl s zFrozenResult[_TP]c às t t| I dH S )a Return 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)r r r+ r# r# r- Úfreeze s zAsyncResult.freezez
|
Literal[0]zAsyncScalarResult[_T])r, Úindexr) c C s d S r^ r# ©r, rn r# r# r- ÚscalarsÄ s zAsyncResult.scalarsc C s d S r^ r# r+ r# r# r- rp Ê s r zAsyncScalarResult[Any])rn r) c C s d S r^ r# ro r# r# r- rp Î s c C 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% ro r# r# r- rp Ò s ÚAsyncMappingResultc C s
|
t | jS )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.
|
|
)rr r% r+ r# r# r- Úmappingsâ s zAsyncResult.mappings)N)N)N)r )r ) r0 r1 r2 Ú__doc__r3 r4 r; r5 r< r= r rD rI rR rT rY r\ r] r_ rb rd re r rg ri rk rl rm rp rs r# r# r# r- r6 B s\
|
|
ÿ ÿ $ r6 c @ sÀ e Zd ZdZdZdZdddddZd)d
|
d d d dZd*dddddZddddZ d+dddddZ
|
ddddZ d dd d Z d dd d!Z d"dd#d$Zd"dd%d&Zd dd'd(Zd S ),rq 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# Fr$ r )r7 rn c C sD || _ |jr |j| _d | _n |j |g¡| _t d¡| _|j| _d S ©Nr )r% Ú_source_supports_scalarsr& r9 Ú_reduceÚoperatorÚ
|
itemgetterr8 )r, r7 rn r# r# r- r; s zAsyncScalarResult.__init__Nr> r r? c C s t |f| _| S )z±Apply unique filtering to the objects returned by this
|
:class:`_asyncio.AsyncScalarResult`.
|
|
See :meth:`_asyncio.AsyncResult.unique` for usage details.
|
|
rA rC r# r# r- rD s
|
zAsyncScalarResult.uniquerJ úAsyncIterator[Sequence[_R]]rK c C s, | j }t|| |I dH }|r(|V qq(qdS )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.
|
|
NrM rO r# r# r- rR s
|
z AsyncScalarResult.partitionsú Sequence[_R]r( c à s t | jI dH S )z@A synonym for the :meth:`_asyncio.AsyncScalarResult.all` method.NrS r+ r# r# r- rT 1 s zAsyncScalarResult.fetchallc à s t | j| |I dH S )z¾Fetch many objects.
|
|
Equivalent to :meth:`_asyncio.AsyncResult.fetchmany` except that
|
scalar values, rather than :class:`_engine.Row` objects,
|
are returned.
|
|
NrZ r[ r# r# r- r\ 6 s zAsyncScalarResult.fetchmanyc à s t | jI dH S )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.
|
|
NrS r+ r# r# r- r] @ s zAsyncScalarResult.allzAsyncScalarResult[_R]c C s | S r^ r# r+ r# r# r- r_ J s zAsyncScalarResult.__aiter__r c à s* t | j| I d H }|tkr"t n|S d S r^ r` rW r# r# r- rb M s zAsyncScalarResult.__anext__ú Optional[_R]c à s t | jdddI dH S )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.
|
|
FNrc r+ r# r# r- rd T s zAsyncScalarResult.firstc à s t | jdddI dH S )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.
|
|
TFNrc r+ r# r# r- re ^ s z AsyncScalarResult.one_or_nonec à s t | jdddI dH S )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.
|
|
TFNrc r+ r# r# r- rk h s zAsyncScalarResult.one)N)N)N)r0 r1 r2 rt r3 Ú_generate_rowsr; rD rR rT r\ r] r_ rb rd re rk r# r# r# r- rq ò s þ ÿ
|
|
|
|
rq c @ sæ e Zd ZdZdZdZe d¡ZddddZ d.d
|
d d d dZ
|
dd dddZ d/dddddZ ddddZ d dd d Zd0dddd d Zddd!d"Zd dd#d$Zd%dd&d'Zd dd(d)Zd dd*d+Zd%dd,d-Zd S )1rr 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Ú_mappingr$ )Úresultc C s0 || _ |j| _|j| _|jr,| j dg¡| _d S ru )r% r8 r& rv rw )r, r r# r# r- r; s
|
zAsyncMappingResult.__init__Nr> r r? c C s t |f| _| S )z²Apply unique filtering to the objects returned by this
|
:class:`_asyncio.AsyncMappingResult`.
|
|
See :meth:`_asyncio.AsyncResult.unique` for usage details.
|
|
rA rC r# r# r- rD s
|
zAsyncMappingResult.uniquer rE c G s
|
| |¡S )z:Establish the columns that should be returned in each row.rG rH r# r# r- rI s zAsyncMappingResult.columnsrJ z#AsyncIterator[Sequence[RowMapping]]rK c C s, | j }t|| |I dH }|r(|V qq(qdS )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.
|
|
NrM rO r# r# r- rR s
|
z AsyncMappingResult.partitionszSequence[RowMapping]r( c à s t | jI dH S )zAA synonym for the :meth:`_asyncio.AsyncMappingResult.all` method.NrS r+ r# r# r- rT ³ s zAsyncMappingResult.fetchallzOptional[RowMapping]c à s& t | j| I dH }|tkr dS |S dS )zÐFetch one object.
|
|
Equivalent to :meth:`_asyncio.AsyncResult.fetchone` except that
|
:class:`_engine.RowMapping` values, rather than :class:`_engine.Row`
|
objects, are returned.
|
|
NrU rW r# r# r- rY ¸ s zAsyncMappingResult.fetchonec à s t | j| |I dH S )zÐFetch many rows.
|
|
Equivalent to :meth:`_asyncio.AsyncResult.fetchmany` except that
|
:class:`_engine.RowMapping` values, rather than :class:`_engine.Row`
|
objects, are returned.
|
|
NrZ r[ r# r# r- r\ Ç s z AsyncMappingResult.fetchmanyc à s t | jI dH S )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.
|
|
NrS r+ r# r# r- r] Ô s zAsyncMappingResult.allc C s | S r^ r# r+ r# r# r- r_ ß s z AsyncMappingResult.__aiter__r c à s* t | j| I d H }|tkr"t n|S d S r^ r` rW r# r# r- rb â s z AsyncMappingResult.__anext__c à s t | jdddI dH S )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.
|
|
FNrc r+ r# r# r- rd é s zAsyncMappingResult.firstc à s t | jdddI dH S )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.
|
|
TFNrc r+ r# r# r- re ó s z AsyncMappingResult.one_or_nonec à s t | jdddI dH S )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.
|
|
TFNrc r+ r# r# r- rk ý s zAsyncMappingResult.one)N)N)N)r0 r1 r2 rt r3 r} rx Ú
|
attrgetterr9 r; rD rI rR rT rY r\ r] r_ rb rd re rk r# r# r# r- rr s s(
|
þ ÿ ÿ
|
|
rr c @ sJ e Zd ZdZdZerFd2dddddZd d
|
d d Zd d
|
ddZd3dd dddZ d d
|
ddZ
|
dd
|
ddZ dd
|
ddZ d d
|
ddZ d d
|
d d Zdd
|
d d Zed d!d"d#d$Zed%d
|
d&d$Zd%d
|
d'd$Zed d(d"d)d*Zed+d
|
d,d*Zd+d
|
d-d*Zed d(d"d.d/Zed%d
|
d0d/Zd%d
|
d1d/ZdS )4Ú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# NrJ rz rK c à s dS )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# r[ r# r# r- rR s
|
zAsyncTupleResult.partitionsr| r( c à s dS )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- rY " s zAsyncTupleResult.fetchoner{ c à s dS )z:A synonym for the :meth:`_engine.ScalarResult.all` method.Nr# r+ r# r# r- rT , s zAsyncTupleResult.fetchallc à s dS )zÇFetch many objects.
|
|
Equivalent to :meth:`_result.Result.fetchmany` except that
|
tuple values, rather than :class:`_engine.Row` objects,
|
are returned.
|
|
Nr# r[ r# r# r- r\ 0 s zAsyncTupleResult.fetchmanyc à s dS )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- r] : s zAsyncTupleResult.allzAsyncIterator[_R]c à s d S r^ r# r+ r# r# r- r_ D s zAsyncTupleResult.__aiter__r c à s d S r^ r# r+ r# r# r- rb G s zAsyncTupleResult.__anext__c à s dS )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- rd J s zAsyncTupleResult.firstc à s dS )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- re U s z AsyncTupleResult.one_or_nonec à s dS )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- rk _ s zAsyncTupleResult.onezAsyncTupleResult[Tuple[_T]]r rf c às d S r^ r# r+ r# r# r- rg i s zAsyncTupleResult.scalar_oner c às d S r^ r# r+ r# r# r- rg m s c às dS )a6 Return exactly one scalar result or raise an exception.
|
|
This is equivalent to calling :meth:`_engine.Result.scalars`
|
and then :meth:`_engine.Result.one`.
|
|
.. seealso::
|
|
:meth:`_engine.Result.one`
|
|
:meth:`_engine.Result.scalars`
|
|
Nr# r+ r# r# r- rg q s rh c às d S r^ r# r+ r# r# r- ri s z#AsyncTupleResult.scalar_one_or_nonerj c às d S r^ r# r+ r# r# r- ri s c às dS )a6 Return exactly one or no scalar result.
|
|
This is equivalent to calling :meth:`_engine.Result.scalars`
|
and then :meth:`_engine.Result.one_or_none`.
|
|
.. seealso::
|
|
:meth:`_engine.Result.one_or_none`
|
|
:meth:`_engine.Result.scalars`
|
|
Nr# r+ r# r# r- ri s c à s d S r^ r# r+ r# r# r- rl s zAsyncTupleResult.scalarc à s d S r^ r# r+ r# r# r- rl s c à s dS )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- rl ¡ s )N)N)r0 r1 r2 rt r3 r rR rY rT r\ r] r_ rb rd re rk r rg ri rl r# r# r# r- r s: ÿ
|
|
|
|
|
r Ú_RTr$ r )r Úcalling_methodr) c à s| z
|
| j }W n tk
|
r" | Y S X |s6t| dd }n| }|rx|jjrxt|jI d H t d|j j
|
j |j |j j
|
j f ¡| 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.) Z
|
_is_cursorÚAttributeErrorÚgetattrÚcontextZ_is_server_sider r* Ú async_excZAsyncMethodRequiredÚ__self__Ú __class__r0 )r r Z is_cursorZ cursor_resultr# r# r- Ú_ensure_sync_result¶ s$
|
|
ýüÿ r )0Ú
|
__future__r rx Útypingr r r r r r r r
|
Ú r r r Zenginer Z engine.resultr r r r r r Z
|
engine.rowr r Zsql.baser Zutil.concurrencyr Z util.typingr r r r r r r! r" r6 rq rr Z
|
TypingOnlyr r r r# r# r# r- Ú<module> sV 3 ,
|
