HEX

File: //usr/local/lib/python3.10/dist-packages/sqlalchemy/engine/__pycache__/result.cpython-310.pyc
o

���g6/�@s
dZddlmZddlmZddlZddlZddlZddlZddlm	Z	ddlm
Z
ddlmZddlmZdd	lm
Z
dd
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+ejs�e(s�dd%l,m-Z-ndd%l.m-Z-ejr�dd&l/m0Z0dd'l1m2Z2ee3d(fZ4ee3d(e5fZ6e	Z7ee4e7fZ8eee	ee	fZ9	ee	d)fZ:	ed*e9d+�Z;ed,e	d+�Z<ed-ee	d)fd+�Z=ee;e:fZ>	eee	e	fZ?eed.Z@e
ee	gee	fZAe
e	ge	fZBeee	eeBfZCGd/d0�d0�ZDGd1d2�d2ejEe	�ZFGd3d4�d4eD�ZG	dXdYd;d<�ZHGd=d>�d>e�ZIeIjJZJGd?d@�d@e$e
e;�ZKGdAdB�dB�ZLGdCdD�dDeLeKee=�ZMGdEdF�dFeKe;�ZNGdGdH�dHeNe;�ZOGdIdJ�dJeNe;e jP�ZQGdKdL�dLeLeNe�ZRGdMdN�dNe
e=�ZSGdOdP�dPeMe=�ZTdZdRdS�ZUGdTdU�dUeTe=�ZVGdVdW�dWeTe=�ZWdS)[z%Define generic result set constructs.�)�annotations)�EnumN)�Any)�Callable)�cast)�Dict)�Generic)�Iterable)�Iterator)�List)�Mapping)�NoReturn)�Optional)�overload)�Sequence)�Set)�Tuple)�
TYPE_CHECKING)�TypeVar)�Union�)�Row)�
RowMapping�)�exc)�util)�_generative)�HasMemoized)�InPlaceGenerative)�!HasMemoized_ro_memoized_attribute)�NONE_SET)�HAS_CYEXTENSION)�Literal)�Self)�tuplegetter)�Column)�_ResultProcessorTypezColumn[Any].�_R)�bound�_T�_TPz_ResultProcessorType[Any]c@s,eZdZUdZdZdZded<dZded<dZded	<d
ed<ded
<ded<ded<e	dPdd��Z
dQdd�ZdRdd�Ze
	dSdTd$d%��Ze
	dSdUd(d%��Ze
	dSdVd*d%��Z	+dWdVd,d%�ZdXd/d0�ZdYd3d4�ZdZd8d9�Zd[d;d<�Zd\d=d>�Z	+dWd]d@dA�Zd^dCdD�Zd_dIdJ�Zd`dLdM�Ze	dadNdO��ZdS)b�ResultMetaDataz$Base for metadata about result rows.�N�Optional[_TupleGetterType]�_tuplefilter�Optional[Sequence[int]]�_translated_indexes�(Optional[Sequence[Callable[[Any], Any]]]�_unique_filters�_KeyMapType�_keymap�
Sequence[str]�_keys�Optional[_ProcessorsType]�_processors�Mapping[_KeyType, int]�
_key_to_index�return�	RMKeyViewcC�t|�S�N)r<��selfr,r,�C/usr/local/lib/python3.10/dist-packages/sqlalchemy/engine/result.py�keysj�zResultMetaData.keys�key�object�boolcC�t��r>��NotImplementedError�r@rDr,r,rA�_has_keyn�zResultMetaData._has_keycCrGr>rHr?r,r,rA�_for_freezeqrLzResultMetaData._for_freeze.r�err�Optional[Exception]�raiseerr�
Literal[True]r
cC�dSr>r,�r@rDrNrPr,r,rA�
_key_fallbackt�zResultMetaData._key_fallback�Literal[False]�NonecCrRr>r,rSr,r,rArTy��Optional[NoReturn]cCrRr>r,rSr,r,rArT�rUTcCs|sJ�t|�|�r>)�KeyErrorrSr,r,rArT�s
�rec�_KeyMapRecTypecCstd��)NzCambiguous column name logic is implemented for CursorResultMetaDatarH)r@r[r,r,rA� _raise_for_ambiguous_column_name�s�z/ResultMetaData._raise_for_ambiguous_column_name�
_KeyIndexType�
Optional[int]cCrGr>rH�r@rDrPr,r,rA�_index_for_key��zResultMetaData._index_for_keyrB�Sequence[_KeyIndexType]�
Sequence[int]cCrGr>rH�r@rBr,r,rA�_indexes_for_keys�rbz ResultMetaData._indexes_for_keys�Iterator[_KeyMapRecType]cCrGr>rHrer,r,rA�_metadata_for_keys�rbz!ResultMetaData._metadata_for_keyscCrGr>rHrer,r,rA�_reduce�rLzResultMetaData._reduce�#Optional[Callable[[Row[Any]], Any]]cCs"|�||�}|durt�|�SdSr>)ra�operator�
itemgetter)r@rDrP�indexr,r,rA�_getter�s
zResultMetaData._getter�_TupleGetterTypecCs|�|�}t|�Sr>)rfr$)r@rB�indexesr,r,rA�_row_as_tuple_getter�s
z#ResultMetaData._row_as_tuple_getter�keymap� Mapping[_KeyType, Sequence[Any]]rm�intcs�fdd�|��D�S)Ncs&i|]\}}|�dur||��qSr>r,)�.0rDr[�rmr,rA�
<dictcomp>�s
�z5ResultMetaData._make_key_to_index.<locals>.<dictcomp>)�items)r@rrrmr,rvrA�_make_key_to_index�s
�z!ResultMetaData._make_key_to_index�
attr_errorc
Csn||jvr|�|j|�dS|r/z	|�|d�WdSty.}zt|jd�|�d}~ww|�|d�dS�Nr)r4r]rTrZ�AttributeError�args)r@rDrz�ker,r,rA�_key_not_found�s
��zResultMetaData._key_not_foundcCs|jr	t�|j�rdS|jSr>)r8r �
issupersetr?r,r,rA�_effective_processors�sz$ResultMetaData._effective_processors�r;r<�rDrEr;rF�r;r+).)rDrrNrOrPrQr;r
)rDrrNrOrPrVr;rW)rDrrNrOrPrFr;rY�T)r[r\r;r
)rDr^rPrFr;r_)rBrcr;rd)rBrcr;rg)rBrcr;r+)rDrrPrFr;rj�rBrcr;ro)rrrsrmrtr;r9)rDrrzrFr;r
)r;r7)�__name__�
__module__�__qualname__�__doc__�	__slots__r.�__annotations__r0r2�propertyrBrKrMrrTr]rarfrhrirnrqryrr�r,r,r,rAr+]sJ


����




�



	r+c@sheZdZUdZded<ded<ddd�Zddd�Zd dd�Zd!dd�Zd"dd�Z	d#dd�Z
d#dd�ZdS)$r<��_parentr6r+r�r5r6�parentcCs||_dd�|jD�|_dS)NcSsg|]}|dur|�qSr>r,)ru�kr,r,rA�
<listcomp>�sz&RMKeyView.__init__.<locals>.<listcomp>r�)r@r�r,r,rA�__init__�szRMKeyView.__init__r;rtcC�
t|j�Sr>)�lenr6r?r,r,rA�__len__��
zRMKeyView.__len__�strcCs
d�|�S)Nz#{0.__class__.__name__}({0._keys!r}))�formatr?r,r,rA�__repr__�r�zRMKeyView.__repr__�
Iterator[str]cCr�r>)�iterr6r?r,r,rA�__iter__�r�zRMKeyView.__iter__�itemrrFcCst|t�rdS|j�|�S�NF)�
isinstancertr�rK)r@r�r,r,rA�__contains__�s
zRMKeyView.__contains__�othercCst|�t|�kSr>��list�r@r�r,r,rA�__eq__��zRMKeyView.__eq__cCst|�t|�kSr>r�r�r,r,rA�__ne__�r�zRMKeyView.__ne__N)r�r+)r;rt)r;r�)r;r�)r�rr;rF)r�rr;rF)r�r�r�r�r�r�r�r�r�r�r�r�r,r,r,rAr<�s






r<c@s�eZdZUdZdZded<					d2d3dd�Zd4dd�Zd5dd�Zd6dd�Z	d7d!d"�Z
d8d9d'd(�Zd:d+d,�Zd;d.d/�Z
d<d0d1�ZdS)=�SimpleResultMetaDataz*result metadata for in-memory collections.)r6r4r8r.r0r2r:r5r6NrB�extra�Optional[Sequence[Any]]r8r7r.r-r0r/r2r1cCszt|�|_||_||_||_|rdd�tt|j|��D�}n
dd�t|j�D�}dd�|D�|_||_|�	|jd�|_
dS)NcSs0g|]\}\}}|f|r|nd|||ff�qS�r,r,)rurm�name�extrasr,r,rAr�s
���z1SimpleResultMetaData.__init__.<locals>.<listcomp>cSs g|]\}}|f||dff�qSr�r,)rurmr�r,r,rAr�s��cSs i|]\}}|D]}||�qqSr,r,)rurBr[rDr,r,rArw!s z1SimpleResultMetaData.__init__.<locals>.<dictcomp>r)r�r6r.r0r2�	enumerate�zipr4r8ryr:)r@rBr�r8r.r0r2�
recs_namesr,r,rAr�s
	��zSimpleResultMetaData.__init__rDrEr;rFcCs
||jvSr>�r4rJr,r,rArK'r�zSimpleResultMetaData._has_keyr+cs:�j}|r
�jr
��|�}t�j�fdd��jD�|d�S)Nc�g|]	}�j|d�qS)rr��rurDr?r,rAr�3�z4SimpleResultMetaData._for_freeze.<locals>.<listcomp>)r�r2)r2r.r�r6)r@�unique_filtersr,r?rArM*s

�z SimpleResultMetaData._for_freeze�Dict[str, Any]cCs|j|jd�S)N�r6r0r�r?r,r,rA�__getstate__7s�z!SimpleResultMetaData.__getstate__�staterWcCs:|dr
|d}t|�}nd}}|j|d||d�dS)Nr0r6)r0r.)r$r�)r@r�r0r.r,r,rA�__setstate__=s

�z!SimpleResultMetaData.__setstate__TrrPrtc
Csdt|jjvr|j|}z
|j|}W|dSty1}z|�|||�}WYd}~|dSd}~wwr{�rt�	__class__�__mro__r6r4rZrT)r@rDrPr[r~r,r,rAraIs
���z#SimpleResultMetaData._index_for_key�
Sequence[Any]rdcs�fdd�|D�S)Ncr��rr�r�r?r,rAr�Tr�z:SimpleResultMetaData._indexes_for_keys.<locals>.<listcomp>r,rer,r?rArfS�z&SimpleResultMetaData._indexes_for_keysrgccsn�|D]1}t|jjvr|j|}z|j|}Wnty0}z
|�||d�}WYd}~nd}~ww|VqdS)NTr�)r@rBrDr[r~r,r,rArhVs�
���z'SimpleResultMetaData._metadata_for_keysc	
s�z�fdd�|D�}Wnty'}z��|jd|d�WYd}~nd}~wwt|�\}}}�jr;�fdd�|D�}t|�}t||||�j�jd�}|S)Ncs,g|]}�jt|jjvr�j|n|�qSr,)r4rtr�r�r6r�r?r,rAr�fs���z0SimpleResultMetaData._reduce.<locals>.<listcomp>rTcsg|]}�j|�qSr,)r0)ru�idxr?r,rAr�us)r�r.r0r8r2)	rZrTr}r�r0r$r�r8r2)	r@rB�metadata_for_keysr~rp�new_keysr��tup�new_metadatar,r?rArids*

� ���	zSimpleResultMetaData._reduce)NNNNN)rBr5r�r�r8r7r.r-r0r/r2r1r�r�)r;r�)r�r�r;rWr�)rDrrPrFr;rt)rBr�r;rd)rBr�r;rg)rBr�r;r+)r�r�r�r�r�r�r�rKrMr�r�rarfrhrir,r,r,rAr��s$

�
!





r��fieldsr5r��
Optional[Any]r;�#Callable[[Iterable[Any]], Row[Any]]cCst||�}t�t||j|j�Sr>)r��	functools�partialrr�r:)r�r�r�r,r,rA�result_tuple�s
�r�c@seZdZdZdS)�_NoRowrN)r�r�r��_NO_ROWr,r,r,rAr��sr�c@s>eZdZUdZdZded<dZded<ded	<dZd
ed<dZded<d
Z	ded<ded<dLdd�Z
	
dMdNdd�Z	dOdPdd�ZdQdd�Z
dMdRd"d#�ZedSd%d&��ZedTd(d)��ZdUd+d,�ZdUd-d.�ZedVd0d1��ZedWd3d4��ZedXd:d;��ZedYd=d;��ZdYd>d;�ZdZd@dA�Zd[dBdC�Zed\dGdH��Zejd]dJdK��ZdS)^�ResultInternalr,N�Optional[Result[Any]]�_real_resultTrF�_generate_rows�Optional[Callable[[Any], Any]]�_row_logging_fnz Optional[_UniqueFilterStateType]�_unique_filter_state�_post_creational_filterFr+�	_metadata�_source_supports_scalarsr;�#Iterator[_InterimRowType[Row[Any]]]cCrGr>rHr?r,r,rA�_fetchiter_impl�rLzResultInternal._fetchiter_impl�
hard_close�#Optional[_InterimRowType[Row[Any]]]cCrGr>rH�r@r�r,r,rA�_fetchone_impl�rbzResultInternal._fetchone_impl�sizer_�List[_InterimRowType[Row[Any]]]cCrGr>rH�r@r�r,r,rA�_fetchmany_impl�rbzResultInternal._fetchmany_implcCrGr>rHr?r,r,rA�_fetchall_impl�rLzResultInternal._fetchall_impl�hardrWcCrGr>rH�r@r�r,r,rA�_soft_close�rLzResultInternal._soft_close�Optional[Callable[..., _R]]cs�|jr|jntd|�}|jr|jsdSt�d�fdd
�}nt}|j}|j}|j}|j}|rI|jsI|r6||�}t	�
||||��|�d��fdd�}nt	�
||||�}|jra|j�|�d��fdd�}|S)N�Result[Any]�metadatar+�
processorsr7�key_to_indexr9�
scalar_objrr;�Row[Any]cs�||||f�Sr>r,)r�r�r�r�)�_procr,rA�process_row�s
�z/ResultInternal._row_getter.<locals>.process_row�row�_InterimRowType[Row[Any]]r'c���|��Sr>r,�r�)�_make_row_orig�fixed_tfr,rA�make_row��z,ResultInternal._row_getter.<locals>.make_rowcr�r>r,r�)�_log_row�	_make_rowr,rAr��r�)
r�r+r�r7r�r9r�rr;r�)r�r�r;r')r�rr�r�rr�r:r�r.r�r�r�)r@�real_resultr�r�r�r��tfr�r,)r�r�r�r�r�rA�_row_getter�s<��
��zResultInternal._row_getter�Callable[..., Iterator[_R]]c�H|j�|j�|jr|j\��d����fdd�}|Sd��fdd�}|S)	Nr@r�r;�Iterator[_R]c3sZ�|��D]%}�r
�|�n|}�r�|�n|}|�vrq��|��r'�|�}|VqdSr>)r��add)r@�raw_row�obj�hashed�r��post_creational_filter�strategy�uniquesr,rA�iterrows�s��
�z1ResultInternal._iterator_getter.<locals>.iterrowsc3s6�|��D]}�r
�|�n|}�r�|�}|VqdSr>)r�)r@rr��r�rr,rArs���)r@r�r;r��r�r�r��_unique_strategy)r@rr,rrA�_iterator_getter�s
�	zResultInternal._iterator_getter�List[_R]cs,|j��dus	J�|��}�fdd�|D�S)Nc�g|]}�|��qSr,r,�rur��r�r,rAr��z0ResultInternal._raw_all_rows.<locals>.<listcomp>)r�r�)r@�rowsr,rrA�
_raw_all_rowsszResultInternal._raw_all_rowscs�|j�|j�|��}�r�fdd�|D�}n|}|jr1|j\���fdd��fdd�|D�D�}n|}�r>�fdd�|D�}|S)Ncrr,r,rrr,rAr�'rz+ResultInternal._allrows.<locals>.<listcomp>c�&g|]\}}|�vr��|�s|�qSr,�r�ru�made_row�sig_row�rr,rAr�0s
�cs g|]}|�r�|�n|f�qSr,r,�rur�rr,rAr�2s���crr,r,r�rr,rAr�?s�)r�r�r�r�r)r@r�	made_rows�interim_rowsr,rrA�_allrowss&


��
�zResultInternal._allrows�1Callable[..., Union[Literal[_NoRow._NO_ROW], _R]]cr�)	Nr@r�r;�Union[_NoRow, _R]cs^|j}	|�}|dur
tS�r�|�n|}�r�|�n|}|�vr"q��|��r-�|�}|Sr>)r�r�r)r@�_onerowr�rrrr,rA�onerowOs�
z-ResultInternal._onerow_getter.<locals>.onerowcs4|��}|dur
tS�r�|�n|}�r�|�}|Sr>)r�r�)r@r��interim_rowr	r,rAr#ds�)r@r�r;r!r
)r@r#r,rrA�_onerow_getterDs
!�zResultInternal._onerow_getter�Callable[..., List[_R]]csT|j�|j�|jr |j\��ddd��d�����fdd�}|Sd��fdd�}|S)Nr�r�r�	List[Any]r�$Optional[Callable[[List[Any]], Any]]r�Set[Any]r;r
csN�r�fdd�|D�}�r�fdd�|D�}ndd�|D�}�fdd�|D�S)Ncrr,r,rrr,rAr��rzFResultInternal._manyrow_getter.<locals>.filterrows.<locals>.<listcomp>c3s�|]	}|�|�fVqdSr>r,rrr,rA�	<genexpr>�s�
�zEResultInternal._manyrow_getter.<locals>.filterrows.<locals>.<genexpr>css�|]}||fVqdSr>r,rr,r,rAr*�s�crr,rrrr,rAr��s
�r,)r�rrrrr,)r�rrrA�
filterrows{s
�
�z2ResultInternal._manyrow_getter.<locals>.filterrowsr@�ResultInternal[_R]�numr_cs�g}|j}|dur<|jr|jntd|�}|jr|j}}n!||�}t|�}�dus+J�|���|����|t|�}n|}|dusDJ�|r_||�}|sMn|���|����|t|�}|sF�rj�fdd�|D�}|S)Nr�crr,r,rrr,rAr��r�DResultInternal._manyrow_getter.<locals>.manyrows.<locals>.<listcomp>)r�r�r�
_yield_perr��extend)r@r-�collect�	_manyrowsr��num_requiredr�r+r�rrrr,rA�manyrows�s<�����
z0ResultInternal._manyrow_getter.<locals>.manyrowscs^|dur|jr
|jntd|�}|j}|�|�}�r"�fdd�|D�}�r-�fdd�|D�}|S)Nr�crr,r,rrr,rAr��rr.crr,r,rrr,rAr��r)r�rr/r�)r@r-r�rr	r,rAr5�s��
)
r�r�rr'rr(rr)r;r
)r@r,r-r_r;r
r
)r@r5r,r4rA�_manyrow_getterrs

C�zResultInternal._manyrow_getter�raise_for_second_row�raise_for_nonerQ�scalarr'cCrRr>r,�r@r7r8r9r,r,rA�
_only_one_row�rXzResultInternal._only_one_row�Optional[_R]cCrRr>r,r:r,r,rAr;�rXcCs�|j}|dd�}|dur|rt�d��dS|r |jr d|_d}n|j}z
|r*||�n|}Wn
|jdd��|r�|jr�|j\}}|rH||�n|}		|dd�}
|
durWt	}
n,z!|r^||
�n|
}
|rq|
t	ushJ�|	||
�krpWqJn||
krwWqJWn
|jdd��n|dd�}
|
dur�t	}
|
t	ur�|jdd�t�
|r�d��d��nt	}
|jdd�|s�|j}|r�||�}|r�|r�|dS|S)	NT�r�z&No row was found when one was requiredF�r�z6Multiple rows were found when exactly one was requiredz6Multiple rows were found when one or none was requiredr)r�r�
NoResultFoundr�r�r�r�r�rr��MultipleResultsFoundr�)r@r7r8r9r#r�r�rr�existing_row_hash�next_rowrr,r,rAr;�sz
�


��
����	r�cCs
|�|�Sr>)rr?r,r,rA�
_iter_impl;r�zResultInternal._iter_implcCs|�|�}|turt��|Sr>)r%r��
StopIteration�r@r�r,r,rA�
_next_impl>s
zResultInternal._next_implrprcr#cCsD|jr|jntd|�}|jrt|�dkr|j�|�|_|js J�|S)Nr�r)r�rr�r�r�rir�)r@rpr�r,r,rA�_column_slicesEs��
zResultInternal._column_slices�_UniqueFilterStateTypecCs�|jdusJ�|j\}}|jdur|jntd|�}|sC|jjrC|jr/|js/|jjd}||fS|jj}|jjr=|j�|�}t�	d|�}||fS)Nr�r�_filter_on_values)
r�r�rr�r2r�r�r.rk�methodcaller)r@rrr��filtersr,r,rArTs$

�����zResultInternal._unique_strategy�r;r��F�r�rFr;r�r>�r�r_r;r��r;r��r�rFr;rW)r;r�)r;r�)r;r
)r;r )r;r&)r7rFr8rQr9rFr;r')r7rFr8rFr9rFr;r<�r;r��r;r')rprcr;r#)r;rH)r�r�r�r�r�r�r�r�r��
_is_cursorr�r�r�r�r�rr�rrrr%r6rr;rCrFrrGr�memoized_attributerr,r,r,rAr��sL

��
;
"
%-b

V
r�c@s$eZdZUdZded<d	dd�ZdS)
�	_WithKeysr,r+r�r;r<cC�|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�rBr?r,r,rArBt�z_WithKeys.keysNr�)r�r�r�r�r�rBr,r,r,rArVns
rVc@s"eZdZUdZdZdZded<dZded<dZd	ed
<e	�
�Zded<d�dd�Zd�dd�Z
d�dd�Zd�dd�Zed�dd��Zed�d d!��Zed�d$d%��Zed�d�d(d)��Zd�d,d-�Zed�d1d2��Zed�d5d2��Zed�d�d8d2��Zd�d�d9d2�Z	:d�d�d>d?�Zd�dCdD�Zd�dFdG�Zed�dIdJ��Zd�dKdL�Zd�dNdO�Zd�dQdR�Zd�dTdU�Z 	d�d�dXdY�Z!d�d[d\�Z"d�d^d_�Z#d�d�d`da�Z$d�dbdc�Z%d�ddde�Z&d�dfdg�Z'ed�didj��Z(ed�dkdj��Z(d�dldj�Z(ed�dndo��Z)ed�dqdo��Z)d�drdo�Z)d�dsdt�Z*ed�dudv��Z+ed�dwdv��Z+d�dxdv�Z+d�dzd{�Z,d�dd��Z-dS)��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`

    )r��__dict__Nz(Optional[Callable[[Row[Any]], Row[Any]]]r�FrFr�r_r/zutil.immutabledict[Any, Any]�_attributes�cursor_metadatar+cCs
||_dSr>)r�)r@r\r,r,rAr��r�zResult.__init__r;r#cC�|Sr>r,r?r,r,rA�	__enter__��zResult.__enter__�type_r�value�	tracebackrWcCs|��dSr>)�close�r@r`rarbr,r,rA�__exit__�r�zResult.__exit__cCs|jdd�dS)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.

        Tr>N)r�r?r,r,rArc�szResult.closecCrGr>rHr?r,r,rA�_soft_closed�szResult._soft_closedcCrG)zkreturn ``True`` if this :class:`_engine.Result` reports .closed

        .. versionadded:: 1.4.43

        rHr?r,r,rA�closed��z
