U
|
¸ý°dþ8 ã @ s d Z ddlmZ ddlmZ ddlZddlZddlZddlZddlm Z ddlm
|
Z
|
ddlm Z ddlm Z dd lm Z dd
|
lmZ dd lmZ dd lmZ dd lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ddlm Z ddl m Z dd l m Z dd l!m"Z" dd l!m#Z# dd l!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- n dd%l.m-Z- ejrìdd&l/m0Z0 dd'l1m2Z2 ee3d(f Z4ee3d(e5f Z6e Z7ee4e7f Z8ee e e f Z9ee d)f Z:ed*e9d+Z;ed,e d+Z<ed-ee d)f d+Z=ee;e:f Z>ee e f Z?eed. Z@e
|
ee gee f ZAe
|
e ge f ZBeee eeB f ZCG d/d0 d0ZDG d1d2 d2ejEe ZFG d3d4 d4eDZGdWd5d6d7d8d9d:ZHG d;d< d<eZIeIjJZJG d=d> d>e$e e; ZKG d?d@ d@ZLG dAdB dBeLeKe e= ZMG dCdD dDeKe; ZNG dEdF dFeNe; ZOG dGdH dHeNe; e jPZQG dIdJ dJeLeNe ZRG dKdL dLe e= ZSG dMdN dNeMe= ZTdOdPdQdRZUG dSdT dTeTe= ZVG dUdV dVeTe= ZWdS )Xz%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)Ú_ResultProcessorTypez Column[Any].Ú_R)ÚboundÚ_TÚ_TPz_ResultProcessorType[Any]c @ s e Zd ZU dZdZdZded< dZded< dZded < d
|
ed < d ed < ded< ded< e ddddZ
|
dddddZ d ddd Z e dOd d d d!d"d#d$Ze dPd d d%d&d"d'd$Ze dQd d dd(d"d)d$ZdRd d dd(d"d+d$Zd,d!d-d.d/Zd0dd1d2d3d4Zd5d6d7d8d9Zd5d:d7d;d<Zd5d d7d=d>ZdSd dd?d2d@dAZd5dBd7dCdDZdEdFddGdHdIZd dd!dJdKdLZe dddMdNZdS )TÚ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Ú RMKeyView©Úreturnc C s t | S ©N)r; ©Úselfr, r, úOd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/engine/result.pyÚkeysj s zResultMetaData.keysÚobjectÚbool©Úkeyr= c C s
|
t d S r> ©ÚNotImplementedError©r@ rF r, r, rA Ú_has_keyn s zResultMetaData._has_keyc C s
|
t d S r> rG r? r, r, rA Ú _for_freezeq s zResultMetaData._for_freeze.r zOptional[Exception]ú Literal[True]r )rF ÚerrÚraiseerrr= c C s d S r> r, ©r@ rF rM rN r, r, rA Ú _key_fallbackt s z ResultMetaData._key_fallbackzLiteral[False]ÚNonec C s d S r> r, rO r, r, rA rP z s zOptional[NoReturn]c C s d S r> r, rO r, r, rA rP s Tc C s |st t||d S r> )ÚAssertionErrorÚKeyErrorrO r, r, rA rP s Ú_KeyMapRecType)Úrecr= c C s t dd S )NzCambiguous column name logic is implemented for CursorResultMetaDatarG )r@ rU r, r, rA Ú _raise_for_ambiguous_column_name s ÿz/ResultMetaData._raise_for_ambiguous_column_nameÚ _KeyIndexTypeú Optional[int]©rF rN r= c C s
|
t d S r> rG ©r@ rF rN r, r, rA Ú_index_for_key s z ResultMetaData._index_for_keyúSequence[_KeyIndexType]ú Sequence[int]©rB r= c C s
|
t d S r> rG ©r@ rB r, r, rA Ú_indexes_for_keys s z ResultMetaData._indexes_for_keysúIterator[_KeyMapRecType]c C s
|
t d S r> rG r_ r, r, rA Ú_metadata_for_keys¡ s z!ResultMetaData._metadata_for_keysc C s
|
t d S r> rG r_ r, r, rA Ú_reduce¦ s zResultMetaData._reduceú#Optional[Callable[[Row[Any]], Any]]c C s& | ||¡}|d k r t |¡S d S d S r> )r[ ÚoperatorÚ
|
itemgetter)r@ rF rN Úindexr, r, rA Ú_getter© s
|
zResultMetaData._getterÚ_TupleGetterTypec C s | |¡}t| S r> )r` r$ )r@ rB Úindexesr, r, rA Ú_row_as_tuple_getter´ s
|
z#ResultMetaData._row_as_tuple_getterz Mapping[_KeyType, Sequence[Any]]Úint)Úkeymaprg r= c s fdd| ¡ D S )Nc s& i | ] \}}| d k r|| qS r> r, )Ú.0rF rU ©rg r, rA Ú
|
<dictcomp>½ s þ z5ResultMetaData._make_key_to_index.<locals>.<dictcomp>)Úitems)r@ rm rg r, ro rA Ú_make_key_to_indexº s
|
þz!ResultMetaData._make_key_to_index)rF Ú
|
attr_errorr= c
|
C sv || j kr | | j | ¡ nV|rfz| |d ¡ W qr tk
|
rb } zt|jd |W 5 d }~X Y qrX n | |d ¡ d S ©Nr )r4 rV rP rS ÚAttributeErrorÚargs)r@ rF rs Úker, r, rA Ú_key_not_foundà s
|
$z ResultMetaData._key_not_foundc C s | j rt | j ¡rd S | j S d S r> )r8 r Ú
|
issupersetr? r, r, rA Ú_effective_processorsÑ s z$ResultMetaData._effective_processors).).).)T)T)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__Ú __slots__r. Ú__annotations__r0 r2 ÚpropertyrB rJ rK r rP rV r[ r` rb rc rh rk rr rx rz r, r, r, rA r+ ] sH
|
ÿ ü ÿ ÿ ÿ r+ c @ s e Zd ZU dZded< ded< ddddZd d
|
d d Zd d
|
ddZdd
|
ddZdddddZ dddddZ
|
ddddd Z d S ) r; ©Ú_parentr6 r+ r r5 r6 )Úparentc C s || _ dd |jD | _d S )Nc S s g | ]}|d k r|qS r> r, )rn Úkr, r, rA Ú
|
<listcomp>á s z&RMKeyView.__init__.<locals>.<listcomp>r )r@ r r, r, rA Ú__init__ß s zRMKeyView.__init__rl r< c C s
|
t | jS r> )Úlenr6 r? r, r, rA Ú__len__ã s zRMKeyView.__len__Ústrc C s
|
d | ¡S )Nz#{0.__class__.__name__}({0._keys!r}))Úformatr? r, r, rA Ú__repr__æ s zRMKeyView.__repr__z Iterator[str]c C s
|
t | jS r> )Úiterr6 r? r, r, rA Ú__iter__é s zRMKeyView.__iter__r rD )Úitemr= c C s t |trdS | j |¡S )NF)Ú
|
isinstancerl r rJ )r@ r r, r, rA Ú __contains__ì s
|
zRMKeyView.__contains__)Úotherr= c C s t |t | kS r> ©Úlist©r@ r r, r, rA Ú__eq__ô s zRMKeyView.__eq__c C s t |t | kS r> r r r, r, rA Ú__ne__÷ s zRMKeyView.__ne__N) r{ r| r} r r r r r r r r r r, r, r, rA r; Ù s
|
r; c @ sÊ e Zd ZU dZdZded< d2ddddd d
|
d d d ZdddddZddddZddddZ dddd d Z
|
d d dd d!d"Z d3d dd$d%d&d'Z d(d)d*d+d,Z d(d-d*d.d/Zd(dd*d0d1ZdS )4ÚSimpleResultMetaDataz*result metadata for in-memory collections.)r6 r4 r8 r. r0 r2 r: r5 r6 NzOptional[Sequence[Any]]r7 r- r/ r1 )rB Úextrar8 r. r0 r2 c C sz t || _|| _|| _|| _|r<dd tt| j|D }ndd t| jD }dd |D | _|| _| | jd¡| _
|
d S )Nc S s0 g | ](\}\}}|f|r |nd |||ffqS ©r, r, )rn rg ÚnameÚextrasr, r, rA r s
|
ýþz1SimpleResultMetaData.__init__.<locals>.<listcomp>c S s g | ]\}}|f||d ffqS r r, )rn rg r r, r, rA r s ÿc S s i | ]\}}|D ]
|
}||qqS r, r, )rn rB rU rF r, r, rA rp % s
|
z1SimpleResultMetaData.__init__.<locals>.<dictcomp>r ) r r6 r. r0 r2 Ú enumerateÚzipr4 r8 rr r: )r@ rB r r8 r. r0 r2 Z
|
recs_namesr, r, rA r
|
s
|
ûþz SimpleResultMetaData.__init__rC rD rE c C s
|
|| j kS r> ©r4 rI r, r, rA rJ + s z SimpleResultMetaData._has_keyr+ r< c s: j }|r jr |¡}t j fdd jD |dS )Nc s g | ]} j | d qS )r r ©rn rF r? r, rA r 7 s z4SimpleResultMetaData._for_freeze.<locals>.<listcomp>)r r2 )r2 r. r r6 )r@ Zunique_filtersr, r? rA rK . s
|
|
ýz SimpleResultMetaData._for_freezezDict[str, Any]c C s | j | jdS )N©r6 r0 r¡ r? r, r, rA Ú __getstate__; s þz!SimpleResultMetaData.__getstate__rQ )Ústater= c C s: |d r|d }t | }nd }}| j|d ||d d S )Nr0 r6 )r0 r. )r$ r )r@ r£ r0 r. r, r, rA Ú __setstate__A s
|
ýz!SimpleResultMetaData.__setstate__r úRow[Any])ÚvalueÚrowr= c C s
|
||j kS r> )Ú_data)r@ r¦ r§ r, r, rA Ú _containsM s z SimpleResultMetaData._containsTrl rY c
|
C s^ t |jjkr| j| }z| j| }W n0 tk
|
rT } z| |||¡}W 5 d }~X Y nX |d S rt ©rl Ú __class__Ú__mro__r6 r4 rS rP )r@ rF rN rU rw r, r, rA r[ P s
|
z#SimpleResultMetaData._index_for_keyú Sequence[Any]r] r^ c s fdd|D S )Nc s g | ]} j | d qS ©r r r r? r, rA r [ s z:SimpleResultMetaData._indexes_for_keys.<locals>.<listcomp>r, r_ r, r? rA r` Z s z&SimpleResultMetaData._indexes_for_keysra c c sj |D ]`}t |jjkr | j| }z| j| }W n0 tk
|
r\ } z| ||d¡}W 5 d }~X Y nX |V qd S )NTrª )r@ rB rF rU rw r, r, rA rb ] s
|
z'SimpleResultMetaData._metadata_for_keysc
|
s z fdd|D }W n6 t k
|
rL } z |jd |d¡ W 5 d }~X Y nX t| \}}} jrt fdd|D }t| }t|||| j jd}|S )Nc s, g | ]$} j t|jjkr" j| n| qS r, )r4 rl r« r¬ r6 r r? r, rA r m s ýÿz0SimpleResultMetaData._reduce.<locals>.<listcomp>r Tc s g | ]} j | qS r, )r0 )rn Úidxr? r, rA r | s )r r. r0 r8 r2 ) rS rP rv r r0 r$ r r8 r2 ) r@ rB Zmetadata_for_keysrw rj Znew_keysr ÚtupZ new_metadatar, r? rA rc k s&
|
ü
|
&ú z SimpleResultMetaData._reduce)NNNNN)T)r{ r| r} r~ r r r rJ rK r¢ r¤ r© r[ r` rb rc r, r, r, rA r û s$
|
|
ù!
|
r r5 ú Optional[Any]z#Callable[[Iterable[Any]], Row[Any]])Úfieldsr r= c C s t | |}t t||j|j¡S r> )r Ú functoolsÚpartialr rz r: )r² r r r, r, rA Ú result_tuple s
|
ÿrµ c @ s e Zd ZdZdS )Ú_NoRowr N)r{ r| r} Ú_NO_ROWr, r, r, rA r¶ s r¶ c @ s e Zd ZU dZdZded< dZded< ded < dZd
|
ed < dZded < d Z ded< ded< ddddZ
|
dJdddddZ dKdddd d Z ddd d Z dLdd d!d"d#Zed$dd%d&Zed'dd(d)Zd*dd+d,Zd*dd-d.Zed/dd0d1Zed2dd3d4Zedd5dd6d7d8d9Zedddd:d7d;d9Zdddd:d7d<d9Zd=dd>d?Zd6dd@dAZedBdCdDdEdFZe j dGddHdIZ dS )MÚResultInternalr, NúOptional[Result[Any]]Ú _real_resultTrD Ú_generate_rowsú Optional[Callable[[Any], Any]]Ú_row_logging_fnz Optional[_UniqueFilterStateType]Ú_unique_filter_stateÚ_post_creational_filterFr+ Ú _metadataÚ_source_supports_scalarsú#Iterator[_InterimRowType[Row[Any]]]r< c C s
|
t d S r> rG r? r, r, rA Ú_fetchiter_impl® s z ResultInternal._fetchiter_implú#Optional[_InterimRowType[Row[Any]]]©Ú
|
hard_closer= c C s
|
t d S r> rG ©r@ rÆ r, r, rA Ú_fetchone_impl± s z ResultInternal._fetchone_implrX ú List[_InterimRowType[Row[Any]]]©Úsizer= c C s
|
t d S r> rG ©r@ rË r, r, rA Ú_fetchmany_impl¶ s z ResultInternal._fetchmany_implc C s
|
t d S r> rG r? r, r, rA Ú_fetchall_impl» s z ResultInternal._fetchall_implrQ ©Úhardr= c C s
|
t d S r> rG ©r@ rÐ r, r, rA Ú _soft_close¾ s zResultInternal._soft_closeúOptional[Callable[..., _R]]c sÞ | j r | j ntd| }|jrF| js&d S tddddddfdd }nt}| j}|j}|j}|j}|r¤|js¤|rx||}t
|
||||¡|d
|
d d fd d }nt
|
||||¡}|j rÚ|j |d
|
d d fdd }|S )Nú Result[Any]r+ r7 r9 r r¥ )ÚmetadataÚ
|
processorsÚ key_to_indexÚ
|
scalar_objr= c s | |||fS r> r, )rÕ rÖ r× rØ )Ú_procr, rA Ú process_rowÏ s ÿz/ResultInternal._row_getter.<locals>.process_rowz_InterimRowType[Row[Any]]r' )r§ r= c s | S r> r, ©r§ )Ú_make_row_origÚfixed_tfr, rA Úmake_rowì s z,ResultInternal._row_getter.<locals>.make_rowc s | S r> r, rÛ )Ú_log_rowÚ _make_rowr, rA rÞ ø s ) rº r rÁ r» r rÀ r: rz r. r³ r´ r½ )r@ Ú real_resultrÚ rÕ r× rÖ ÚtfrÞ r, )rß rà rÜ rÙ rÝ rA Ú _row_getterÁ sH ÿý
|
ÿ ÿzResultInternal._row_getterzCallable[..., Iterator[_R]]c sR | j | j| jr8| j\ddd fdd }nddd fdd }|S )NrÔ ú Iterator[_R]©r@ r= c 3 sX | ¡ D ]J} r |n|}r(|n|}|kr6q |¡ rL|}|V qd S r> )rà Úadd)r@ Úraw_rowÚobjÚhashed©rÞ Úpost_creational_filterÚstrategyÚuniquesr, rA Úiterrows s ÿ
|
z1ResultInternal._iterator_getter.<locals>.iterrowsc 3 s4 | ¡ D ]&} r |n|}r(|}|V qd S r> )rà )r@ rç r§ ©rÞ rë r, rA rî s ÿ©rã r¿ r¾ Ú_unique_strategy)r@ rî r, rê rA Ú_iterator_getterý s
|
z ResultInternal._iterator_getterúList[_R]c s, | j d k st| ¡ } fdd|D S )Nc s g | ] } |qS r, r, ©rn r§ ©rÞ r, rA r % s z0ResultInternal._raw_all_rows.<locals>.<listcomp>)rã rR rÎ )r@ Úrowsr, rõ rA Ú _raw_all_rows! s z ResultInternal._raw_all_rowsc s | j | j | ¡ } r, fdd|D }n|}| jrb| j\fddfdd|D D }n|}r|fdd|D }|S )Nc s g | ] } |qS r, r, rô rõ r, rA r 0 s z+ResultInternal._allrows.<locals>.<listcomp>c s& g | ] \}}| kr |¡s|qS r, ©ræ ©rn Úmade_rowZsig_row©rí r, rA r 9 s
|
øc s g | ]}| r |n|fqS r, r, ©rn rú ©rì r, rA r ; s ýþc s g | ] } |qS r, r, rô ©rë r, rA r H s )r¿ rã rÎ r¾ rñ )r@ rö Ú made_rowsZ interim_rowsr, rê rA Ú_allrows' s&
|
|
|
ûþ
|
ÿzResultInternal._allrowsz1Callable[..., Union[Literal[_NoRow._NO_ROW], _R]]c sR | j | j| jr8| j\ddd fdd }nddd fdd }|S )NrÔ zUnion[_NoRow, _R]rå c sd | j }| }|d krtS r$ |n|}r4|n|}|krDqn
|
|¡ rZ|}|S qd S r> )rÈ r· ræ )r@ Z_onerowr§ rè ré rê r, rA ÚonerowX s ÿ
|
z-ResultInternal._onerow_getter.<locals>.onerowc s8 | ¡ }|d krtS r |n|}r0|}|S d S r> )rÈ r· )r@ r§ Z interim_rowrï r, rA r m s ÿrð )r@ r r, rê rA Ú_onerow_getterM s
|
z ResultInternal._onerow_getterzCallable[..., List[_R]]c sn | j | j| jrR| j\dddddddd d d
|
dd fd d }nd d
|
dd fdd }|S )NrÓ z List[Any]z$Optional[Callable[[List[Any]], Any]]zSet[Any]ró )rÞ rö rì rí r= c sN r fdd|D }r.fdd|D }ndd |D }fdd|D S )Nc s g | ] } |qS r, r, rô rõ r, rA r s zFResultInternal._manyrow_getter.<locals>.filterrows.<locals>.<listcomp>c 3 s | ]}| |fV qd S r> r, rü rý r, rA Ú <genexpr> s zEResultInternal._manyrow_getter.<locals>.filterrows.<locals>.<genexpr>c s s | ]}||fV qd S r> r, rü r, r, rA r s c s& g | ] \}}| kr |¡s|qS r, rø rù rû r, rA r s
|
þr, )rÞ rö rì rí rÿ r, )rÞ rì rí rA Ú
|
filterrows s
|
ÿ
|
þz2ResultInternal._manyrow_getter.<locals>.filterrowszResultInternal[_R]rX )r@ Únumr= c sÖ g }| j }|d krx| jr | jntd| }|jr:|j }}q|||}t|}d k sVt| |¡ |t| }n|}|d k st|r¼||}|sq¼| |¡ |t| }qrÒfdd|D }|S )NrÔ c s g | ] } |qS r, r, rô rþ r, rA r Å s úDResultInternal._manyrow_getter.<locals>.manyrows.<locals>.<listcomp>)rÍ rº r Ú
|
_yield_perr rR Úextend)r@ r ZcollectZ _manyrowsrá Z num_requiredrö ©r rÞ rë rì rí r, rA Úmanyrows s: ÿý ÿ ÿz0ResultInternal._manyrow_getter.<locals>.manyrowsc s^ |d kr$| j r| j ntd| }|j}| |¡} rD fdd|D }rZfdd|D }|S )NrÔ c s g | ] } |qS r, r, rô rõ r, rA r × s r c s g | ] } |qS r, r, rô rþ r, rA r Ù s )rº r r rÍ )r@ r rá rö rï r, rA r
|
Ê s ÿý
|
rð )r@ r
|
r, r rA Ú_manyrow_getter{ s
|
1z ResultInternal._manyrow_getterrL r' )Úraise_for_second_rowÚraise_for_noneÚscalarr= c C s d S r> r, ©r@ r r r r, r, rA Ú _only_one_rowÞ s z ResultInternal._only_one_rowú Optional[_R]c C s d S r> r, r r, r, rA r ç s c C s¬ | j }|dd}|d kr,|r(t d¡nd S |rB| jrBd| _d }n| j}z|rV||n|}W n | jdd Y nX |rf| jr"| j\}}|r||n|} |dd}
|
|
|
d krºt }
|
q:zH|rÈ||
|
n|
|
}
|
|rî|
|
t k sÜt
|
| ||
|
krúW q n ||
|
krúW q W q:W q | jdd Y q X q n|dd}
|
|
|
d kr:t }
|
|
|
t k rv| jdd t |r^dnd¡nt }
|
| jdd |s| j } | r| |}|r¤|r¤|d S |S d 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 Z NoResultFoundrÁ r» rã rÒ r¾ rñ r· rR ZMultipleResultsFoundr¿ ) r@ r r r r r§ rÞ rí rì Zexisting_row_hashZnext_rowrë r, r, rA r ð sp
|
ÿ
|
|
|
|
|
|
|
ÿý rä c C s
|
| | ¡S r> )rò r? r, r, rA Ú
|
_iter_implF s zResultInternal._iter_implc C s" | | ¡}|tkrt n|S d S r> )r r· Ú StopIteration©r@ r§ r, r, rA Ú
|
_next_implI s
|
zResultInternal._next_implr\ r# )rj r= c C sD | j r | j ntd| }|jr(t|dkr6| j |¡| _| js@t| S )NrÔ r )rº r rÁ r rÀ rc r» rR )r@ rj rá r, r, rA Ú_column_slicesP s ÿý
|
z ResultInternal._column_slicesÚ_UniqueFilterStateTypec C s | j d k st| j \}}| jd k r(| jntd| }|s| jjr|jrX| jsX| jjd }n(| jj}| jjrt| j |¡}t
|
d|¡}||fS )NrÔ r Z_filter_on_values) r¾ rR rº r rÀ r2 rÁ r» r. re Ú methodcaller)r@ rí rì rá Úfiltersr, r, rA rñ _ s"
|
ÿý ÿþ z ResultInternal._unique_strategy)F)N)F) r{ r| r} r rº r r» r¾ r¿ Z
|
_is_cursorrà rÈ rÍ rÎ rÒ r rã rò r÷ r r r r r r r r r r Zmemoized_attributerñ r, r, r, rA r¸ sJ
|
ÿ ÿ;#&-bVr¸ c @ s( e Zd ZU dZded< ddddZdS ) Ú _WithKeysr, r+ rÀ r; r< c C s | j jS )ak Return 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À rB r? r, r, rA rB s z_WithKeys.keysN)r{ r| r} r r rB r, r, r, rA r y s
|
r c @ sæ e Zd ZU dZdZdZded< dZded< dZd ed
|
< e
|
¡ Z d ed < d dddZ ddddZ dddddddZddddZeddd d Zeddd d Zed dd!d"d#Zedd$dd%d&d'Zd(dd)d*d+Zed,d-d.d/d0Zed,d1d-d2d3d0Zedd(d5d6d7d0Zdd(d5d6d8d0Zdd(dd:d;d<d=Zd>d?d@dAdBZdCddDdEZedFddGdHZ dFddIdJZ dKddLdMZ dNddOdPZ dQddRdSZ dd dTdUdVdWZ!dXddYdZZ"d[dd\d]Z#dd dXdUd^d_Z$dXdd`daZ%d[ddbdcZ&d[ddddeZ'ed,dfd.dgdhZ(edddidhZ(dddjdhZ(ed,dkd.dldmZ)ednddodmZ)dnddpdmZ)dQddqdrZ*ed,dkd.dsdtZ+edddudtZ+dddvdtZ+dwddxdyZ,dzd{d|d}d~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½ FrD rÁ rX r z util.immutabledict[Any, Any]Ú _attributesr+ )Úcursor_metadatac C s
|
|| _ d S r> )rÀ )r@ r r, r, rA r · s zResult.__init__r# r< c C s | S r> r, r? r, r, rA Ú __enter__º s zResult.__enter__r rQ ©Útype_r¦ Ú tracebackr= c C s | ¡ d S r> )Úclose©r@ r# r¦ r$ r, r, rA Ú__exit__½ s zResult.__exit__c C s | j dd 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, rA r% À s z Result.closec C s
|
t d S r> rG r? r, r, rA Ú _soft_closedÖ s zResult._soft_closedc C s
|
t dS )zkreturn ``True`` if this :class:`_engine.Result` reports .closed
|
|
.. versionadded:: 1.4.43
|
|
NrG r? r, r, rA ÚclosedÚ s z Result.closedrl ©r r= c C s
|
|| _ | 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ã s 1zResult.yield_perúOptional[_UniqueFilterType]©rì r= c C s t |f| _| S )a Apply 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@ rì r, r, rA Úunique s & z Result.uniquerW ©Úcol_expressionsr= c G s
|
| |¡S )a9 Establish 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.
|
|
©r ©r@ r4 r, r, rA Úcolumns@ s /zResult.columnszResult[Tuple[_T]]zScalarResult[_T]rå c C s d S r> r, r? r, r, rA Úscalarsq s zResult.scalarsz
|
Literal[0])r@ rg r= c C s d S r> r, ©r@ rg r, r, rA r8 u s r zScalarResult[Any])rg r= c C s d S r> r, r9 r, r, rA r8 { s c C s
|
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.
|
|
)Ú ScalarResultr9 r, r, rA r8 s Trd rY c C s | j rtd| 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Á rH rÀ rh rZ r, r, rA rh s
|
ÿzResult._getterr\ ri r^ c C s | j rtd| j |¡S )zbreturn a callable that will retrieve the given keys from a
|
:class:`_engine.Row`.
|
|
r; )rÁ rH rÀ rk r_ r, r, rA Ú _tuple_getter¥ s
|
ÿzResult._tuple_getterÚ MappingResultc C s t | 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.
|
|
)r= r? r, r, rA Úmappings° s zResult.mappingszTupleResult[_TP]c C s | 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? r, r, rA ÚtÁ s
|
zResult.tc C s | 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? r, r, rA ÚtuplesÍ s z Result.tuplesúIterator[_RowData]c C s
|
t dS )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.
|
|
NrG r? r, r, rA Ú_raw_row_iteratorç s zResult._raw_row_iteratorzIterator[Row[_TP]]c C s | ¡ S r> ©r r? r, r, rA r ð s zResult.__iter__zRow[_TP]c C s | ¡ S r> ©r r? r, r, rA Ú__next__ó s zResult.__next__z Iterator[Sequence[Row[_TP]]]rÊ c c s$ | j }|| |}|r |V qq qdS )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`
|
|
N©r ©r@ rË ÚgetterÚ partitionr, r, rA Ú
|
partitionsö s
|
1
|
zResult.partitionsúSequence[Row[_TP]]c C s | ¡ S )z4A synonym for the :meth:`_engine.Result.all` method.©r r? r, r, rA Úfetchall0 s zResult.fetchallzOptional[Row[_TP]]c C s | | ¡}|tkrdS |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:`_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· r r, r, rA Úfetchone5 s
|
zResult.fetchonec C s | | |¡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:`_engine.Result.partitions`
|
method.
|
|
:return: a list of :class:`_engine.Row` objects.
|
|
.. seealso::
|
|
:meth:`_engine.Result.partitions`
|
|
rF rÌ r, r, rA Ú fetchmanyK s zResult.fetchmanyc C s | ¡ S )zêReturn all rows in a list.
|
|
Closes the result set after invocation. Subsequent invocations
|
will return an empty list.
|
|
.. versionadded:: 1.4
|
|
:return: a list of :class:`_engine.Row` objects.
|
|
rL r? r, r, rA Úall` s z
|
Result.allc C s | j ddddS )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©r r r ©r r? r, r, rA Úfirstn s
|
# ÿz Result.firstc C s | j ddddS )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`
|
|
TFrR rS r? r, r, rA Ú one_or_none s
|
ÿzResult.one_or_noner) c C s d S r> r, r? r, r, rA Ú
|
scalar_one® s zResult.scalar_onec C s d S r> r, r? r, r, rA rV ² s c C s | j ddddS )a 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`
|
|
TrR rS r? r, r, rA rV ¶ s
|
ÿú Optional[_T]c C s d S r> r, r? r, r, rA Úscalar_one_or_noneÇ s zResult.scalar_one_or_noner± c C s d S r> r, r? r, r, rA rX Ë s c C s | j ddddS )a$ Return exactly one scalar result or ``None``.
|
|
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`
|
|
TFrR rS r? r, r, rA rX Ï s
|
ÿc C s | j ddddS )ae 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:`_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`
|
|
TFrR rS r? r, r, rA Úoneà s
|
ÿz
|
Result.onec C s d S r> r, r? r, r, rA r s z Result.scalarc C s d S r> r, r? r, r, rA r s c C s | j ddddS )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.
|
|
FTrR rS r? r, r, rA r s
|
ÿúFrozenResult[_TP]c C s t | S )a Return 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 s z Result.freezerÔ zMergedResult[_TP])Úothersr= c G s t | 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 Úmerge2 s z Result.merge)N)r )r )T)N)N).r{ r| r} r~ r r½ r rÁ r r Z immutabledictr r r! r' r% r r( r) r r, r2 r7 r r8 rh r< r> r? r@ rB r rE rJ rM rO rP rQ rT rU rV rX rY r r\ r_ r, r, r, rA r s|
|
3(1 ÿ ÿ:'!r c @ sò e Zd ZU dZdZded< ded< ddd d
|
Zd d d d d ddZedddddZ d1dd dddZ
|
e ddddZ e dddd Z d dd d Ze d dd d!Zd"dd#d$Zd2dd%d&d'd(Zd)dd*d+Zd3d-d)d.d/d0Zd,S )4Ú FilterResultaZ A 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¾ r r¼ r¿ rÔ rº r# r< c C s | S r> r, r? r, r, rA r! Y s zFilterResult.__enter__r rQ r" c C s | j |||¡ d S r> )rº r' r& r, r, rA r' \ s zFilterResult.__exit__rl r* c C s | 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º r, r+ r, r, rA r, _ s zFilterResult.yield_perFrD rÏ c C s | j j|d d S ©Nr )rº rÒ rÑ r, r, rA rÒ u s zFilterResult._soft_closec C s | j jS r> )rº r( r? r, r, rA r( x s zFilterResult._soft_closedc C s | j jS )z|Return ``True`` if the underlying :class:`_engine.Result` reports
|
closed
|
|
.. versionadded:: 1.4.43
|
|
)rº r) r? r, r, rA r) | s zFilterResult.closedc C s | j ¡ dS )zUClose this :class:`_engine.FilterResult`.
|
|
.. versionadded:: 1.4.43
|
|
N)rº r% r? r, r, rA r% s zFilterResult.closezDict[Any, Any]c C s | j jS r> )rº r r? r, r, rA r s zFilterResult._attributesr c C s
|
| j ¡ S r> )rº rà r? r, r, rA rà s z FilterResult._fetchiter_implrÄ rÅ c C s | j j|dS )Nr )rº rÈ rÇ r, r, rA rÈ s zFilterResult._fetchone_implrÉ c C s
|
| j ¡ S r> )rº rÎ r? r, r, rA rÎ s zFilterResult._fetchall_implNrX rÊ c C s | j j|dS ©N©rË )rº rÍ rÌ r, r, rA rÍ s z FilterResult._fetchmany_impl)F)F)N)r{ r| r} r~ r r r! r' r r, rÒ r r( r) r% r rà rÈ rÎ rÍ r, r, r, rA r` C s,
|
ÿ ÿr` c @ sÊ e Zd ZU dZdZdZded< dddd d
|
Zd+d d dddZd,dddddZ ddddZ
|
d-dddddZ ddd d Z d dd d Z d!dd"d#Zd$dd%d&Zd$dd'd(Zd!dd)d*Zd S ).r: 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Ô rW )rá rg c C sD || _ |jr |j| _d | _n |j |g¡| _t d¡| _|j| _d S rt )rº rÁ rÀ r¿ rc re rf r¾ )r@ rá rg r, r, rA r ¹ s zScalarResult.__init__Nr- r# r. c C s t |f| _| S )z¥Apply unique filtering to the objects returned by this
|
:class:`_engine.ScalarResult`.
|
|
See :meth:`_engine.Result.unique` for usage details.
|
|
r/ r1 r, r, rA r2 Å s zScalarResult.uniquerX úIterator[Sequence[_R]]rÊ c c s$ | j }|| |}|r |V qq qdS )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.
|
|
NrF rG r, r, rA rJ Ï s
|
|
zScalarResult.partitionsú Sequence[_R]r< c C s | ¡ S )ú:A synonym for the :meth:`_engine.ScalarResult.all` method.rL r? r, r, rA rM á s zScalarResult.fetchallc C s | | |¡S )z¸Fetch many objects.
|
|
Equivalent to :meth:`_engine.Result.fetchmany` except that
|
scalar values, rather than :class:`_engine.Row` objects,
|
are returned.
|
|
rF rÌ r, r, rA rP æ s zScalarResult.fetchmanyc C s | ¡ S )zÂReturn all scalar values in a list.
|
|
Equivalent to :meth:`_engine.Result.all` except that
|
scalar values, rather than :class:`_engine.Row` objects,
|
are returned.
|
|
rL r? r, r, rA rQ ð s zScalarResult.allrä c C s | ¡ S r> rC r? r, r, rA r ú s zScalarResult.__iter__r' c C s | ¡ S r> rD r? r, r, rA rE ý s zScalarResult.__next__r c C s | j ddddS )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.
|
|
|
FrR rS r? r, r, rA rT s
|
ÿzScalarResult.firstc C s | j ddddS )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.
|
|
TFrR rS r? r, r, rA rU s
|
ÿzScalarResult.one_or_nonec C s | j ddddS )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.
|
|
TFrR rS r? r, r, rA rY s
|
ÿzScalarResult.one)N)N)N)r{ r| r} r~ r r» r r r2 rJ rM rP rQ r rE rT rU rY r, r, r, rA r: £ s
|
|
|
|
r: 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Ú TupleResulta A :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, NrX rd rÊ c C s 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, rA rJ 4 s
|
zTupleResult.partitionsr r< c C s dS )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, rA rO @ s zTupleResult.fetchonere c C s dS )rf Nr, r? r, r, rA rM J s zTupleResult.fetchallc C s dS )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, rA rP N s zTupleResult.fetchmanyc C s dS )zÑReturn all scalar values in a list.
|
|
Equivalent to :meth:`_engine.Result.all` except that
|
tuple values, rather than :class:`_engine.Row` objects,
|
are returned.
|
|
Nr, r? r, r, rA rQ X s zTupleResult.allrä c C s d S r> r, r? r, r, rA r b s zTupleResult.__iter__r' c C s d S r> r, r? r, r, rA rE e s zTupleResult.__next__c C s dS )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, rA rT h s zTupleResult.firstc C s dS )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, rA rU s s zTupleResult.one_or_nonec C s dS )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, rA rY } s zTupleResult.onezTupleResult[Tuple[_T]]r) rå c C s d S r> r, r? r, r, rA rV s zTupleResult.scalar_oner c C s d S r> r, r? r, r, rA rV s c 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, rA rV s rW c C s d S r> r, r? r, r, rA rX s z TupleResult.scalar_one_or_noner± c C s d S r> r, r? r, r, rA rX ¢ s c 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, rA rX ¦ s c C s d S r> r, r? r, r, rA r µ s zTupleResult.scalarc C s d S r> r, r? r, r, rA r ¹ s c 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, rA r ½ s )N)N)r{ r| r} r~ r r rJ rO rM rP rQ r rE rT rU rY r rV rX r r, r, r, rA rg & s: ÿ
|
|
|
|
|
rg c @ sæ e Zd ZdZdZdZe d¡ZddddZ d/d
|
d d d dZ
|
dd dddZ d0dddddZ ddddZ d dd d Zd1dddd d Zddd!d"Zd#dd$d%Zd&dd'd(Zd dd)d*Zd dd+d,Zd&dd-d.Zd S )2r= 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Ú_mappingrÔ ©Úresultc C s0 || _ |j| _|j| _|jr,| j dg¡| _d S rt )rº r¾ rÀ rÁ rc ©r@ rj r, r, rA r Þ s
|
zMappingResult.__init__Nr- r# r. c C s t |f| _| S )z¦Apply unique filtering to the objects returned by this
|
:class:`_engine.MappingResult`.
|
|
See :meth:`_engine.Result.unique` for usage details.
|
|
r/ r1 r, r, rA r2 å s zMappingResult.uniquerW r3 c G s
|
| |¡S )z:Establish the columns that should be returned in each row.r5 r6 r, r, rA r7 ï s zMappingResult.columnsrX z Iterator[Sequence[RowMapping]]rÊ c c s$ | j }|| |}|r |V qq qdS )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.
|
|
NrF rG r, r, rA rJ ó s
|
|
zMappingResult.partitionszSequence[RowMapping]r< c C s | ¡ S )z;A synonym for the :meth:`_engine.MappingResult.all` method.rL r? r, r, rA rM s zMappingResult.fetchallzOptional[RowMapping]c C s | | ¡}|tkrdS |S dS )zÊFetch one object.
|
|
Equivalent to :meth:`_engine.Result.fetchone` except that
|
:class:`_engine.RowMapping` values, rather than :class:`_engine.Row`
|
objects, are returned.
|
|
NrN r r, r, rA rO s
|
zMappingResult.fetchonec C s | | |¡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.
|
|
rF rÌ r, r, rA rP s zMappingResult.fetchmanyc C s | ¡ S )z×Return all scalar values in a list.
|
|
Equivalent to :meth:`_engine.Result.all` except that
|
:class:`_engine.RowMapping` values, rather than :class:`_engine.Row`
|
objects, are returned.
|
|
rL r? r, r, rA rQ & s zMappingResult.allzIterator[RowMapping]c C s | ¡ S r> rC r? r, r, rA r 1 s zMappingResult.__iter__r c C s | ¡ S r> rD r? r, r, rA rE 4 s zMappingResult.__next__c C s | j ddddS )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.
|
|
|
FrR rS r? r, r, rA rT 7 s
|
ÿzMappingResult.firstc C s | j ddddS )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.
|
|
TFrR rS r? r, r, rA rU D s
|
ÿzMappingResult.one_or_nonec C s | j ddddS )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.
|
|
TFrR rS r? r, r, rA rY P s
|
ÿzMappingResult.one)N)N)N)r{ r| r} r~ r r» re Ú
|
attrgetterr¿ r r2 r7 rJ rM rO rP rQ r rE rT rU rY r, r, r, rA r= Ï s$
|
|
ÿ r= c @ sT e Zd ZU dZded< ddddZdd d
|
d Zd d dddZdd ddZdS )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 Údataz Result[_TP]ri c C s@ |j ¡ | _|j| _|j| _| jr2t| ¡ | _n
|
| ¡ | _d S r> ) rÀ rK rÕ rÁ r r rB rm rM rk r, r, rA r s zFrozenResult.__init__zSequence[Sequence[Any]]r< c C s* | j rdd | jD S dd | jD S d S )Nc S s g | ]
|
}|gqS r, r, )rn Úelemr, r, rA r s z-FrozenResult.rewrite_rows.<locals>.<listcomp>c S s g | ] }t |qS r, r rô r, r, rA r s )rÁ rm r? r, r, rA Ú rewrite_rows s zFrozenResult.rewrite_rowsrK rZ )Ú
|
tuple_datar= c C sD t t ¡}| j|_| j|_| j|_| jr:dd |D |_n||_|S )Nc S s g | ] }|d qS r® r, )rn Údr, r, rA r s z.FrozenResult.with_new_rows.<locals>.<listcomp>)r[ Ú__new__rÕ r rÁ rm )r@ rp Úfrr, r, rA Ú with_new_rows s
|
zFrozenResult.with_new_rowsc C s& t | jt| j}| j|_| j|_|S r> )ÚIteratorResultrÕ r rm r rÁ rk r, r, rA Ú__call__¤ s ÿzFrozenResult.__call__N) r{ r| r} r~ r r ro rt rv r, r, r, rA r[ ] s
|
&
|
r[ c @ s° e Zd ZdZdZdZd&dddddd d
|
Zedd d d Zd'ddddddZ dd ddZ
|
dd ddZ dd ddZ d(ddd d d Z d d d d!Zd)d"d d#d$d%ZdS )*ru zA :class:`_engine.Result` that gets data from a Python iterator of
|
:class:`_engine.Row` objects or similar row-like data.
|
|
.. versionadded:: 1.4
|
|
FNr+ z(Iterator[_InterimSupportsScalarsRowType]r¹ rD )r ÚiteratorÚrawrÁ c C s || _ || _|| _|| _d S r> )rÀ rw rx rÁ )r@ r rw rx rÁ r, r, rA r ¸ s zIteratorResult.__init__r< c C s | j S )z{Return ``True`` if this :class:`_engine.IteratorResult` has
|
been closed
|
|
.. versionadded:: 1.4.43
|
|
)Ú _hard_closedr? r, r, rA r) Ä s zIteratorResult.closedr rQ ©rÐ Úkwr= c K sF |r
|
d| _ | jd k r*| jjf d|i| tg | _| ¡ d| _d S )NTrÐ )ry rx rÒ r rw Z_reset_memoizationsr( ©r@ rÐ r{ r, r, rA rÒ Î s
|
|
zIteratorResult._soft_closer c C s t d¡d S )Nz This result object is closed.)r ZResourceClosedErrorr? r, r, rA Ú_raise_hard_closed× s z!IteratorResult._raise_hard_closedrA c C s | j S r> )rw r? r, r, rA rB Ú s z IteratorResult._raw_row_iteratorc C s | j r| ¡ | jS r> )ry r} rw r? r, r, rA rÃ Ý s z IteratorResult._fetchiter_implrÄ rÅ c C s: | j r| ¡ t| jt}|tkr2| j|d d S |S d S ra )ry r} Únextrw r· rÒ )r@ rÆ r§ r, r, rA rÈ â s z IteratorResult._fetchone_implrÉ c C s, | j r| ¡ zt| jW ¢S | ¡ X d S r> )ry r} rÒ r rw r? r, r, rA rÎ ï s
|
z IteratorResult._fetchall_implrX rÊ c C s" | j r| ¡ tt | jd|¡S rt )ry r} r Ú itertoolsÚislicerw rÌ r, r, rA rÍ ÷ s z IteratorResult._fetchmany_impl)NF)F)F)N)r{ r| r} r~ ry r( r r r) rÒ r} rB rà rÈ rÎ rÍ r, r, r, rA ru s" û ÿ ÿru zIteratorResult[Any]r< c C s t tg tg S r> )ru r r r, r, r, rA Ú null_result s r c sn e Zd ZdZdddddddd d
|
Zed d d ddZddddd fdd Zd ddd 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+ zBCallable[[Optional[int]], Iterator[Sequence[_InterimRowType[_R]]]]rD r¹ )r ÚchunksÚsource_supports_scalarsrx Údynamic_yield_perc C s6 || _ || _|| _|| _tj | d ¡¡| _|| _d S r> ) rÀ r rÁ rx r ÚchainÚ from_iterablerw r
)r@ r r r rx r
r, r, rA r s
|
z ChunkedIteratorResult.__init__rl r# r* c C s || _ tj | |¡¡| _| S r> )r r r r r rw r+ r, r, rA r, % s z ChunkedIteratorResult.yield_perr rQ rz c s$ t jf d|i| dd | _d S )NrÐ c S s g S r> r, rc r, r, rA Ú<lambda>3 ó z3ChunkedIteratorResult._soft_close.<locals>.<lambda>)ÚsuperrÒ r r| ©r« r, rA rÒ 1 s z!ChunkedIteratorResult._soft_closerX rÉ rÊ c s( | j rtj | |¡¡| _t j|dS rb )r
r r r r rw r rÍ rÌ r r, rA rÍ 5 s z%ChunkedIteratorResult._fetchmany_impl)FNF)F)N)
|
r{ r| r} r~ r r r, rÒ rÍ Ú __classcell__r, r, r rA r s ø ÿr c sJ e Zd ZU dZdZded< ddd fdd Zdd
|
d d d ddZ 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
|
|
FrX Zrowcountr+ zSequence[Result[_TP]])r Úresultsc sf || _ t |tj dd |D ¡¡ |d j| _|d j| _|d j| _| j j
|
dd |D | _ d S )Nc s s | ]}| ¡ V qd S r> )rB ©rn Úrr, r, rA r P s z(MergedResult.__init__.<locals>.<genexpr>r c S s g | ]
|
}|j qS r, )r r r, r, rA r \ s z)MergedResult.__init__.<locals>.<listcomp>) Ú_resultsr r r r r r¾ r rÁ r Z
|
merge_with)r@ r r r r, rA r J s ÿþ ÿzMergedResult.__init__rD r rQ rz c K s. | j D ]}|jf d|i| q|r*d| _d S )NrÐ T)r rÒ r) )r@ rÐ r{ r r, r, rA rÒ _ s
|
zMergedResult._soft_close)F) r{ r| r} r~ r) r r rÒ r r, r, r rA r^ = s
|
|
r^ )N)Xr~ Ú
|
__future__r Úenumr r³ r re Útypingr r r r r r r
|
r r r r r r r r r r r r§ r r Ú r r Zsql.baser r r r r Z util._has_cyr! Z util.typingr" r# Z_py_rowr$ Z"sqlalchemy.cyextension.resultproxyZ
|
sql.schemar% Z sql.type_apir& r Z_KeyTyperl rW rT r3 Z_RowDataZ _RawRowTyper' r) r* Z_InterimRowTypeZ _InterimSupportsScalarsRowTypeZ_ProcessorsTyperi Z_UniqueFilterTyper r+ ÚKeysViewr; r rµ r¶ r· r¸ r r r` r: Z
|
TypingOnlyrg r= r[ ru r r r^ r, r, r, rA Ú<module> s° |" ÿ ] 5` * PS9
|
