lmZddlmZddlmZdd
lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddl!m"Z"ddl!m#Z#ddl!m$Z$dd l m%Z%dd!l m&Z&dd"l'm(Z(dd#l)m*Z*dd$l)m+Z+ej0se(sdd%l,m-Z-ndd%l.m-Z-ej0rdd&l/m0Z0dd'l1m2Z2ee3d(fZ4ee3d(e5fZ6e Z7ee4e7fZ8eee ee fZ9 ee d)fZ: ed*e9<65>+<2B>Z;ed,e <09>+<2B>Z<ed-ee d)f<00>+<2B>Z=ee;e:fZ> eee e fZ?eed.Z@e
ee gee fZAe
e ge fZBeee eeBfZCGd/<2F>d0<64>ZDGd1<64>d2ej<>e <00>ZFGd3<64>d4eD<65>ZG dO dPd5<64>ZHGd6<64>d7e<04>ZIeIj<49>ZJGd8<64>d9e$e
e;<00>ZKGd:<3A>d;<3B>ZLGd<<3C>d=eLeKee=<00>ZMGd><3E>d?eKe;<00>ZNGd@<40>dAeNe;<00>ZOGdB<64>dCeNe;e j<><00>ZQGdD<64>dEeLeNe<00>ZRGdF<64>dGe
e=<00>ZSGdH<64>dIeMe=<00>ZTdQdJ<64>ZUGdK<64>dLeTe=<00>ZVGdM<64>dNeTe=<00>ZWy)Rz%Define generic result set constructs.<2E>)<01>annotations)<01>EnumN)<01>Any)<01>Callable)<01>cast)<01>Dict)<01>Generic)<01>Iterable)<01>Iterator)<01>List)<01>Mapping)<01>NoReturn)<01>Optional)<01>overload)<01>Sequence)<01>Set)<01>Tuple)<01>
TYPE_CHECKING)<01>TypeVar)<01>Union<6F>)<01>Row)<01>
|j
d<01><05>|s|j}|r||<05>}|r|r|dS|S#|j
d<01><05><00>xYw#|j
d<01><05><00>xYw) NT<4E>r<>z&No row was found when one was requiredF<64>r<>z6Multiple rows were found when exactly one was requiredz6Multiple rows were found when one or none was requiredr)r<>r<00>
NoResultFoundr<64>r<>rr<>r<>rr<><00>MultipleResultsFoundr<64>)rArBrCrDr(rrrr<00>existing_row_hash<73>next_rowrs rBrEzResultInternal._only_one_row<6F>s<><00><00><16>$<24>$<24><06>.4<EFBFBD><04>.E<><03><0E>;<3B><1D><19>'<27>'<27><<3C><12><12><1C><11>d<EFBFBD>3<>3<>"'<27>D<EFBFBD><1F><1B>H<EFBFBD><1B>'<27>'<27>H<EFBFBD><12>#+<2B>(<28>3<EFBFBD>-<2D><13>C<EFBFBD>
s rB<00>_column_sliceszResultInternal._column_slicesEsg<00><00><14><20><20><11><1D><1D><15>m<EFBFBD>T<EFBFBD>*<2A><14><1B>3<>3<>s<EFBFBD>7<EFBFBD>|<7C>q<EFBFBD>7H<37>!<21>^<5E>^<5E>3<>3<>G<EFBFBD><<3C>D<EFBFBD>N<EFBFBD><13>"<22>"<22>"<22>"<22><13>rDc<01><><00>|j<00>J<00>|j\}}|j<00>|jntd|<00>}|s<>|jjr<>|j
<16>T<17>l+<2B><17><11><14><11><14><11>#<23>#<23>!<21>$<24>!rDr<>c<01>$<00>eZdZUdZded<dd<04>Zy)<07> _WithKeysr.r-r<>c<01>.<00>|jjS)akReturn an iterable view which yields the string keys that would
be represented by each :class:`_engine.Row`.
The keys can represent the labels of the columns returned by a core
statement or the names of the orm classes returned by an orm
execution.
The view also can be tested for key containment using the Python
``in`` operator, which will test both for the string keys represented
in the view, as well as for alternate keys such as column objects.
.. versionchanged:: 1.4 a key view object is returned rather than a
plain list.
)r<>rCr@s rBrCz_WithKeys.keysts<00><00>"<14>~<7E>~<7E>"<22>"<22>"rDNr{)r<>r<>r<>r<>r<>rCr.rDrBrhrhns<00><00><12>I<EFBFBD><1D><1D>#rDrhc<01>d<00>eZdZUdZdZdZded<dZded<dZd ed
<e j<00>Zded<d5d
<0A>Zd6d<0E>Z
d7d<0F>Zd8d<10>Zed9d<11><04>Zed9d<12><04>Zed:d<13><04>Zed;d<d<14><05>Zd=d<15>Zed>d<16><04>Zed?d<17><04>Zed@dAd<18><05>Zd@dAd<19>ZdB dCd<1A>ZdDd<1B>ZdEd<1C>ZedFd<1D><04>ZdFd<1E>ZdGd<1F>ZdHd <20>ZdId!<21>Z d; dJd"<22>Z!dKd#<23>Z"dLd$<24>Z#d;dMd%<25>Z$dKd&<26>Z%dLd'<27>Z&dLd(<28>Z'edNd)<29><04>Z(edOd*<2A><04>Z(dOd+<2B>Z(edPd,<2C><04>Z)edQd-<2D><04>Z)dQd.<2E>Z)dId/<2F>Z*edPd0<64><04>Z+edOd1<64><04>Z+dOd2<64>Z+dRd3<64>Z,dSd4<64>Z-y)T<>Resulta\Represent a set of database results.
.. versionadded:: 1.4 The :class:`_engine.Result` object provides a
completely updated usage model and calling facade for SQLAlchemy
Core and SQLAlchemy ORM. In Core, it forms the basis of the
:class:`_engine.CursorResult` object which replaces the previous
:class:`_engine.ResultProxy` interface. When using the ORM, a
higher level object called :class:`_engine.ChunkedIteratorResult`
is normally used.
.. note:: In SQLAlchemy 1.4 and above, this object is
used for ORM results returned by :meth:`_orm.Session.execute`, which can
yield instances of ORM mapped objects either individually or within
tuple-like rows. Note that the :class:`_engine.Result` object does 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:`_engine.Result.unique` modifier
method.
.. seealso::
:ref:`tutorial_fetching_rows` - in the :doc:`/tutorial/index`
<EFBFBD>rDc<01>(<00>|jd<01><02>y)a<>close this :class:`_engine.Result`.
The behavior of this method is implementation specific, and is
not implemented by default. The method should generally end
the resources in use by the result object and also cause any
subsequent iteration or row fetching to raise
:class:`.ResourceClosedError`.
.. versionadded:: 1.4.27 - ``.close()`` was previously not generally
available for all :class:`_engine.Result` classes, instead only
being available on the :class:`_engine.CursorResult` returned for
Core statement executions. As most other result objects, namely the
ones used by the ORM, are proxying a :class:`_engine.CursorResult`
in any case, this allows the underlying cursor result to be closed
from the outside facade for the case when the ORM query is using
the ``yield_per`` execution option where it does not immediately
exhaust and autoclose the database cursor.
TrIN)r<>r@s rBrtzResult.close<73>s<00><00>(<0A><18><18>d<EFBFBD><18>#rDc<01><00>t<00><00>r>rFr@s rB<00>_soft_closedzResult._soft_closed<65>s<00><00>!<21>#<23>#rDc<01><00>t<00><00>)zkreturn ``True`` if this :class:`_engine.Result` reports .closed
.. versionadded:: 1.4.43
rFr@s rB<00>closedz
Result.closed<65><00><00><00>"<22>#<23>#rDc<01><00>||_|S)a<>Configure the row-fetching strategy to fetch ``num`` rows at a time.
This impacts the underlying behavior of the result when iterating over
the result object, or otherwise making use of methods such as
:meth:`_engine.Result.fetchone` that return one row at a time. Data
from the underlying cursor or other data source will be buffered up to
this many rows in memory, and the buffered collection will then be
yielded out one row at a time or as many rows are requested. Each time
the buffer clears, it will be refreshed to this many rows or as many
rows remain if fewer remain.
The :meth:`_engine.Result.yield_per` method is generally used in
to ensure the use of server side cursors, as well as automatically
invoke the :meth:`_engine.Result.yield_per` method to establish
a fixed row buffer size at once.
The :paramref:`_engine.Connection.execution_options.yield_per`
execution option is available for ORM operations, with
:class:`_orm.Session`-oriented use described at
:ref:`orm_queryguide_yield_per`. The Core-only version which works
with :class:`_engine.Connection` is new as of SQLAlchemy 1.4.40.
.. versionadded:: 1.4
:param num: number of rows to fetch each time the buffer is refilled.
If set to a value below 1, fetches all rows for the next buffer.
.. seealso::
:ref:`engine_stream_results` - describes Core behavior for
:meth:`_engine.Result.yield_per`
:ref:`orm_queryguide_yield_per` - in the :ref:`queryguide_toplevel`
)r5<00>rAr7s rB<00> yield_perzResult.yield_per<65>s<00><00>b<1E><04><0F><13>rDc<01>(<00>t<00>|f|_|S)aApply unique filtering to the objects returned by this
:class:`_engine.Result`.
When this filter is applied with no arguments, the rows or objects
returned will filtered such that each row is returned uniquely. The
algorithm used to determine this uniqueness is by default the Python
hashing identity of the whole tuple. In some cases a specialized
per-entity hashing scheme may be used, such as when using the ORM, a
scheme is applied which works against the primary key identity of
returned objects.
The unique filter is applied **after all other filters**, which means
if the columns returned have been refined using a method such as the
:meth:`_engine.Result.columns` or :meth:`_engine.Result.scalars`
method, the uniquing is applied to **only the column or columns
returned**. This occurs regardless of the order in which these
methods have been called upon the :class:`_engine.Result` object.
The unique filter also changes the calculus used for methods like
:meth:`_engine.Result.fetchmany` and :meth:`_engine.Result.partitions`.
When using :meth:`_engine.Result.unique`, these methods will continue
to yield the number of rows or objects requested, after uniquing
has been applied. However, this necessarily impacts the buffering
behavior of the underlying cursor or datasource, such that multiple
underlying calls to ``cursor.fetchmany()`` may be necessary in order
to accumulate enough objects in order to provide a unique collection
of the requested size.
:param strategy: a callable that will be applied to rows or objects
being iterated, which should return an object that represents the
unique value of the row. A Python ``set()`` is used to store
these identities. If not passed, a default uniqueness strategy
is used which may have been assembled by the source of this
:class:`_engine.Result` object.
<20><02>setr<74><00>rArs rB<00>uniquez
Result.uniques<00><00>L&)<29>U<EFBFBD>H<EFBFBD>$5<><04>!<21><13>rDc<01>$<00>|j|<01>S)aEstablish the columns that should be returned in each row.
This method may be used to limit the columns returned as well
as to reorder them. The given list of expressions are normally
a series of integers or string key names. They may also be
appropriate :class:`.ColumnElement` objects which correspond to
a given statement construct.
.. versionchanged:: 2.0 Due to a bug in 1.4, the
:meth:`_engine.Result.columns` method had an incorrect behavior
where calling upon the method with just one index would cause the
:class:`_engine.Result` object to yield scalar values rather than
:class:`_engine.Row` objects. In version 2.0, this behavior
has been corrected such that calling upon
:meth:`_engine.Result.columns` with a single index will
produce a :class:`_engine.Result` object that continues
to yield :class:`_engine.Row` objects, which include
:param \*col_expressions: indicates columns to be returned. Elements
may be integer row indexes, string column names, or appropriate
:class:`.ColumnElement` objects corresponding to a select construct.
:return: this :class:`_engine.Result` object with the modifications
given.
<20>rU<00>rA<00>col_expressionss rB<00>columnszResult.columns5s<00><00>Z<14>"<22>"<22>?<3F>3<>3rDc<01><00>yr>r.r@s rB<00>scalarszResult.scalarsds<00><00>>ArDc<01><00>yr>r.<00>rArhs rBr<>zResult.scalarsg<00><00><00>rDc<01><00>yr>r.r<>s rBr<>zResult.scalarsls<00><00>FIrDc<01><00>t||<01>S)a@Return a :class:`_engine.ScalarResult` filtering object which
will return single elements rather than :class:`_row.Row` objects.
E.g.::
>>> result = conn.execute(text("select int_id from table"))
>>> result.scalars().all()
[1, 2, 3]
When results are fetched from the :class:`_engine.ScalarResult`
filtering object, the single column-row that would be returned by the
:class:`_engine.Result` is instead returned as the column's value.
.. versionadded:: 1.4
: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:`_engine.ScalarResult` filtering object referring
to this :class:`_engine.Result` object.
)<01>ScalarResultr<74>s rBr<>zResult.scalarsos<00><00>.<1C>D<EFBFBD>%<25>(<28>(rDc<01>h<00>|jrtd<01><00>|jj||<02>S)zareturn a callable that will retrieve the given key from a
:class:`_engine.Row`.
<20>.can't use this function in 'only scalars' mode)r<>rGr<>rir[s rBrizResult._getter<65>s6<00><00><10>(<28>(<28>%<25>@<40><0E><0E><14>~<7E>~<7E>%<25>%<25>c<EFBFBD>8<EFBFBD>4<>4rDc<01>f<00>|jrtd<01><00>|jj|<01>S)zbreturn a callable that will retrieve the given keys from a
<10>(<28>(<28>%<25>@<40><0E><0E><14>~<7E>~<7E>2<>2<>4<EFBFBD>8<>8rDc<01><00>t|<00>S)a<>Apply a mappings filter to returned rows, returning an instance of
:class:`_engine.MappingResult`.
When this filter is applied, fetching rows will return
:class:`_engine.RowMapping` objects instead of :class:`_engine.Row`
objects.
.. versionadded:: 1.4
:return: a new :class:`_engine.MappingResult` filtering object
referring to this :class:`_engine.Result` object.
)<01>
MappingResultr@s rB<00>mappingszResult.mappings<67>s<00><00><1D>T<EFBFBD>"<22>"rDc<01><00>|S)z<>Apply a "typed tuple" typing filter to returned rows.
The :attr:`_engine.Result.t` attribute is a synonym for
calling the :meth:`_engine.Result.tuples` method.
.. versionadded:: 2.0
r.r@s rB<00>tzResult.t<>s <00><00><14>rDc<01><00>|S)a,Apply a "typed tuple" typing filter to returned rows.
This method returns the same :class:`_engine.Result` object
at runtime,
however annotates as returning a :class:`_engine.TupleResult` 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:`_engine.TupleResult` type at typing time.
.. seealso::
:attr:`_engine.Result.t` - shorter synonym
:attr:`_engine.Row._t` - :class:`_engine.Row` version
r.r@s rB<00>tuplesz
Result.tuples<65>s <00><00>0<14>rDc<01><00>t<00><00>)z<>Return a safe iterator that yields raw row data.
This is used by the :meth:`_engine.Result.merge` method
to merge multiple compatible results together.
rFr@s rB<00>_raw_row_iteratorzResult._raw_row_iterator<6F>rrDc<01>"<00>|j<00>Sr><00>rOr@s rBr<>zResult.__iter__<5F><00><00><00><13><EFBFBD><EFBFBD><20> rDc<01>"<00>|j<00>Sr><00>rSr@s rB<00>__next__zResult.__next__<5F>r<>rDc#<01>HK<00>|j}|||<01>}|r|<03><01>ny<01><12>w)a<>Iterate through sub-lists of rows of the size given.
Each list will be of the size given, excluding the last list to
be yielded, which may have a small number of rows. No empty
lists will be yielded.
The result object is automatically closed when the iterator
is fully consumed.
Note that the backend driver will usually buffer the entire result
which instructs both the DBAPI driver to use server side cursors,
if available, as well as instructs the ORM loading internals to only
build a certain amount of ORM objects from a result at a time before
yielding them out.
.. versionadded:: 1.4
:param size: indicate the maximum number of rows to be present
in each list yielded. If None, makes use of the value set by
the :meth:`_engine.Result.yield_per`, method, if it were called,
or the :paramref:`_engine.Connection.execution_options.yield_per`
execution option, which is equivalent in this regard. If
yield_per weren't set, it makes use of the
:meth:`_engine.Result.fetchmany` default, which may be backend
specific and not well defined.
:return: iterator of lists
.. seealso::
:ref:`engine_stream_results`
:ref:`orm_queryguide_yield_per` - in the :ref:`queryguide_toplevel`
N<>r?<00>rAr<><00>getter<65> partitions rB<00>
partitionszResult.partitions<6E>s3<00><00><><00>b<16>%<25>%<25><06><12><1E>t<EFBFBD>T<EFBFBD>*<2A>I<EFBFBD><18><1F><0F><15><13><><00> "c<01>"<00>|j<00>S)z4A synonym for the :meth:`_engine.Result.all` method.<2E>r$r@s rB<00>fetchallzResult.fetchall <00><00><00><14>}<7D>}<7D><EFBFBD>rDc<01>:<00>|j|<00>}|tury|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:`_engine.Result.first` method. To iterate through all
rows, iterate the :class:`_engine.Result` object directly.
:return: a :class:`_engine.Row` object if no filters are applied,
or ``None`` if no rows remain.
N<>r+r<>rRs rB<00>fetchonezResult.fetchone%s#<00><00><13>!<21>!<21>$<24>'<27><03><0E>'<27>><3E><17><16>JrDc<01>&<00>|j||<01>S)a<>Fetch many rows.
When all rows are exhausted, returns an empty sequence.
This method is provided for backwards compatibility with
SQLAlchemy 1.x.x.
To fetch rows in groups, use the :meth:`_engine.Result.partitions`
method.
:return: a sequence of :class:`_engine.Row` objects.
.. seealso::
:meth:`_engine.Result.partitions`
r<>r<>s rB<00> fetchmanyzResult.fetchmany;s<00><00>&<14>#<23>#<23>D<EFBFBD>$<24>/<2F>/rDc<01>"<00>|j<00>S)a<>Return all rows in a sequence.
Closes the result set after invocation. Subsequent invocations
will return an empty sequence.
.. versionadded:: 1.4
:return: a sequence of :class:`_engine.Row` objects.
.. seealso::
:ref:`engine_stream_results` - How to stream a large result set
without loading it completely in python.
r<>r@s rB<00>allz
Result.allPs<00><00>"<14>}<7D>}<7D><EFBFBD>rDc<01>*<00>|jddd<01><02>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:`_engine.Result.scalar` method,
or combine :meth:`_engine.Result.scalars` and
:meth:`_engine.Result.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:`_engine.Result`;
for a DBAPI driver that buffers results in memory before yielding
rows, all rows will be sent to the Python process and all but
scalar_onezResult.scalar_one<6E><00><00><00>36rDc<01><00>yr>r.r@s rBr<>zResult.scalar_one<6E><00><00><00>!$rDc<01>*<00>|jddd<01><02>S)a*Return exactly one scalar result or raise an exception.
This is equivalent to calling :meth:`_engine.Result.scalars` and
rDc<01><00>yr>r.r@s rB<00>scalar_one_or_nonezResult.scalar_one_or_none<6E>s<00><00>EHrDc<01><00>yr>r.r@s rBr<>zResult.scalar_one_or_none<6E>r<>rDc<01>*<00>|jddd<01><03>S)a0Return exactly one scalar result or ``None``.
This is equivalent to calling :meth:`_engine.Result.scalars` and
rDc<01><00>yr>r.r@s rBrDz
Result.scalar<61>s<00><00>9<rDc<01><00>yr>r.r@s rBrDz
Result.scalar<61>s<00><00> rDc<01>*<00>|jddd<02><03>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.
edd<0B><04>Zedd<0C><04>Z
dd
<0A>Zedd<0E><04>Zdd<0F>Zddd<10>Zdd<11>Zdd d<13>Zy)!<21>FilterResultaZA wrapper for a :class:`_engine.Result` that returns objects other than
:class:`_engine.Row` objects, such as dictionaries or scalar objects.
:class:`_engine.FilterResult` is the common base for additional result
APIs including :class:`_engine.MappingResult`,
:class:`_engine.ScalarResult` and :class:`_engine.AsyncResult`.
)r<>r<>r<>r<>rlr<>r<>r<>r<>c<01><00>|Sr>r.r@s rBrqzFilterResult.__enter__HrrrDc<01>><00>|jj|||<03>yr>)r<>ryrus rBryzFilterResult.__exit__Ks<00><00><0C><19><19>"<22>"<22>5<EFBFBD>%<25><19>;rDc<01>F<00>|jj|<01>|_|S)a<>Configure the row-fetching strategy to fetch ``num`` rows at a time.
The :meth:`_engine.FilterResult.yield_per` method is a pass through
to the :meth:`_engine.Result.yield_per` method. See that method's
so that the method is available on all result set implementations
.. seealso::
:ref:`engine_stream_results` - describes Core behavior for
:meth:`_engine.Result.yield_per`
:ref:`orm_queryguide_yield_per` - in the :ref:`queryguide_toplevel`
)r<>r<>r<>s rBr<>zFilterResult.yield_perNs"<00><00>&!<21>-<2D>-<2D>7<>7<><03><<3C><04><19><13>rDc<01><<00>|jj|<01><01>y<00>NrI)r<>r<>r<>s rBr<>zFilterResult._soft_closeds<00><00><0C><19><19>%<25>%<25>4<EFBFBD>%<25>0rDc<01>.<00>|jjSr>)r<>r|r@s rBr|zFilterResult._soft_closedgs<00><00><13><20><20>-<2D>-<2D>-rDc<01>.<00>|jjS)z|Return ``True`` if the underlying :class:`_engine.Result` reports
closed
.. versionadded:: 1.4.43
)r<>r~r@s rBr~zFilterResult.closedks<00><00><14><20><20>'<27>'<27>'rDc<01>8<00>|jj<00>y)zUClose this :class:`_engine.FilterResult`.
rhs rBr<>zScalarResult.__init__<5F>sc<00><00>'<27><04><19><16>/<2F>/<2F>(<28>2<>2<>D<EFBFBD>N<EFBFBD>+/<2F>D<EFBFBD>(<28>(<28>2<>2<>:<3A>:<3A>E<EFBFBD>7<EFBFBD>C<>D<EFBFBD>N<EFBFBD>+3<>+><3E>+><3E>q<EFBFBD>+A<>D<EFBFBD>(<28>$/<2F>$D<>$D<><04>!rDNc<01>(<00>t<00>|f|_|S)z<>Apply unique filtering to the objects returned by this
:class:`_engine.ScalarResult`.
See :meth:`_engine.Result.unique` for usage details.
r<>r<>s rBr<>zScalarResult.unique<75><00><00><00>&)<29>U<EFBFBD>H<EFBFBD>$5<><04>!<21><13>rDc#<01>HK<00>|j}|||<01>}|r|<03><01>ny<01><12>w)z<>Iterate through sub-lists of elements of the size given.
Equivalent to :meth:`_engine.Result.partitions` except that
scalar values, rather than :class:`_engine.Row` objects,
are returned.
Nr<4E>r<>s rBr<>zScalarResult.partitions<6E>s2<00><00><><00><16>%<25>%<25><06><12><1E>t<EFBFBD>T<EFBFBD>*<2A>I<EFBFBD><18><1F><0F><15><13>r<EFBFBD>c<01>"<00>|j<00>S)<01>:A synonym for the :meth:`_engine.ScalarResult.all` method.r<>r@s rBr<>zScalarResult.fetchall<6C>r<>rDc<01>&<00>|j||<01>S)z<>Fetch many objects.
Equivalent to :meth:`_engine.Result.fetchmany` except that
scalar values, rather than :class:`_engine.Row` objects,
are returned.
r<>r<>s rBr<>zScalarResult.fetchmany<6E>s<00><00><14>#<23>#<23>D<EFBFBD>$<24>/<2F>/rDc<01>"<00>|j<00>S)z<>Return all scalar values in a sequence.
Equivalent to :meth:`_engine.Result.all` except that
scalar values, rather than :class:`_engine.Row` objects,
are returned.
r<>r@s rBr<>zScalarResult.all<6C>s<00><00><14>}<7D>}<7D><EFBFBD>rDc<01>"<00>|j<00>Sr>r<>r@s rBr<>zScalarResult.__iter__<5F>r<>rDc<01>"<00>|j<00>Sr>r<>r@s rBr<>zScalarResult.__next__<5F>r<>rDc<01>*<00>|jddd<01><02>S)z<>Fetch the first object or ``None`` if no object is present.
Equivalent to :meth:`_engine.Result.first` except that
scalar values, rather than :class:`_engine.Row` objects,
Since :class:`_engine.Row` acts like a tuple in every way already,
this class is a typing only class, regular :class:`_engine.Result` is
still used at runtime.
r.Nc<01><00>y)z<>Iterate through sub-lists of elements of the size given.
Equivalent to :meth:`_engine.Result.partitions` except that
tuple values, rather than :class:`_engine.Row` objects,
are returned.
Nr.r<>s rBr<>zTupleResult.partitions#s<00><00>rDc<01><00>y)z<>Fetch one tuple.
Equivalent to :meth:`_engine.Result.fetchone` except that
tuple values, rather than :class:`_engine.Row`
objects, are returned.
Nr.r@s rBr<>zTupleResult.fetchone/<00><00><00>rDc<01><00>y)r<>Nr.r@s rBr<>zTupleResult.fetchall9s<00><00>rDc<01><00>y)z<>Fetch many objects.
Equivalent to :meth:`_engine.Result.fetchmany` except that
tuple values, rather than :class:`_engine.Row` objects,
are returned.
Nr.r<>s rBr<>zTupleResult.fetchmany=rrDc<01><00>y)z<>Return all scalar values in a sequence.
Equivalent to :meth:`_engine.Result.all` except that
tuple values, rather than :class:`_engine.Row` objects,
are returned.
Nr.r@s rBr<>zTupleResult.allGrrDc<01><00>yr>r.r@s rBr<>zTupleResult.__iter__Qs<00><00>CrDc<01><00>yr>r.r@s rBr<>zTupleResult.__next__Ss<00><00>#rDc<01><00>y)z<>Fetch the first object or ``None`` if no object is present.
Equivalent to :meth:`_engine.Result.first` except that
tuple values, rather than :class:`_engine.Row` objects,
are returned.
Nr.r@s rBr<>zTupleResult.firstUs<00><00>rDc<01><00>y)z<>Return at most one object or raise an exception.
Equivalent to :meth:`_engine.Result.one_or_none` except that
tuple values, rather than :class:`_engine.Row` objects,
are returned.
Nr.r@s rBr<>zTupleResult.one_or_none`rrDc<01><00>y)z<>Return exactly one object or raise an exception.
Equivalent to :meth:`_engine.Result.one` except that
tuple values, rather than :class:`_engine.Row` objects,
are returned.
Nr.r@s rBr<>zTupleResult.onejrrDc<01><00>yr>r.r@s rBr<>zTupleResult.scalar_onets<00><00><?rDc<01><00>yr>r.r@s rBr<>zTupleResult.scalar_onews<00><00>%(rDc<01><00>y)aBReturn exactly one scalar result or raise an exception.
This is equivalent to calling :meth:`_engine.Result.scalars`
and then :meth:`_engine.ScalarResult.one`.
.. seealso::
:meth:`_engine.ScalarResult.one`
:meth:`_engine.Result.scalars`
Nr.r@s rBr<>zTupleResult.scalar_onez<00><00><00>rDc<01><00>yr>r.r@s rBr<>zTupleResult.scalar_one_or_none<6E>r<>rDc<01><00>yr>r.r@s rBr<>zTupleResult.scalar_one_or_none<6E>s<00><00>7:rDc<01><00>y)aBReturn exactly one or no scalar result.
This is equivalent to calling :meth:`_engine.Result.scalars`
and then :meth:`_engine.ScalarResult.one_or_none`.
.. seealso::
:meth:`_engine.ScalarResult.one_or_none`
:meth:`_engine.Result.scalars`
Nr.r@s rBr<>zTupleResult.scalar_one_or_none<6E>rrDc<01><00>yr>r.r@s rBrDzTupleResult.scalar<61>s<00><00>BErDc<01><00>yr>r.r@s rBrDzTupleResult.scalar<61>r<>rDc<01><00>y)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@s rBrDzTupleResult.scalar<61>s<00><00>rDr>r r
r
<EFBFBD>Z
dd<0B>Zddd<0C>Zdd
<0A>Zdd<0E>Zdd<0F>Zdd<10>Zdd<11>Zdd<12>Zy)r<>z<>A wrapper for a :class:`_engine.Result` that returns dictionary values
rather than :class:`_engine.Row` values.
The :class:`_engine.MappingResult` object is acquired by calling the
:meth:`_engine.Result.mappings` method.
r.T<>_mappingc<01><><00>||_|j|_|j|_|jr"|jj dg<01>|_yyrr)r<>r<>r<>r<>rd<00>rA<00>results rBr<>zMappingResult.__init__<5F>sK<00><00>"<22><04><19>$*<2A>$?<3F>$?<3F><04>!<21><1F>)<29>)<29><04><0E><11>*<2A>*<2A>!<21>^<5E>^<5E>3<>3<>Q<EFBFBD>C<EFBFBD>8<>D<EFBFBD>N<EFBFBD>+rDNc<01>(<00>t<00>|f|_|S)z<>Apply unique filtering to the objects returned by this
:class:`_engine.MappingResult`.
See :meth:`_engine.Result.unique` for usage details.
r<>r<>s rBr<>zMappingResult.unique<75>r<>rDc<01>$<00>|j|<01>S)z:Establish the columns that should be returned in each row.r<>r<>s rBr<>zMappingResult.columns<6E>s<00><00><13>"<22>"<22>?<3F>3<>3rDc#<01>HK<00>|j}|||<01>}|r|<03><01>ny<01><12>w)z<>Iterate through sub-lists of elements of the size given.
Equivalent to :meth:`_engine.Result.partitions` except that
:class:`_engine.RowMapping` values, rather than :class:`_engine.Row`
objects, are returned.
Nr<4E>r<>s rBr<>zMappingResult.partitions<6E>s2<00><00><><00><16>%<25>%<25><06><12><1E>t<EFBFBD>T<EFBFBD>*<2A>I<EFBFBD><18><1F><0F><15><13>r<EFBFBD>c<01>"<00>|j<00>S)z;A synonym for the :meth:`_engine.MappingResult.all` method.r<>r@s rBr<>zMappingResult.fetchall<6C>r<>rDc<01>:<00>|j|<00>}|tury|S)z<>Fetch one object.
Equivalent to :meth:`_engine.Result.fetchone` except that
:class:`_engine.RowMapping` values, rather than :class:`_engine.Row`
objects, are returned.
Nr<4E>rRs rBr<>zMappingResult.fetchone<6E>s#<00><00><13>!<21>!<21>$<24>'<27><03><0E>'<27>><3E><17><16>JrDc<01>&<00>|j||<01>S)z<>Fetch many objects.
Equivalent to :meth:`_engine.Result.fetchmany` except that
:class:`_engine.RowMapping` values, rather than :class:`_engine.Row`
objects, are returned.
r<>r<>s rBr<>zMappingResult.fetchmanys<00><00><14>#<23>#<23>D<EFBFBD>$<24>/<2F>/rDc<01>"<00>|j<00>S)z<>Return all scalar values in a sequence.
Equivalent to :meth:`_engine.Result.all` except that
:class:`_engine.RowMapping` values, rather than :class:`_engine.Row`
objects, are returned.
r<>r@s rBr<>zMappingResult.alls<00><00><14>}<7D>}<7D><EFBFBD>rDc<01>"<00>|j<00>Sr>r<>r@s rBr<>zMappingResult.__iter__r<>rDc<01>"<00>|j<00>Sr>r<>r@s rBr<>zMappingResult.__next__r<>rDc<01>*<00>|jddd<01><02>S)z<>Fetch the first object or ``None`` if no object is present.
Equivalent to :meth:`_engine.Result.first` except that
:class:`_engine.RowMapping` values, rather than :class:`_engine.Row`
objects, are returned.
Fr<46>r<>r@s rBr<>zMappingResult.first rrDc<01>*<00>|jddd<02><03>S)z<>Return at most one object or raise an exception.
Equivalent to :meth:`_engine.Result.one_or_none` except that
:class:`_engine.RowMapping` values, rather than :class:`_engine.Row`
objects, are returned.
TFr<46>r<>r@s rBr<>zMappingResult.one_or_none-rrDc<01>*<00>|jddd<02><03>S)z<>Return exactly one object or raise an exception.
Equivalent to :meth:`_engine.Result.one` except that
:class:`_engine.RowMapping` values, rather than :class:`_engine.Row`
<EFBFBD>Z
dd<0B>Zddd<0C>Zy)rFz<>A :class:`_engine.Result` that gets data from a Python iterator of
:class:`_engine.Row` objects or similar row-like data.
.. versionadded:: 1.4
FNc<01><<00>||_||_||_||_yr>)r<><00>iterator<6F>rawr<77>)rArorKrLr<>s rBr<>zIteratorResult.__init__<5F>s!<00><00>)<29><04><0E><20><04><0A><16><04><08>(@<40><04>%rDc<01><00>|jS)z{Return ``True`` if this :class:`_engine.IteratorResult` has
been closed
.. versionadded:: 1.4.43
)<01>_hard_closedr@s rBr~zIteratorResult.closed<65>s<00><00><14><20><20> rDc<01><><00>|rd|_|j<00>|jjdd|i|<02><01>tg<00>|_|j<00>d|_y)NTr<54>r.)rNrLr<>r<>rK<00>_reset_memoizationsr|)rAr<><00>kws rBr<>zIteratorResult._soft_close<73>sR<00><00><0F> $<24>D<EFBFBD><1D><0F>8<EFBFBD>8<EFBFBD><1F><20>D<EFBFBD>H<EFBFBD>H<EFBFBD><20><20>1<>d<EFBFBD>1<>b<EFBFBD>1<><1C>R<EFBFBD><08><04><0A><0C><20><20>"<22><20><04>rDc<01>,<00>tjd<01><00>)NzThis result object is closed.)r<00>ResourceClosedErrorr@s rB<00>_raise_hard_closedz!IteratorResult._raise_hard_closed<65>s<00><00><11>%<25>%<25>&E<>F<>FrDc<01><00>|jSr>)rKr@s rBr<>z IteratorResult._raw_row_iterator<6F>s<00><00><13>}<7D>}<7D>rDc<01>R<00>|jr|j<00>|jSr>)rNrTrKr@s rBr<>zIteratorResult._fetchiter_impl<70>s!<00><00><0F><1C><1C><10>#<23>#<23>%<25><13>}<7D>}<7D>rDc<01><><00>|jr|j<00>t|jt<00>}|tur|j|<01><01>y|Sr<>)rNrT<00>nextrKr<>r<>)rAr<>rs rBr<>zIteratorResult._fetchone_impl<70>sI<00><00><10><1C><1C><10>#<23>#<23>%<25><12>4<EFBFBD>=<3D>=<3D>'<27>*<2A><03><0E>'<27>><3E><10><1C><1C>*<2A><1C>-<2D><17><16>JrDc<01><><00>|jr|j<00>t|j<00>|j <00>S#|j <00>wxYwr>)rNrTr<>rKr<>r@s rBr<>zIteratorResult._fetchall_impl<70>sA<00><00><0F><1C><1C><10>#<23>#<23>%<25><1F><17><04><0A><0A>&<26><10><1C><1C><1E><>D<EFBFBD><1C><1C><1E>s<00>A<00>Ac<01><><00>|jr|j<00>ttj|j
A<01><0E>!<21><0E>!<21>!<21>G<01><1D><1D>"'<27><17><1E><17> ,<2C><17><1F>%)<29>><3E>!<21>><3E> (<28>>rDrFc<01>><00>ttg<00>tg<00><00>Sr>)rFr<>r<>r.rDrB<00>null_resultr`<00>s<00><00><19>.<2E>r<EFBFBD>2<>D<EFBFBD><12>H<EFBFBD>=<3D>=rDc<01>p<00><00>eZdZdZddd<02>Zedd<03><04>Zd d
<EFBFBD>fd<04>
Zdd<0C>fd<05>
Z<08>xZ S)
<0A>ChunkedIteratorResulta<74>An :class:`_engine.IteratorResult` that works from an
iterator-producing callable.
The given ``chunks`` argument is a function that is given a number of rows
to return in each chunk, or ``None`` for all rows. The function should
then return an un-consumed iterator of lists, each list of the requested
size.
The function can be called at any time again, in which case it should
continue from the same result set but adjust the chunk size as given.