Result.closedr-rtcCs
||_|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
        conjunction with the
        :paramref:`_engine.Connection.execution_options.stream_results`
        execution option, which will allow the database dialect in use to make
        use of a server side cursor, if the DBAPI supports a specific "server
        side cursor" mode separate from its default mode of operation.

        .. tip::

            Consider using the
            :paramref:`_engine.Connection.execution_options.yield_per`
            execution option, which will simultaneously set
            :paramref:`_engine.Connection.execution_options.stream_results`
            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`

        )r/�r@r-r,r,rA�	yield_per�s1zResult.yield_perr�Optional[_UniqueFilterType]cC�t�|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.

        ��setr��r@rr,r,rA�uniques&z
Result.unique�col_expressionsr^cG�
|�|�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
           only a single column.

        E.g.::

            statement = select(table.c.x, table.c.y, table.c.z)
            result = connection.execute(statement)

            for z, y in result.columns("z", "y"):
                ...

        Example of using the column objects from the statement itself::

            for z, y in result.columns(
                statement.selected_columns.c.z, statement.selected_columns.c.y
            ):
                ...

        .. versionadded:: 1.4

        :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.

        �rG�r@rqr,r,rA�columns5s
-zResult.columnsr@�Result[Tuple[_T]]�ScalarResult[_T]cCrRr>r,r?r,r,rA�scalarsdr_zResult.scalarsrm�
Literal[0]cCrRr>r,�r@rmr,r,rArxgrUr�ScalarResult[Any]cCrRr>r,rzr,r,rArxlr_cCs
t||�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.

        )�ScalarResultrzr,r,rArxos
TrDrPrjcCs|jrtd��|j�||�S)zareturn a callable that will retrieve the given key from a
        :class:`_engine.Row`.

        �.can't use this function in 'only scalars' mode)r�rIr�rnr`r,r,rArn�s
�zResult._getterrBrcrocCs|jrtd��|j�|�S)zbreturn a callable that will retrieve the given keys from a
        :class:`_engine.Row`.

        r})r�rIr�rqrer,r,rA�
_tuple_getter�s
�zResult._tuple_getter�
MappingResultcCr=)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.

        )rr?r,r,rA�mappings�szResult.mappings�TupleResult[_TP]cCr])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?r,r,rA�t��
zResult.tcCr])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?r,r,rA�tuples�sz
Result.tuples�Iterator[_RowData]cCrG)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.

        rHr?r,r,rA�_raw_row_iterator�rhzResult._raw_row_iterator�Iterator[Row[_TP]]cC�|��Sr>�rCr?r,r,rAr���zResult.__iter__�Row[_TP]cCr�r>�rFr?r,r,rA�__next__�r�zResult.__next__r��Iterator[Sequence[Row[_TP]]]cc�&�|j}	|||�}|r|VndSq)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
        ahead of time unless the
        :paramref:`.Connection.execution_options.stream_results` execution
        option is used indicating that the driver should not pre-buffer
        results, if possible.   Not all drivers support this option and
        the option is silently ignored for those who do not.

        When using the ORM, the :meth:`_engine.Result.partitions` method
        is typically more effective from a memory perspective when it is
        combined with use of the
        :ref:`yield_per execution option <orm_queryguide_yield_per>`,
        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`

        TN�r6�r@r��getter�	partitionr,r,rA�
partitions�s�1
�zResult.partitions�Sequence[Row[_TP]]cCr�)z4A synonym for the :meth:`_engine.Result.all` method.�rr?r,r,rA�fetchall �zResult.fetchall�Optional[Row[_TP]]cC�|�|�}|turdS|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�rEr,r,rA�fetchone%s
zResult.fetchonecC�|�||�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�r,r,rA�	fetchmany;szResult.fetchmanycCr�)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?r,r,rA�allPrXz
Result.allcC�|jdddd�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
           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:`_engine.Result.scalar`

            :meth:`_engine.Result.one`

        F�r7r8r9�r;r?r,r,rA�firstcs#�zResult.firstcC�|jdddd�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:`_engine.Result.first`

            :meth:`_engine.Result.one`

        TFr�r�r?r,r,rA�one_or_none�s�zResult.one_or_noner)cCrRr>r,r?r,r,rA�
scalar_one�r_zResult.scalar_onecCrRr>r,r?r,r,rAr��r_cCr�)a*Return 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`

        Tr�r�r?r,r,rAr���
��Optional[_T]cCrRr>r,r?r,r,rA�scalar_one_or_none�r_zResult.scalar_one_or_noner�cCrRr>r,r?r,r,rAr��r_cCs|jdddd�S)a0Return exactly one scalar result or ``None``.

        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`

        TFr�r�r?r,r,rAr��r�cC�|jdddd�S)aeReturn 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:`_engine.Result.scalar_one` method, or combine
           :meth:`_engine.Result.scalars` and
           :meth:`_engine.Result.one`.

        .. versionadded:: 1.4

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

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

        .. seealso::

            :meth:`_engine.Result.first`

            :meth:`_engine.Result.one_or_none`

            :meth:`_engine.Result.scalar_one`

        TFr�r�r?r,r,rA�one�s�z
Result.onecCrRr>r,r?r,r,rAr9�r_z
Result.scalarcCrRr>r,r?r,r,rAr9�r_cCr�)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.

        FTr�r�r?r,r,rAr9�s��FrozenResult[_TP]cCr=)aReturn a callable object that will produce copies of this
        :class:`_engine.Result` 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.

        )�FrozenResultr?r,r,rA�freeze
sz
Result.freeze�othersr��MergedResult[_TP]cGst|j|f|�S)a�Merge this :class:`_engine.Result` with other compatible result
        objects.

        The object returned is an instance of :class:`_engine.MergedResult`,
        which will be composed of iterators from the given result
        objects.

        The new result will use the metadata from this result object.
        The subsequent result objects must be against an identical
        set of result / cursor metadata, otherwise the behavior is
        undefined.

        )�MergedResultr�)r@r�r,r,rA�merge!szResult.merge)r\r+�r;r#�r`rrarrbrr;rW�r;rW�r;rF�r-rtr;r#r>�rrkr;r#�rqr^r;r#)r@rvr;rw)r@rvrmryr;rwr�)rmr^r;r{r�)rDr^rPrFr;rjr�)r;r)r;r��r;r�)r;r�)r;r�)r�r_r;r�)r;r�)r;r�)r�r_r;r�)r@rvr;r)�r;r)r@rvr;r��r;r�)r;r�)r�r�r;r�).r�r�r�r�r�r�r�r�r/r�
immutabledictr[r�r^rercr�rfrgrrjrprurrxrnr~r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r9r�r�r,r,r,rArY�s~




3
(/�




	
�
:



'


!

rYc@s�eZdZUdZdZded<ded<d3d	d
�Zd4dd�Zed5dd��Z	d6d7dd�Z
ed8dd��Zed8dd��Z
d9dd �Zed:d"d#��Zd;d%d&�Z	d6d<d)d*�Zd=d,d-�Z	.d>d?d1d2�Zd.S)@�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�rZr�r�r�r�r;r#cCr]r>r,r?r,r,rAr^Hr_zFilterResult.__enter__r`rrarbrWcCs|j�|||�dSr>)r�rerdr,r,rAreKszFilterResult.__exit__r-rtcCs|j�|�|_|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
        documentation for usage notes.

        .. versionadded:: 1.4.40 - added :meth:`_engine.FilterResult.yield_per`
           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�rjrir,r,rArjNszFilterResult.yield_perFr�rFcCs|jj|d�dS�Nr>)r�r�r�r,r,rAr�dr�zFilterResult._soft_closecCrWr>)r�rfr?r,r,rArfgrCzFilterResult._soft_closedcCrW)z|Return ``True`` if the underlying :class:`_engine.Result` reports
        closed

        .. versionadded:: 1.4.43

        )r�rgr?r,r,rArgk�zFilterResult.closedcCs|j��dS)zUClose this :class:`_engine.FilterResult`.

        .. versionadded:: 1.4.43

        N)r�rcr?r,r,rArcuszFilterResult.close�Dict[Any, Any]cCrWr>)r�r[r?r,r,rAr[}rCzFilterResult._attributesr�cC�
|j��Sr>)r�r�r?r,r,rAr��r�zFilterResult._fetchiter_implr�r�cC�|jj|d�S)Nr=)r�r�r�r,r,rAr���zFilterResult._fetchone_implr�cCr�r>)r�r�r?r,r,rAr��r�zFilterResult._fetchall_implNr�r_cCr��N�r�)r�r�r�r,r,rAr��r�zFilterResult._fetchmany_implr�r�r�rMrQr�r�)r;r�rLrNrPr>rO)r�r�r�r�r�r�r^rerrjr�r�rfrgrcr[r�r�r�r�r,r,r,rAr�2s.
	


	
�
�r�c@s�eZdZUdZdZdZded<d,d
d�Zd-d.dd�Zd-d/dd�Z	d0dd�Z
d-d1dd�Zd0dd�Zd2d d!�Z
d3d#d$�Zd4d&d'�Zd4d(d)�Zd3d*d+�ZdS)5r|a�A wrapper for a :class:`_engine.Result` that returns scalar values
    rather than :class:`_row.Row` values.

    The :class:`_engine.ScalarResult` object is acquired by calling the
    :meth:`_engine.Result.scalars` method.

    A special limitation of :class:`_engine.ScalarResult` is that it has
    no ``fetchone()`` method; since the semantics of ``fetchone()`` are that
    the ``None`` value indicates no more results, this is not compatible
    with :class:`_engine.ScalarResult` since there is no way to distinguish
    between ``None`` as a row value versus ``None`` as an indicator.  Use
    ``next(result)`` to receive values individually.

    r,Fr�r�r�r�rmr^cCsD||_|jr|j|_d|_n|j�|g�|_t�d�|_|j|_dSr{)r�r�r�r�rirkrlr�)r@r�rmr,r,rAr��szScalarResult.__init__Nrrkr;r#cCrl)z�Apply unique filtering to the objects returned by this
        :class:`_engine.ScalarResult`.

        See :meth:`_engine.Result.unique` for usage details.

        rmror,r,rArp��zScalarResult.uniquer�r_�Iterator[Sequence[_R]]ccr�)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.

        TNr�r�r,r,rAr��s�	
�zScalarResult.partitions�Sequence[_R]cCr�)�:A synonym for the :meth:`_engine.ScalarResult.all` method.r�r?r,r,rAr��r�zScalarResult.fetchallcCr�)z�Fetch many objects.

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

        r�r�r,r,rAr��szScalarResult.fetchmanycCr�)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?r,r,rAr��r�zScalarResult.allr�cCr�r>r�r?r,r,rAr��r�zScalarResult.__iter__r'cCr�r>r�r?r,r,rAr��r�zScalarResult.__next__r<cCr�)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,
        are returned.


        Fr�r�r?r,r,rAr���	�zScalarResult.firstcCr�)z�Return at most one object or raise an exception.

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

        TFr�r�r?r,r,rAr����zScalarResult.one_or_nonecCr�)z�Return exactly one object or raise an exception.

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

        TFr�r�r?r,r,rAr�r�zScalarResult.one)r�r�rmr^r>r��r�r_r;r��r;r��r�r_r;r�rRrS�r;r<)r�r�r�r�r�r�r�r�rpr�r�r�r�r�r�r�r�r�r,r,r,rAr|�s 











r|c@s�eZdZdZdZerz	d2d3dd	�Zd4dd�Zd5dd�Zd2d6dd�Z	d5dd�Z
d7dd�Zd8dd�Zd4dd�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)=�TupleResultaA :class:`_engine.Result` 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:`_engine.Result` is
    still used at runtime.

    r,Nr�r_r;r�cC�dS)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�r,r,rAr�#r�zTupleResult.partitionsr<cCr�)z�Fetch one tuple.

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

            Nr,r?r,r,rAr�/�zTupleResult.fetchoner�cCr�)r�Nr,r?r,r,rAr�9szTupleResult.fetchallcCr�)z�Fetch many objects.

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

            Nr,r�r,r,rAr�=r�zTupleResult.fetchmanycCr�)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?r,r,rAr�Gr�zTupleResult.allr�cCrRr>r,r?r,r,rAr�Q�zTupleResult.__iter__r'cCrRr>r,r?r,r,rAr�Sr�zTupleResult.__next__cCr�)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?r,r,rAr�Us	zTupleResult.firstcCr�)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?r,r,rAr�`r�zTupleResult.one_or_nonecCr�)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?r,r,rAr�jr�zTupleResult.oner@�TupleResult[Tuple[_T]]r)cCrRr>r,r?r,r,rAr�tr_zTupleResult.scalar_onercCrRr>r,r?r,r,rAr�wr_cCr�)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?r,r,rAr�z�
r�cCrRr>r,r?r,r,rAr��rUzTupleResult.scalar_one_or_noner�cCrRr>r,r?r,r,rAr��r_cCr�)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?r,r,rAr��r�cCrRr>r,r?r,r,rAr9�r_zTupleResult.scalarcCrRr>r,r?r,r,rAr9�r_cCr�)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,rAr9�sr>r�r�r�r�rRrS)r@r�r;r)r�)r@r�r;r�r�)r�r�r�r�r�rr�r�r�r�r�r�r�r�r�r�rr�r�r9r,r,r,rAr�s@	�














��r�c@s�eZdZdZdZdZe�d�Zd/dd�Z	d0d1dd�Z
d2dd�Z		d0d3dd�Zd4dd�Z
d5dd�Zd0d6dd �Zd4d!d"�Zd7d$d%�Zd8d'd(�Zd5d)d*�Zd5d+d,�Zd8d-d.�Zd	S)9rz�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�_mapping�resultr�cCs4||_|j|_|j|_|jr|j�dg�|_dSdSr{)r�r�r�r�ri�r@r�r,r,rAr��s�zMappingResult.__init__Nrrkr;r#cCrl)z�Apply unique filtering to the objects returned by this
        :class:`_engine.MappingResult`.

        See :meth:`_engine.Result.unique` for usage details.

        rmror,r,rArp�r�zMappingResult.uniquerqr^cGrr)z:Establish the columns that should be returned in each row.rsrtr,r,rAru�s
zMappingResult.columnsr�r_�Iterator[Sequence[RowMapping]]ccr�)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.

        TNr�r�r,r,rAr��s�
�zMappingResult.partitions�Sequence[RowMapping]cCr�)z;A synonym for the :meth:`_engine.MappingResult.all` method.r�r?r,r,rAr��r�zMappingResult.fetchall�Optional[RowMapping]cCr�)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�rEr,r,rAr��s
	zMappingResult.fetchonecCr�)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�r,r,rAr�s	zMappingResult.fetchmanycCr�)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?r,r,rAr�s	zMappingResult.all�Iterator[RowMapping]cCr�r>r�r?r,r,rAr�r�zMappingResult.__iter__rcCr�r>r�r?r,r,rAr�r�zMappingResult.__next__cCr�)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�r�r?r,r,rAr� r�zMappingResult.firstcCr�)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�r�r?r,r,rAr�-r�zMappingResult.one_or_nonecCr�)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`
        objects, are returned.

        TFr�r�r?r,r,rAr�9r�zMappingResult.one)r�r�r>r�r�)r�r_r;r�)r;r�)r;r�)r�r_r;r�)r;r�)r;r)r�r�r�r�r�r�rk�
attrgetterr�r�rprur�r�r�r�r�r�r�r�r�r�r,r,r,rAr�s&



�







rc@sBeZdZUdZded<ddd�Zdd
d�Zddd�Zddd�ZdS)r�a�Represents a :class:`_engine.Result` object in a "frozen" state suitable
    for caching.

    The :class:`_engine.FrozenResult` object is returned from the
    :meth:`_engine.Result.freeze` method of any :class:`_engine.Result`
    object.

    A new iterable :class:`_engine.Result` object is generated from a fixed
    set of data each time the :class:`_engine.FrozenResult` is invoked as
    a callable::


        result = connection.execute(query)

        frozen = result.freeze()

        unfrozen_result_one = frozen()

        for row in unfrozen_result_one:
            print(row)

        unfrozen_result_two = frozen()
        rows = unfrozen_result_two.all()

        # ... etc

    .. versionadded:: 1.4

    .. seealso::

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

        :func:`_orm.loading.merge_frozen_result` - ORM function to merge
        a frozen result back into a :class:`_orm.Session`.

    r��datar��Result[_TP]cCsB|j��|_|j|_|j|_|jrt|���|_dS|��|_dSr>)	r�rMr�r�r[r�r�r�r�r�r,r,rAr�oszFrozenResult.__init__r;�Sequence[Sequence[Any]]cCs&|jrdd�|jD�Sdd�|jD�S)NcSsg|]}|g�qSr,r,)ru�elemr,r,rAr�{�z-FrozenResult.rewrite_rows.<locals>.<listcomp>cSsg|]}t|��qSr,r�rr,r,rAr�}r)r�r�r?r,r,rA�rewrite_rowsyszFrozenResult.rewrite_rows�
tuple_datar�r�cCsFt�t�}|j|_|j|_|j|_|jrdd�|D�|_|S||_|S)NcSsg|]}|d�qSr�r,)ru�dr,r,rAr��rz.FrozenResult.with_new_rows.<locals>.<listcomp>)r��__new__r�r[r�r�)r@r��frr,r,rA�
with_new_rowss
�zFrozenResult.with_new_rowscCs&t|jt|j��}|j|_|j|_|Sr>)�IteratorResultr�r�r�r[r�r�r,r,rA�__call__�s�zFrozenResult.__call__N)r�r�)r;r�)r�r�r;r�)r;r�)	r�r�r�r�r�r�r�r�r�r,r,r,rAr�Fs
&



r�c@s�eZdZdZdZdZ		d*d+dd
�Zed,dd��Zd-d.dd�Z	d/dd�Z
d0dd�Zd1dd�Z	d-d2d!d"�Z
d3d$d%�Z	d4d5d(d)�ZdS)6r�z�A :class:`_engine.Result` that gets data from a Python iterator of
    :class:`_engine.Row` objects or similar row-like data.

    .. versionadded:: 1.4

    FNr\r+�iterator�(Iterator[_InterimSupportsScalarsRowType]�rawr�r�rFcCs||_||_||_||_dSr>)r�r�r�r�)r@r\r�r�r�r,r,rAr��s
zIteratorResult.__init__r;cC�|jS)z{Return ``True`` if this :class:`_engine.IteratorResult` has
        been closed

        .. versionadded:: 1.4.43

        )�_hard_closedr?r,r,rArg�szIteratorResult.closedr��kwrrWcKsF|rd|_|jdur|jjdd|i|��tg�|_|��d|_dS)NTr�r,)r�r�r�r�r��_reset_memoizationsrf�r@r�r�r,r,rAr��s


zIteratorResult._soft_closer
cCs
t�d��)NzThis result object is closed.)r�ResourceClosedErrorr?r,r,rA�_raise_hard_closed�r�z!IteratorResult._raise_hard_closedr�cCr�r>)r�r?r,r,rAr��rLz IteratorResult._raw_row_iteratorcCs|jr|��|jSr>)r�r�r�r?r,r,rAr��szIteratorResult._fetchiter_implr�r�cCs6|jr|��t|jt�}|tur|j|d�dS|Sr�)r�r��nextr�r�r�)r@r�r�r,r,rAr��szIteratorResult._fetchone_implr�cCs.|jr|��z
t|j�W|��S|��wr>)r�r�r�r�r�r?r,r,rAr��s

zIteratorResult._fetchall_implr�r_cCs"|jr|��tt�|jd|��Sr{)r�r�r��	itertools�islicer�r�r,r,rAr��szIteratorResult._fetchmany_implr�)r\r+r�r�r�r�r�rFr�rM�r�rFr�rr;rW)r;r
r�)r;r�rNrPr>rO)r�r�r�r�r�rfr�r�rgr�r�r�r�r�r�r�r,r,r,rAr��s$�	
	

�

	�r��IteratorResult[Any]cCsttg�tg��Sr>)r�r�r�r,r,r,rA�null_result�r�r�csVeZdZdZ			d d!d
d�Zed"dd��Zd#d$�fdd�
Z	d%d&�fdd�
Z�Z	S)'�ChunkedIteratorResulta�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.

    .. versionadded:: 1.4

    FNr\r+�chunks�BCallable[[Optional[int]], Iterator[Sequence[_InterimRowType[_R]]]]�source_supports_scalarsrFr�r��dynamic_yield_percCs6||_||_||_||_tj�|�d��|_||_dSr>)	r�r�r�r�r��chain�
from_iterabler�r)r@r\r�r�r�rr,r,rAr��s

zChunkedIteratorResult.__init__r-rtr;r#cCs||_tj�|�|��|_|Sr>)r/r�rrr�r�rir,r,rArj	szChunkedIteratorResult.yield_perr�r�rrWcs$t�jdd|i|��dd�|_dS)Nr�cSsgSr>r,r�r,r,rA�<lambda>	r�z3ChunkedIteratorResult._soft_close.<locals>.<lambda>r,)�superr�r�r��r�r,rAr�	sz!ChunkedIteratorResult._soft_closer�r_r�cs(|jr
tj�|�|��|_t�j|d�Sr�)rr�rrr�r�rr�r�rr,rAr�	sz%ChunkedIteratorResult._fetchmany_impl)FNF)
r\r+r�r�r�rFr�r�rrFr�rMr�r>rO)
r�r�r�r�r�rrjr�r��
__classcell__r,r,rrAr��s��r�cs<eZdZUdZdZded<d�fd	d
�Zdddd�Z�ZS)r�z�A :class:`_engine.Result` that is merged from any number of
    :class:`_engine.Result` objects.

    Returned by the :meth:`_engine.Result.merge` method.

    .. versionadded:: 1.4

    Fr_�rowcountr\r+�results�Sequence[Result[_TP]]csf||_t��|tj�dd�|D���|dj|_|dj|_|dj|_|j	j
dd�|D��|_	dS)Ncss�|]}|��VqdSr>)r��ru�rr,r,rAr*9	s�
�z(MergedResult.__init__.<locals>.<genexpr>rcSsg|]}|j�qSr,)r[r
r,r,rAr�E	r�z)MergedResult.__init__.<locals>.<listcomp>)�_resultsrr�r�rrr�r/r�r[�
merge_with)r@r\rrr,rAr�3	s��
�zMergedResult.__init__r�rFr�rr;rWcKs2|jD]}|jdd|i|��q|rd|_dSdS)Nr�Tr,)rr�rg)r@r�r�rr,r,rAr�H	s


�zMergedResult._soft_close)r\r+rr	rMr�)	r�r�r�r�rgr�r�r�rr,r,rrAr�&	s
	r�r>)r�r5r�r�r;r�)r;r�)Xr��
__future__r�enumrr�r�rk�typingrrrrrr	r
rrr
rrrrrrrrr�rr�rr�sql.baserrrrr �util._has_cyr!�util.typingr"r#�_py_rowr$�"sqlalchemy.cyextension.resultproxy�
sql.schemar%�sql.type_apir&r��_KeyTypertr^r\r3�_RowData�_RawRowTyper'r)r*�_InterimRowType�_InterimSupportsScalarsRowType�_ProcessorsTypero�_UniqueFilterTyperHr+�KeysViewr<r�r�r�r�r�rVrYr�r|�
TypingOnlyr�rr�r�r�r�r�r,r,r,rA�<module>s�
x"�Y/`$P
S9