U
|
¸ý°d + ã @ s U d Z ddlmZ ddlZddlZddlZddlZddlmZ ddlmZ ddlm Z ddlm
|
Z
|
ddlm Z dd lm Z dd
|
lm Z dd lmZ dd lmZ dd lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ 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& 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'l0m1Z1 dd(l0m2Z2 ejrdd)l3m4Z4 dd*l5m6Z6 dd+l7m8Z8 dd,l7m9Z9 dd-l7m:Z: dd.l7m;Z; dd/lm<Z< dd0lm=Z= dd1lm>Z> dd2lm?Z? dd3lm@Z@ dd4lmAZA dd5l-mBZB ed6ed7ZCdZDd8eEd9< dZFd:eEd;< dZGd<eEd=< d>ZHd?eEd@< dAZIdBeEdC< dDZJdEeEdF< dGZKdHeEdI< eeeL eLe e eMeMedJ eeM f ZNe dKeNf ZOeeLeLe e eMeMedJ eMf ZPG dLdM dMeZQG dNdO dOZRG dPdQ dQeRZSG dRdS dSeSZTeT ZUG dTdU dUeSZVeV ZWG dVdW dWeRZXeX ZYG dXdY dYeXZZG dZd[ d[eXZ[G d\d] d]eZ\e\ Z]d^d_d`daZ^G dbdc dceeC Z_e_Z`dS )dzNDefine cursor-specific result set constructs including
|
:class:`.CursorResult`.é )Ú annotationsN)ÚAny)Úcast)ÚClassVar)ÚDict)ÚIterator)ÚList)ÚMapping)ÚNoReturn)ÚOptional)ÚSequence)ÚTuple)Ú TYPE_CHECKING)ÚTypeVar)ÚUnioné )ÚIteratorResult)Ú MergedResult)ÚResult)ÚResultMetaData)ÚSimpleResultMetaData)Ú tuplegetter)ÚRowé )Úexc)Úutil)Úelements)Úsqltypes)Ú _generative)ÚResultColumnsEntry)ÚRM_NAME)Ú
|
RM_OBJECTS)ÚRM_RENDERED_NAME)ÚRM_TYPE)Ú
|
TypeEngine)Úcompat)ÚLiteral)ÚSelf)Ú
|
Connection)ÚDefaultExecutionContext)Ú_DBAPICursorDescription)Ú DBAPICursor)ÚDialect)ÚExecutionContext)Ú _KeyIndexType)Ú_KeyMapRecType)Ú _KeyMapType)Ú_KeyType)Ú_ProcessorsType)Ú_TupleGetterType)Ú_ResultProcessorTypeÚ_T)Úboundz
|
Literal[0]ÚMD_INDEXz
|
Literal[1]ÚMD_RESULT_MAP_INDEXz
|
Literal[2]Ú
|
MD_OBJECTSé z
|
Literal[3]Ú MD_LOOKUP_KEYé z
|
Literal[4]ÚMD_RENDERED_NAMEé z
|
Literal[5]Ú MD_PROCESSORé z
|
Literal[6]ÚMD_UNTRANSLATEDr4 r1 c
|
@ s| e Zd ZU dZdZded< ded< ded< d ed
|
< d ed < d ed < dZded< dd dddZddddZd ddddd d dd d d d Z d dd d Z
|
d d d!d"d#Z d$dd%d&d'Z d(dd)d*d+Z d,d-d.d/d0Zd1d2 Zd3d4 Zd5d6 Zd7d8 ZedWd:d d;d<d=d>Zd?d@ Zes4dXddAd dBdCdDdEZdFdG ZdYdd dHdIdJdKZdLdM ZdNdOd%dPdQZdRdS Z dTdU Z dVS )ZÚCursorResultMetaDataz"Result metadata for DBAPI cursors.) Ú_keymapÚ _processorsÚ_keysÚ _keymap_by_result_column_idxÚ _tuplefilterÚ_translated_indexesÚ_safe_for_cacheÚ
|
_unpickledÚ _key_to_indexÚ_CursorKeyMapTyperC r2 rD z#Optional[Dict[int, _KeyMapRecType]]rF ÚboolrJ rI zOptional[List[int]]rH TzClassVar[bool]Ú returns_rowsr )ÚkeyÚreturnc C s
|
|| j kS ©N©rC ©ÚselfrO © rU úOd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/engine/cursor.pyÚ_has_key¨ s z CursorResultMetaData._has_keyr ©rP c s t j fdd jD dS )Nc s g | ]} j | t qS rU )rC r9 ©Ú.0rO ©rT rU rV Ú
|
<listcomp>® s z4CursorResultMetaData._for_freeze.<locals>.<listcomp>)Úextra)r rE r[ rU r[ rV Ú _for_freeze« s þz CursorResultMetaData._for_freezez Sequence[str]r0 zOptional[_TupleGetterType]) Ú unpickledÚ
|
processorsÚkeysÚkeymapÚ tuplefilterÚtranslated_indexesÚsafe_for_cacheÚkeymap_by_result_column_idxrP c
|
C sP | j | j ¡} || _|| _|| _|| _|| _|| _|| _|| _ |
|
|t ¡| _ | S rQ ) Ú __class__Ú__new__rJ rD rE rC rG rH rI rF Ú_make_key_to_indexr7 rK )
|
rT r_ r` ra rb rc rd re rf Znew_objrU rU rV Ú_make_new_metadata± s z'CursorResultMetaData._make_new_metadatac
|
C sH | j r
|
t| j| jd gt| j d d dd | j ¡ D | j| j | j
|
dS )Nc S s. i | ]&\}}||d d
d |dd
qS )r r> rQ r@ NrU ©rZ rO ÚvaluerU rU rV Ú
|
<dictcomp>Ð s ÿ z;CursorResultMetaData._remove_processors.<locals>.<dictcomp>)r_ r` rc rd rb ra re rf ) rG ÚAssertionErrorrj rJ ÚlenrD rC ÚitemsrE rI rF r[ rU rU rV Ú_remove_processorsÉ s
|
þõz'CursorResultMetaData._remove_processors)ÚotherrP c sz | j r
|
tt| j t| j fdd|j ¡ D ¡ | j| j | j
|
|j
|
d d | j|j | j dd ¡ D dS )Nc sN i | ]F\}}||d dk r.| kr.|d nd|d f|dd
qS )r Nr r rU rk ©rb ÚoffsetrU rV rm â s ø
|
ÿÿ
|
û
|
úz=CursorResultMetaData._splice_horizontally.<locals>.<dictcomp>c S s i | ]}|t |qS rU ©r8 ©rZ Úmetadata_entryrU rU rV rm ö s ÿ )r_ r` rc rd ra rb re rf ) rG rn ÚdictrC ro rE Úupdaterp rj rJ rD rI Úvalues)rT rr rU rs rV Ú_splice_horizontallyÙ s(
|
|
|
÷ÿ
|
|
þøz)CursorResultMetaData._splice_horizontallyzSequence[_KeyIndexType])ra rP c
|
s t |¡}dd |D }dd |D } jrB fdd|D }t| }dd t|D }dd |D }| dd |D ¡ j j j|||| j j
|
d
|
S ) Nc S s g | ] }|t qS rU )r7 ©rZ ÚrecrU rU rV r\ ÿ s z0CursorResultMetaData._reduce.<locals>.<listcomp>c S s g | ] }|t qS rU ©r; r| rU rU rV r\ s c s g | ]} j | qS rU )rH )rZ Úidxr[ rU rV r\ s c S s" g | ]\}}|f|d d
qS ©r NrU )rZ Úindexr} rU rU rV r\ s c S s i | ]}|t |qS rU r~ r| rU rU rV rm s z0CursorResultMetaData._reduce.<locals>.<dictcomp>c s s( | ] }|t pd D ]}||fV qqdS )rU N©r9 )rZ Znew_recÚerU rU rV Ú <genexpr> s þz/CursorResultMetaData._reduce.<locals>.<genexpr>)r_ r` ra rc rd rb re rf ) ÚlistÚ_metadata_for_keysrH r Ú enumeratery rj rJ rD rI rF )rT ra ZrecsZindexesZnew_keysÚtupZnew_recsrb rU r[ rV Ú_reduceü s*
|
þøz CursorResultMetaData._reducer- )ÚcontextrP c
|
sÀ |j r|j js| S |j j}|j}tr4t|tjs4t||kr@| S |dk sLt| j dkrtdd | j
|
¡ D | _ | j r~t| j t | j
|
fddt|jD ¡| j| jdd| j| j| j dS )a[ When using a cached Compiled construct that has a _result_map,
|
for a new statement that used the cached Compiled, we need to ensure
|
the keymap has the Column objects from our new statement as keys.
|
So here we rewrite keymap with new entries for the new columns
|
as matched to those of the cached statement.
|
|
Nc S s i | ]}|t |qS rU ru rv rU rU rV rm @ s ÿ z:CursorResultMetaData._adapt_to_context.<locals>.<dictcomp>c s" i | ]\}}| kr| | qS rU rU )rZ r Únew©Zkeymap_by_positionrU rV rm I s ü )rb r_ r` rc rd ra re rf )ÚcompiledÚ_result_columnsÚ statementÚinvoked_statementr Ú
|
isinstancer Z ClauseElementrn rF rC rz rG rj r% Z
|
dict_unionr Z_all_selected_columnsrJ rD rE rI )rT r Zcompiled_statementr rU r rV Ú_adapt_to_context s@
|
þ
|
|
ÿþþ
|
ïz&CursorResultMetaData._adapt_to_contextúCursorResult[Any]r* )ÚparentÚcursor_descriptionc
|
s |j }d _d _d __|jr>|j\}}}}}t|} nd } } } } }} |||| ||||¡}
|
dd |
|
D _d _ | r@dd |
|
D } t| | kr"i } t
|
|
|
D ]B} | t f| t pÊd D ]&}| t }| ||¡|krÎ |¡ qÎq´ fdd|
|
D _| dd D ¡ nd d |
|
D _j | ¡ nd
|
d |
|
D _| sx|jrxj fd d|
|
D ¡ jt ¡_d S ) NFc S s g | ] }|t qS rU )r? rv rU rU rV r\
s z1CursorResultMetaData.__init__.<locals>.<listcomp>c S s i | ]}|t |qS rU r~ rv rU rU rV rm s ÿ z1CursorResultMetaData.__init__.<locals>.<dictcomp>rU c s0 i | ](}|t r|t D ]}| kr||qqS rU r ©rZ rw Zobj_elem)ÚdupesrU rV rm ¶ s
|
ü c
|
S s i | ]}|d d g ||d d fqS rQ rU rY rU rU rV rm Á s ÿ c S s( i | ] }|t r|t D ]
|
}||qqS rU r r rU rU rV rm Í s
|
ý c S s i | ]}|t |qS rU r~ rv rU rU rV rm Ø s ÿ c s( i | ] }|t r|t j|t qS rU )rA rC r; rv r[ rU rV rm ç s ü ÿ)r rG rH rI rJ Zresult_column_structro Ú_merge_cursor_descriptionrD rF Úsetr= r9 r7 Ú
|
setdefaultÚaddrC ry Ú_translate_colnameri rK )rT r r r Úresult_columnsÚcols_are_orderedÚtextual_orderedÚad_hoc_textualÚloose_column_name_matchingÚ num_ctx_colsÚrawÚby_keyZ index_by_keyrw rO r rU )r rT rV Ú__init__Z s ú
|
úÿýû ø ÿþ
|
ÿ
|
þ
|
þÿ þþ
|
üÿ
|
z CursorResultMetaData.__init__c
|
s´ |rF|rF|sF|t krFdd |D | _d| _ fddt|D S |sZ|rpt |krpd| _| |¡} n.|rd| _| ||¡} nd| _| ¡} fdd| D S dS )a# Merge a cursor.description with compiled result column information.
|
|
There are at least four separate strategies used here, selected
|
depending on the type of SQL construct used to start with.
|
|
The most common case is that of the compiled SQL expression construct,
|
which generated the column names present in the raw SQL string and
|
which has the identical number of columns as were reported by
|
cursor.description. In this case, we assume a 1-1 positional mapping
|
between the entries in cursor.description and the compiled object.
|
This is also the most performant case as we disregard extracting /
|
decoding the column names present in cursor.description since we
|
already have the desired name we generated in the compiled SQL
|
construct.
|
|
The next common case is that of the completely raw string SQL,
|
such as passed to connection.execute(). In this case we have no
|
compiled construct to work with, so we extract and decode the
|
names from cursor.description and index those as the primary
|
result row target keys.
|
|
The remaining fairly common case is that of the textual SQL
|
that includes at least partial column information; this is when
|
we use a :class:`_expression.TextualSelect` construct.
|
This construct may have
|
unordered or ordered column information. In the ordered case, we
|
merge the cursor.description and the compiled construct's information
|
positionally, and warn if there are additional description names
|
present, however we still decode the names in cursor.description
|
as we don't have a guarantee that the names in the columns match
|
on these. In the unordered case, we match names in cursor.description
|
to that of the compiled construct based on name matching.
|
In both of these cases, the cursor.description names and the column
|
expression objects and names are indexed as result row target keys.
|
|
The final case is much less common, where we have a compiled
|
non-textual SQL expression construct, but the number of columns
|
in cursor.description doesn't match what's in the compiled
|
construct. We make the guess here that there might be textual
|
column expressions in the compiled construct that themselves include
|
a comma in them causing them to split. We do the same name-matching
|
as with textual non-ordered columns.
|
|
The name-matched system of merging is the same as that used by
|
SQLAlchemy for all cases up through the 0.9 series. Positional
|
matching for compiled SQL expressions was introduced in 1.0 as a
|
major performance feature, and positional matching for textual
|
:class:`_expression.TextualSelect` objects in 1.1.
|
As name matching is no longer
|
a common case, it was acceptable to factor it into smaller generator-
|
oriented methods that are easier to understand, but incur slightly
|
more performance overhead.
|
|
c S s g | ] }|d qS ©r rU )rZ ÚelemrU rU rV r\ : s zBCursorResultMetaData._merge_cursor_description.<locals>.<listcomp>Tc sH g | ]@\}}|||t |t |t |t |t | d ¡dfqS r )r! r r" Úget_result_processorr# )rZ r Z
|
rmap_entry©r r rU rV r\ C s ô
|
ýõFc s6 g | ].\}}}}}}}||||| |||¡|fqS rU )r¨ )rZ r ÚridxZcursor_colnameÚ mapped_typeÚcoltypeÚobjÚ untranslated)r rU rV r\ t s( ï ÿ÷N)ro rE rI r Ú _merge_textual_cols_by_positionÚ_merge_cols_by_nameÚ_merge_cols_by_none)
|
rT r r r r¢ r r r r¡ Z raw_iteratorrU r© rV r ò sP Cÿþý
|
ü òÿ
|
ÿ ÿü ÿ
|
ìz.CursorResultMetaData._merge_cursor_descriptionc c s |j }|j}|jr|jnd}d}g | _t|D ]N\}}|d } |d }
|
|rV|| \} }|rb|| } | j | ¡ || ||
|
fV q.dS )zÖExtract column names and data types from a cursor.description.
|
|
Applies unicode decoding, column translation, "normalization",
|
and case sensitivity rules to the names based on the dialect.
|
|
Nr r )Údialectr Zrequires_name_normalizeÚnormalize_namerE r Úappend) rT r r r² Ztranslate_colnamer³ r® r r} Úcolnamer¬ rU rU rV Ú_colnames_from_description s ÿ z/CursorResultMetaData._colnames_from_descriptionc c s t |}|t |kr*t d|t |f ¡ t }| ||¡D ]\}}}} ||k r|| }
|
|
|
t } |} |
|
t } | d |krt d| d ¡| | d ¡ nt
|
j } d } d } || || | | |fV q<d S )NzVNumber of columns in textual SQL (%d) is smaller than number of columns requested (%d)r z8Duplicate column expression requested in textual SQL: %r) ro r Úwarnr r¶ r! r# r ÚInvalidRequestErrorr r ÚNULLTYPE)rT r r r r¢ Úseenr rµ r® r¬ Úctx_recr rª r« rU rU rV r¯ ª s<
|
þÿ
|
û ÿÿz4CursorResultMetaData._merge_textual_cols_by_positionc c s | ||¡}| ||¡D ]h\}}}} z || }
|
W n" tk
|
rR tj} d } d } Y nX |
|
d } |
|
d } |
|
d } || || | | |fV qd S )Nr r r: )Ú _create_description_match_mapr¶ ÚKeyErrorr r¹ )rT r r r r¡ Z match_mapr rµ r® r¬ r» r« r Zresult_columns_idxrU rU rV r° Í s6 ÿ
|
|
û
|
ùz(CursorResultMetaData._merge_cols_by_nameFzList[ResultColumnsEntry]zKDict[Union[str, object], Tuple[str, Tuple[Any, ...], TypeEngine[Any], int]])r r¡ rP c C s¢ i }t |D ]\}}|t }||krN|| \}}} }
|
|||t | |f||< n |t |t |t |f||< |r |t D ]$} | | |t |t |t |f¡ qvq |S )zÚwhen matching cursor.description to a set of names that are present
|
in a Compiled object, as is the case with TextualSelect, get all the
|
names we expect might match those in cursor.description.
|
)r r" r! r r# r ) Úclsr r¡ Údrª r§ rO Ze_nameZe_objÚe_typeZe_ridxZr_keyrU rU rV r¼ ó s ý þz2CursorResultMetaData._create_description_match_mapc c s4 | ||¡D ]"\}}}}|d |tj|d |fV q d S rQ )r¶ r r¹ )rT r r r rµ r® r¬ rU rU rV r± s
|
ûùz(CursorResultMetaData._merge_cols_by_nonezOptional[Exception]zOptional[NoReturn])rO ÚerrÚraiseerrrP c C sD |r<| j r$t|tjr$t d¡|q@t dt |¡ ¡|nd S d S )Nz9Row was unpickled; lookup by ColumnElement is unsupportedz.Could not locate column in row for column '%s')rJ r r Z ColumnElementr ZNoSuchColumnErrorr Zstring_or_unprintable)rT rO rÁ r rU rU rV Ú _key_fallback0 s ÿýÿÿýz"CursorResultMetaData._key_fallbackc C s t d|t ¡d S )Nz<Ambiguous column name '%s' in result set column descriptions)r r¸ r; )rT r} rU rU rV Ú _raise_for_ambiguous_column_nameB s
|
ÿÿz5CursorResultMetaData._raise_for_ambiguous_column_nameú Optional[int])rO r rP c
|
C s t |tr| j| }z| j| }W nB tk
|
rd } z$| |||¡}|d ksNtW Y ¢d S d }~X Y nX |d }|d kr| |¡ |S ©Nr )r ÚintrE rC r½ rà rn rÄ )rT rO r r} ÚkeÚxr rU rU rV Ú_index_for_keyH s
|
|
|
z#CursorResultMetaData._index_for_keyc
|
sP z fdd|D W S t k
|
rJ } zt |jd |¡ W 5 d }~X Y nX d S )Nc s g | ]} j | d qS r¦ rR rY r[ rU rV r\ ^ s z:CursorResultMetaData._indexes_for_keys.<locals>.<listcomp>r )r½ rB rà Úargs)rT ra rÈ rU r[ rV Ú_indexes_for_keys[ s z&CursorResultMetaData._indexes_for_keysz Sequence[Any]z&Iterator[_NonAmbigCursorKeyMapRecType]c c s |D ]}t |jjkr | j| }z| j| }W n6 tk
|
rb } zt | |jd |¡ W 5 d }~X Y nX |t }|d kr~|
|
|¡ t t |V qd S rÆ ) rÇ rg Ú__mro__rE rC r½ rB rà rË r7 rÄ r Ú _NonAmbigCursorKeyMapRecType)rT ra rO r} rÈ r rU rU rV r c s
|
&
|
z'CursorResultMetaData._metadata_for_keysc C s dd | j ¡ D | j| jdS )Nc
|
S s> i | ]6\}}t |ttfr||t |t g ||t d d fqS rQ )r ÚstrrÇ r7 r8 r= )rZ rO r} rU rU rV rm z s
|
öùz5CursorResultMetaData.__getstate__.<locals>.<dictcomp>)rC rE rH )rC rp rE rH r[ rU rU rV Ú __getstate__w s
|
ö ñz!CursorResultMetaData.__getstate__c C s dd t t|d D | _|d | _d | _| | jt¡| _|d | _d| _ |d rrt
|
d|d | _ t | j | _ n d | _ | _ d S )Nc S s g | ]}d qS rQ rU )rZ Ú_rU rU rV r\ s z5CursorResultMetaData.__setstate__.<locals>.<listcomp>rE rC TrH z List[int])Úrangero rD rC rF ri r7 rK rE rJ r rH r rG )rT ÚstaterU rU rV Ú __setstate__ s
|
|
ÿz!CursorResultMetaData.__setstate__N)F)T)T) Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__Ú __slots__Ú__annotations__rN rW r^ rj rq r{ r r r¥ r r¶ r¯ r° Ú classmethodr¼ r± r rà rÄ rÊ rÌ r rÐ rÔ rU rU rU rV rB sH
|
# > #& ý) ÿrB c @ s¬ e Zd ZU dZdZdZded< dddd d
|
d Zdddd d d ZdddddddZ d$dddddddZ
|
d%ddddddd Z dddd d d Z ddd d d!d"d#Z dS )&ÚResultFetchStrategyzQDefine a fetching strategy for a result object.
|
|
|
.. versionadded:: 1.4
|
|
rU Nú!Optional[_DBAPICursorDescription]Ú alternate_cursor_descriptionr úOptional[DBAPICursor]ÚNone©ÚresultÚ dbapi_cursorrP c C s
|
t d S rQ ©ÚNotImplementedError©rT râ rã rU rU rV Ú
|
soft_close§ s z ResultFetchStrategy.soft_closec C s
|
t d S rQ rä ræ rU rU rV Ú
|
hard_close¬ s z ResultFetchStrategy.hard_closerÇ ©râ rã ÚnumrP c C s d S rQ rU ©rT râ rã rê rU rU rV Ú yield_per± s z ResultFetchStrategy.yield_perFr+ rM r ©râ rã rè rP c C s
|
t d S rQ rä ©rT râ rã rè rU rU rV Úfetchone¹ s z ResultFetchStrategy.fetchonerÅ ©râ rã ÚsizerP c C s
|
t d S rQ rä ©rT râ rã rñ rU rU rV Ú fetchmanyÁ s z ResultFetchStrategy.fetchmanyc C s
|
t d S rQ rä ræ rU rU rV ÚfetchallÉ s z ResultFetchStrategy.fetchallÚ BaseExceptionr
|
©râ rã rÁ rP c C s |d S rQ rU ©rT râ rã rÁ rU rU rV Úhandle_exceptionÐ s z$ResultFetchStrategy.handle_exception)F)N)rÕ rÖ r× rØ rÙ rÞ rÚ rç rè rì rï ró rô rø rU rU rU rV rÜ s
|
ü ürÜ c @ sJ e Zd ZdZdZdd Zdd Zddd Zdd d Zd d Z dddZ
|
d
|
S )ÚNoCursorFetchStrategyzèCursor strategy for a result that has no open cursor.
|
|
There are two varieties of this strategy, one for DQL and one for
|
DML (and also DDL), each of which represent a result that had a cursor
|
but no longer has one.
|
|
rU c C s d S rQ rU ræ rU rU rV rç ä s z NoCursorFetchStrategy.soft_closec C s d S rQ rU ræ rU rU rV rè ç s z NoCursorFetchStrategy.hard_closeFc C s | |d ¡S rQ ©Ú _non_resultrî rU rU rV rï ê s z NoCursorFetchStrategy.fetchoneNc C s | |g ¡S rQ rú rò rU rU rV ró í s z NoCursorFetchStrategy.fetchmanyc C s | |g ¡S rQ rú ræ rU rU rV rô ð s z NoCursorFetchStrategy.fetchallc C s
|
t d S rQ rä ©rT râ ÚdefaultrÁ rU rU rV rû ó s z!NoCursorFetchStrategy._non_result)F)N)N) rÕ rÖ r× rØ rÙ rç rè rï ró rô rû rU rU rU rV rù Ù s
|
|
rù c @ s e Zd ZdZdZdddZdS )ÚNoCursorDQLFetchStrategya° Cursor strategy for a DQL result that has no open cursor.
|
|
This is a result set that can return rows, i.e. for a SELECT, or for an
|
INSERT, UPDATE, DELETE that includes RETURNING. However it is in the state
|
where the cursor is closed and no rows remain available. The owning result
|
object may or may not be "hard closed", which determines if the fetch
|
methods send empty results or raise for closed result.
|
|
rU Nc C s |j rt d¡|n|S d S )Nz This result object is closed.)Úclosedr ÚResourceClosedErrorrü rU rU rV rû s ÿþz$NoCursorDQLFetchStrategy._non_result)N©rÕ rÖ r× rØ rÙ rû rU rU rU rV rþ ÷ s
|
rþ c @ s e Zd ZdZdZdddZdS )ÚNoCursorDMLFetchStrategyz¼Cursor strategy for a DML result that has no open cursor.
|
|
This is a result set that does not return rows, i.e. for an INSERT,
|
UPDATE, DELETE that does not include RETURNING.
|
|
rU Nc C s |j jr t|j |¡ d S rQ )Ú _metadatarN rn Ú_we_dont_return_rowsrü rU rU rV rû s z$NoCursorDMLFetchStrategy._non_result)Nr rU rU rU rV r s r c @ s e Zd ZdZdZddddddZddddd d
|
Zddd d d ddZdddddddZd"dddddddZ d#ddd dd d d Z
|
ddddd d!Z dS )$ÚCursorFetchStrategyzCall fetch methods from a DBAPI cursor.
|
|
Alternate versions of this class may instead buffer the rows from
|
cursors or not use cursors at all.
|
|
rU r rß rà rá c C s
|
t |_d S rQ ©Ú_NO_CURSOR_DQLÚcursor_strategyræ rU rU rV rç - s z CursorFetchStrategy.soft_closec C s
|
t |_d S rQ r ræ rU rU rV rè 2 s z CursorFetchStrategy.hard_closerõ r
|
rö c C s |j |d d ||j¡ d S rQ )Ú
|
connectionZ_handle_dbapi_exceptionr r÷ rU rU rV rø 7 s ÿz$CursorFetchStrategy.handle_exceptionrÇ ré c C s t |d|it ¡ dd|_d S )NÚmax_row_bufferr )Úinitial_bufferÚ growth_factor)Ú BufferedRowCursorFetchStrategyÚ collectionsÚdequer rë rU rU rV rì A s üz CursorFetchStrategy.yield_perFr+ rM r rí c
|
C sX z"| ¡ }|d kr |j|d |W S tk
|
rR } z| |||¡ W 5 d }~X Y nX d S ©N©Úhard)rï Ú _soft_closerõ rø )rT râ rã rè Úrowr rU rU rV rï N s z CursorFetchStrategy.fetchoneNrÅ rð c
|
C sd z.|d kr| ¡ }n
|
| |¡}|s*| ¡ |W S tk
|
r^ } z| |||¡ W 5 d }~X Y nX d S rQ )ró r rõ rø )rT râ rã rñ Úlr rU rU rV ró \ s
|
|
z CursorFetchStrategy.fetchmanyc
|
C sL z| ¡ }| ¡ |W S tk
|
rF } z| |||¡ W 5 d }~X Y nX d S rQ )rô r rõ rø )rT râ rã Úrowsr rU rU rV rô n s z CursorFetchStrategy.fetchall)F)N) rÕ rÖ r× rØ rÙ rç rè rø rì rï ró rô rU rU rU rV r # s
|
ü ür c sr e Zd ZdZdZdddZedd Zd d
|
Zd d Z fd dZ
|
fddZ dddZ dddZ dd Z ZS )r a× A cursor fetch strategy with row buffering behavior.
|
|
This strategy buffers the contents of a selection of rows
|
before ``fetchone()`` is called. This is to allow the results of
|
``cursor.description`` to be available immediately, when
|
interfacing with a DB-API that requires rows to be consumed before
|
this information is available (currently psycopg2, when used with
|
server-side cursors).
|
|
The pre-fetching behavior fetches only one row initially, and then
|
grows its buffer size by a fixed amount with each successive need
|
for additional rows up the ``max_row_buffer`` size, which defaults
|
to 1000::
|
|
with psycopg2_engine.connect() as conn:
|
|
result = conn.execution_options(
|
stream_results=True, max_row_buffer=50
|
).execute(text("select * from table"))
|
|
.. versionadded:: 1.4 ``max_row_buffer`` may now exceed 1000 rows.
|
|
.. seealso::
|
|
:ref:`psycopg2_execution_options`
|
)Ú_max_row_bufferÚ
|
_rowbufferÚ_bufsizeÚ_growth_factorr> Nc C sX | dd¡| _|d k r || _nt | d¡¡| _|| _|rLt| j| j| _n| j| _d S )Nr
|
iè r ) Úgetr r r r ró r Úminr )rT rã Úexecution_optionsr r rU rU rV r¥ s z'BufferedRowCursorFetchStrategy.__init__c C s t |j|jjS rQ )r Úcursorr r )r¾ râ rU rU rV Úcreate° s þz%BufferedRowCursorFetchStrategy.createc
|
C s | j }z |dk r| ¡ }n
|
| |¡}W n0 tk
|
rV } z| |||¡ W 5 d}~X Y nX |s`dS t |¡| _| jr|| j k rt
|
| j || j | _ dS )z*this is currently used only by fetchone().r N) r rô ró rõ rø r r r r r r )rT râ rã rñ Znew_rowsr rU rU rV Ú _buffer_rows· s
|
ÿz+BufferedRowCursorFetchStrategy._buffer_rowsc C s d| _ | | _| _d S rÆ )r r r rë rU rU rV rì Ë s z(BufferedRowCursorFetchStrategy.yield_perc s | j ¡ t ||¡ d S rQ ©r ÚclearÚsuperrç ræ ©rg rU rV rç Ï s
|
z)BufferedRowCursorFetchStrategy.soft_closec s | j ¡ t ||¡ d S rQ ©r r" r# rè ræ r$ rU rV rè Ó s
|
z)BufferedRowCursorFetchStrategy.hard_closeFc
|
C sh | j s^| ||¡ | j s^z|j|d W n0 tk
|
rX } z| |||¡ W 5 d }~X Y nX d S | j ¡ S r )r r r rõ rø Úpopleft)rT râ rã rè r rU rU rV rï × s z'BufferedRowCursorFetchStrategy.fetchonec
|
C s® |d kr| ||¡S t| j}t|}||krz| || ¡}W n0 tk
|
rp } z| |||¡ W 5 d }~X Y nX |s| ¡ n
|
| |¡ |d|
}t
|
||d
¡| _|S rÆ ) rô r
r ro ró rõ rø r Úextendr r )rT râ rã rñ ÚbufZlbr r rU rU rV ró â s
|
|
|
z(BufferedRowCursorFetchStrategy.fetchmanyc
|
C sd z.t | jt | ¡ }| j ¡ | ¡ |W S tk
|
r^ } z| |||¡ W 5 d }~X Y nX d S rQ )r
r rô r" r rõ rø )rT râ rã Úretr rU rU rV rô ÷ s
|
z'BufferedRowCursorFetchStrategy.fetchall)r> N)F)N)rÕ rÖ r× rØ rÙ r¥ rÛ r r rì rç rè rï ró rô Ú __classcell__rU rU r$ rV r ~ s û
|
|
|
|
r c s^ e Zd ZdZdZdddZdd Z fdd Z fd
|
d Zdd dZ dddZ
|
dd Z Z S )Ú FullyBufferedCursorFetchStrategyzêA cursor strategy that buffers rows fully upon creation.
|
|
Used for operations where a result is to be delivered
|
after the database conversation can not be continued,
|
such as MSSQL INSERT...OUTPUT after an autocommit.
|
|
)r rÞ Nc C s0 || _ |d k r t |¡| _nt | ¡ ¡| _d S rQ )rÞ r r r rô )rT rã Zalternate_descriptionr rU rU rV r¥ s z)FullyBufferedCursorFetchStrategy.__init__c C s d S rQ rU rë rU rU rV rì s z*FullyBufferedCursorFetchStrategy.yield_perc s | j ¡ t ||¡ d S rQ r! ræ r$ rU rV rç s
|
z+FullyBufferedCursorFetchStrategy.soft_closec s | j ¡ t ||¡ d S rQ r% ræ r$ rU rV rè s
|
z+FullyBufferedCursorFetchStrategy.hard_closeFc C s$ | j r| j ¡ S |j|d d S d S r )r r& r rî rU rU rV rï s
|
z)FullyBufferedCursorFetchStrategy.fetchonec C sN |d kr| ||¡S t| j}|d|
}t ||d
¡| _|sJ| ¡ |S rÆ )rô r
r r r r )rT râ rã rñ r( r rU rU rV ró ' s
|
z*FullyBufferedCursorFetchStrategy.fetchmanyc C s | j }t ¡ | _ | ¡ |S rQ )r r r r )rT râ rã r) rU rU rV rô 2 s
|
z)FullyBufferedCursorFetchStrategy.fetchall)NN)F)N) rÕ rÖ r× rØ rÙ r¥ rì rç rè rï ró rô r* rU rU r$ rV r+ s ÿ
|
|
|
r+ c @ sf e Zd ZdZdZdddZdd Zdd Zd
|
d Ze d d Z
|
e dd Z e dd Z e dd Z dS )Ú_NoResultMetaDatarU FNc C s t d¡|d S )NzJThis result object does not return rows. It has been closed automatically.)r r )rT rÁ rU rU rV r > s
|
ÿýz&_NoResultMetaData._we_dont_return_rowsc C s | ¡ d S rQ ©r )rT ra r rU rU rV rÊ D s z _NoResultMetaData._index_for_keyc C s | ¡ d S rQ r- rS rU rU rV r G s z$_NoResultMetaData._metadata_for_keysc C s | ¡ d S rQ r- )rT ra rU rU rV r J s z_NoResultMetaData._reducec C s | ¡ d S rQ r- r[ rU rU rV rC M s z_NoResultMetaData._keymapc C s | ¡ d S rQ r- r[ rU rU rV rK Q s z _NoResultMetaData._key_to_indexc C s | ¡ d S rQ r- r[ rU rU rV rD U s z _NoResultMetaData._processorsc C s | ¡ d S rQ r- r[ rU rU rV ra Y s z_NoResultMetaData.keys)N)rÕ rÖ r× rÙ rN r rÊ r r ÚpropertyrC rK rD ra rU rU rU rV r, 9 s
|
|
|
|
r, zIteratorResult[Any]rX c C s t t tg } | ¡ | S rQ )r r, Úiterr )ÚitrU rU rV Únull_dml_resulta s r1 c s e Zd ZU dZdZded< eZdZded< dZ ded< d Z
|
d
|
ed < d ed < ded< ded< d
|
dddddZ dd Z dWddZ edd Zed d Zd d Zd d! Zed"d# Zd$d% Zd&d' Zd(d) Zed*d+ Zd,d- Zd.d/ Zd0d1 Zd2d3 Zd4d5 Z e j d6d7d8d9Z ed:d; Z ed<d= Z!ed>d? Z"d@dA Z#dXdBdCZ$dDdE Z%dYdGdHZ&dIdJ Z'dKdLdM fdNdO Z(dPd7dQdRZ)e*d6dSdTdUdVZ+ Z,S )ZÚ CursorResulta+ A Result that is representing state from a DBAPI cursor.
|
|
.. versionchanged:: 1.4 The :class:`.CursorResult``
|
class replaces the previous :class:`.ResultProxy` interface.
|
This classes are based on the :class:`.Result` calling API
|
which provides an updated usage model and calling facade for
|
SQLAlchemy Core and SQLAlchemy ORM.
|
|
Returns database rows via the :class:`.Row` class, which provides
|
additional API features and behaviors on top of the raw data returned by
|
the DBAPI. Through the use of filters such as the :meth:`.Result.scalars`
|
method, other kinds of objects may also be returned.
|
|
.. seealso::
|
|
:ref:`tutorial_selecting_data` - introductory material for accessing
|
:class:`_engine.CursorResult` and :class:`.Row` objects.
|
|
)r r² r r Ú_echor z.Union[CursorResultMetaData, _NoResultMetaData]r FrM Ú _soft_closedrÿ Tr) r r, r² rÜ r r( r rÝ )r r r c sô || _ |j| _|j| _|| _|j| _| jjo4|j ¡ | _}|d k rÚ| ||¡}t
|
t ||j |j¡|jrt t|j ¡fdd}|n|rÈ| j jjfdd | _ fdd}|}n}| d|¡ n|jdksèt| j| _d S ) Nc s | S rQ rU )Úraw_data)Ú _make_rowÚsentinel_filterrU rV Ú _sliced_row² s z*CursorResult.__init__.<locals>._sliced_rowc s dt | ¡ | S )NzRow %r)Úsql_utilZ _repr_row©r )ÚlogrU rV Ú_log_row¼ s z'CursorResult.__init__.<locals>._log_rowc s | S rQ rU r: )r< Ú
|
sliced_rowrU rV Ú _make_row_2Â s z*CursorResult.__init__.<locals>._make_row_2Z _row_getterr )r r² r r Zroot_connectionr r3 ZengineZ_should_log_debugÚ_init_metadataÚ functoolsÚpartialr Z_effective_processorsrK Z_num_sentinel_colsÚoperatorÚ
|
itemgetterÚsliceÚ
|
_log_debugZ_row_logging_fnZ_set_memoized_attributern Ú_no_result_metadatar ) rT r r r ZechoÚmetadatar8 r> Zmake_rowrU )r< r6 r; r7 r= rV r¥ s@ ÿ ü
|
ÿ
|
zCursorResult.__init__c C s¦ |j rp|j }|jr|j}nt| |}|jr0||_|j dd¡sh|jrh|j|jj krh|j
|
|j k rh| |¡}|| _ nt| | | _ }| jr¢|j dtdd |D ¡ |S )NZ _result_disable_adapt_to_contextFzCol %rc s s | ]}|d V qdS )r NrU )rZ rÉ rU rU rV r ú s z.CursorResult._init_metadata.<locals>.<genexpr>)r Z_cached_metadatarB rI r r r Z cache_hitr² Z CACHE_HITr r r r r3 r rE Útuple)rT r r r rG rU rU rV r? Î s<
|
ÿÿü û
|
ú
|
ÿ
|
ÿzCursorResult._init_metadatac C sl |s
|
| j s|r| jrdS |r4d| _| j | | j¡ n| j | | j¡ | j sh| j}d| _| j |¡ d| _ dS )a\ Soft close this :class:`_engine.CursorResult`.
|
|
This releases all DBAPI cursor resources, but leaves the
|
CursorResult "open" from a semantic perspective, meaning the
|
fetchXXX() methods will continue to return empty results.
|
|
This method is called automatically when:
|
|
* all result rows are exhausted using the fetchXXX() methods.
|
* cursor.description is None.
|
|
This method is **not public**, but is documented in order to clarify
|
the "autoclose" process used.
|
|
.. seealso::
|
|
:meth:`_engine.CursorResult.close`
|
|
|
NT)r4 rÿ r rè r rç r Z_safe_close_cursor)rT r r rU rU rV r þ s zCursorResult._soft_closec C sB | j jst d¡n&| j js(t d¡n| j jr:t d¡| j jS )aÌ Return the value of
|
:attr:`_engine.CursorResult.inserted_primary_key`
|
as a row contained within a list; some dialects may support a
|
multiple row form as well.
|
|
.. note:: As indicated below, in current SQLAlchemy versions this
|
accessor is only useful beyond what's already supplied by
|
:attr:`_engine.CursorResult.inserted_primary_key` when using the
|
:ref:`postgresql_psycopg2` dialect. Future versions hope to
|
generalize this feature to more dialects.
|
|
This accessor is added to support dialects that offer the feature
|
that is currently implemented by the :ref:`psycopg2_executemany_mode`
|
feature, currently **only the psycopg2 dialect**, which provides
|
for many rows to be INSERTed at once while still retaining the
|
behavior of being able to return server-generated primary key values.
|
|
* **When using the psycopg2 dialect, or other dialects that may support
|
"fast executemany" style inserts in upcoming releases** : When
|
invoking an INSERT statement while passing a list of rows as the
|
second argument to :meth:`_engine.Connection.execute`, this accessor
|
will then provide a list of rows, where each row contains the primary
|
key value for each row that was INSERTed.
|
|
* **When using all other dialects / backends that don't yet support
|
this feature**: This accessor is only useful for **single row INSERT
|
statements**, and returns the same information as that of the
|
:attr:`_engine.CursorResult.inserted_primary_key` within a
|
single-element list. When an INSERT statement is executed in
|
conjunction with a list of rows to be INSERTed, the list will contain
|
one row per row inserted in the statement, however it will contain
|
``None`` for any server-generated values.
|
|
Future releases of SQLAlchemy will further generalize the
|
"fast execution helper" feature of psycopg2 to suit other dialects,
|
thus allowing this accessor to be of more general use.
|
|
.. versionadded:: 1.4
|
|
.. seealso::
|
|
:attr:`_engine.CursorResult.inserted_primary_key`
|
|
ú1Statement is not a compiled expression construct.ú2Statement is not an insert() expression construct.z9Can't call inserted_primary_key when returning() is used.)r r r r¸ ÚisinsertZ_is_explicit_returningÚinserted_primary_key_rowsr[ rU rU rV rL # s .ÿÿÿz&CursorResult.inserted_primary_key_rowsc C s, | j jrt d¡| j}|r$|d S dS dS )a² Return the primary key for the row just inserted.
|
|
The return value is a :class:`_result.Row` object representing
|
a named tuple of primary key values in the order in which the
|
primary key columns are configured in the source
|
:class:`_schema.Table`.
|
|
.. versionchanged:: 1.4.8 - the
|
:attr:`_engine.CursorResult.inserted_primary_key`
|
value is now a named tuple via the :class:`_result.Row` class,
|
rather than a plain tuple.
|
|
This accessor only applies to single row :func:`_expression.insert`
|
constructs which did not explicitly specify
|
:meth:`_expression.Insert.returning`. Support for multirow inserts,
|
while not yet available for most backends, would be accessed using
|
the :attr:`_engine.CursorResult.inserted_primary_key_rows` accessor.
|
|
Note that primary key columns which specify a server_default clause, or
|
otherwise do not qualify as "autoincrement" columns (see the notes at
|
:class:`_schema.Column`), and were generated using the database-side
|
default, will appear in this list as ``None`` unless the backend
|
supports "returning" and the insert statement executed with the
|
"implicit returning" enabled.
|
|
Raises :class:`~sqlalchemy.exc.InvalidRequestError` if the executed
|
statement is not a compiled expression construct
|
or is not an insert() construct.
|
|
zuThis statement was an executemany call; if primary key returning is supported, please use .inserted_primary_key_rows.r N)r Ú executemanyr r¸ rL )rT ZikprU rU rV Úinserted_primary_keya s !ÿz!CursorResult.inserted_primary_keyc C sH | j jst d¡n0| j js(t d¡n | j jr8| j jS | j jd S dS )a Return the collection of updated parameters from this
|
execution.
|
|
Raises :class:`~sqlalchemy.exc.InvalidRequestError` if the executed
|
statement is not a compiled expression construct
|
or is not an update() construct.
|
|
rI z2Statement is not an update() expression construct.r N)r r r r¸ ÚisupdaterM Úcompiled_parametersr[ rU rU rV Úlast_updated_params s ÿÿz CursorResult.last_updated_paramsc C sH | j jst d¡n0| j js(t d¡n | j jr8| j jS | j jd S dS )a Return the collection of inserted parameters from this
|
execution.
|
|
Raises :class:`~sqlalchemy.exc.InvalidRequestError` if the executed
|
statement is not a compiled expression construct
|
or is not an insert() construct.
|
|
rI rJ r N)r r r r¸ rK rM rP r[ rU rU rV Úlast_inserted_params¥ s ÿÿz!CursorResult.last_inserted_paramsc C s | j jS )a Return a list of rows each containing the values of default
|
columns that were fetched using
|
the :meth:`.ValuesBase.return_defaults` feature.
|
|
The return value is a list of :class:`.Row` objects.
|
|
.. versionadded:: 1.4
|
|
)r Úreturned_default_rowsr[ rU rU rV Úreturned_defaults_rows» s z#CursorResult.returned_defaults_rowsc C sV | ¡ }dd tt| ¡ t| ¡ D }|j |j¡|_td|d|_| ¡ |S )aÌ Return a new :class:`.CursorResult` that "horizontally splices"
|
together the rows of this :class:`.CursorResult` with that of another
|
:class:`.CursorResult`.
|
|
.. tip:: This method is for the benefit of the SQLAlchemy ORM and is
|
not intended for general use.
|
|
"horizontally splices" means that for each row in the first and second
|
result sets, a new row that concatenates the two rows together is
|
produced, which then becomes the new row. The incoming
|
:class:`.CursorResult` must have the identical number of rows. It is
|
typically expected that the two result sets come from the same sort
|
order as well, as the result rows are spliced together based on their
|
position in the result.
|
|
The expected use case here is so that multiple INSERT..RETURNING
|
statements (which definitely need to be sorted) against different
|
tables can produce a single result that looks like a JOIN of those two
|
tables.
|
|
E.g.::
|
|
r1 = connection.execute(
|
users.insert().returning(
|
users.c.user_name,
|
users.c.user_id,
|
sort_by_parameter_order=True
|
),
|
user_values
|
)
|
|
r2 = connection.execute(
|
addresses.insert().returning(
|
addresses.c.address_id,
|
addresses.c.address,
|
addresses.c.user_id,
|
sort_by_parameter_order=True
|
),
|
address_values
|
)
|
|
rows = r1.splice_horizontally(r2).all()
|
assert (
|
rows ==
|
[
|
("john", 1, 1, "foo@bar.com", 1),
|
("jack", 2, 2, "bar@bat.com", 2),
|
]
|
)
|
|
.. versionadded:: 2.0
|
|
.. seealso::
|
|
:meth:`.CursorResult.splice_vertically`
|
|
|
c S s g | ]\}}t |t | qS rU )rH )rZ Zr1Zr2rU rU rV r\ s ÿz4CursorResult.splice_horizontally.<locals>.<listcomp>N©r ) Ú _generateÚzipr
Ú_raw_row_iteratorr r{ r+ r Ú_reset_memoizations©rT rr ÚcloneZ
|
total_rowsrU rU rV Úsplice_horizontallyÈ s <
|
|
þþþz CursorResult.splice_horizontallyc C s: | ¡ }t| ¡ t| ¡ }td|d|_| ¡ |S )aÍ Return a new :class:`.CursorResult` that "vertically splices",
|
i.e. "extends", the rows of this :class:`.CursorResult` with that of
|
another :class:`.CursorResult`.
|
|
.. tip:: This method is for the benefit of the SQLAlchemy ORM and is
|
not intended for general use.
|
|
"vertically splices" means the rows of the given result are appended to
|
the rows of this cursor result. The incoming :class:`.CursorResult`
|
must have rows that represent the identical list of columns in the
|
identical order as they are in this :class:`.CursorResult`.
|
|
.. versionadded:: 2.0
|
|
.. seealso::
|
|
:meth:`.CursorResult.splice_horizontally`
|
|
NrU )rV r
rX r+ r rY rZ rU rU rV Úsplice_vertically s ÿþz CursorResult.splice_verticallyc C sF | j r| jj dt|¡ tt| j ¡ | _t d|d| _
|
| ¡ | S )a rewind this result back to the given rowset.
|
|
this is used internally for the case where an :class:`.Insert`
|
construct combines the use of
|
:meth:`.Insert.return_defaults` along with the
|
"supplemental columns" feature.
|
|
z CursorResult rewound %d row(s)NrU ) r3 r r rE ro r rB r rq r+ r rY ©rT r rU rU rV Ú_rewind6 s
|
ÿ ÿ
|
ûzCursorResult._rewindc C s. | j jrt d¡| j j}|r&|d S dS dS )ax Return the values of default columns that were fetched using
|
the :meth:`.ValuesBase.return_defaults` feature.
|
|
The value is an instance of :class:`.Row`, or ``None``
|
if :meth:`.ValuesBase.return_defaults` was not used or if the
|
backend does not support RETURNING.
|
|
.. seealso::
|
|
:meth:`.ValuesBase.return_defaults`
|
|
zlThis statement was an executemany call; if return defaults is supported, please use .returned_defaults_rows.r N)r rM r r¸ rS r^ rU rU rV Úreturned_defaultsV s ÿz CursorResult.returned_defaultsc C s
|
| j ¡ S )zReturn ``lastrow_has_defaults()`` from the underlying
|
:class:`.ExecutionContext`.
|
|
See :class:`.ExecutionContext` for details.
|
|
)r Úlastrow_has_defaultsr[ rU rU rV ra q s z!CursorResult.lastrow_has_defaultsc C s6 | j jst d¡n| j js.| j js.t d¡| j jS )aM Return ``postfetch_cols()`` from the underlying
|
:class:`.ExecutionContext`.
|
|
See :class:`.ExecutionContext` for details.
|
|
Raises :class:`~sqlalchemy.exc.InvalidRequestError` if the executed
|
statement is not a compiled expression construct
|
or is not an insert() or update() construct.
|
|
rI ú>Statement is not an insert() or update() expression construct.)r r r r¸ rK rO Úpostfetch_colsr[ rU rU rV rc { s ÿÿzCursorResult.postfetch_colsc C s6 | j jst d¡n| j js.| j js.t d¡| j jS )aL Return ``prefetch_cols()`` from the underlying
|
:class:`.ExecutionContext`.
|
|
See :class:`.ExecutionContext` for details.
|
|
Raises :class:`~sqlalchemy.exc.InvalidRequestError` if the executed
|
statement is not a compiled expression construct
|
or is not an insert() or update() construct.
|
|
rI rb )r r r r¸ rK rO Ú prefetch_colsr[ rU rU rV rd s ÿÿzCursorResult.prefetch_colsc C s | j jS )zReturn ``supports_sane_rowcount`` from the dialect.
|
|
See :attr:`_engine.CursorResult.rowcount` for background.
|
|
)r² Úsupports_sane_rowcountr[ rU rU rV re © s z#CursorResult.supports_sane_rowcountc C s | j jS )zReturn ``supports_sane_multi_rowcount`` from the dialect.
|
|
See :attr:`_engine.CursorResult.rowcount` for background.
|
|
)r² Ú supports_sane_multi_rowcountr[ rU rU rV rf ² s z)CursorResult.supports_sane_multi_rowcountrÇ rX c
|
C sF z
|
| j jW S tk
|
r@ } z| j | | j|¡ W 5 d}~X Y nX dS )a~ Return the 'rowcount' for this result.
|
|
The 'rowcount' reports the number of rows *matched*
|
by the WHERE criterion of an UPDATE or DELETE statement.
|
|
.. note::
|
|
Notes regarding :attr:`_engine.CursorResult.rowcount`:
|
|
|
* This attribute returns the number of rows *matched*,
|
which is not necessarily the same as the number of rows
|
that were actually *modified* - an UPDATE statement, for example,
|
may have no net change on a given row if the SET values
|
given are the same as those present in the row already.
|
Such a row would be matched but not modified.
|
On backends that feature both styles, such as MySQL,
|
rowcount is configured by default to return the match
|
count in all cases.
|
|
* :attr:`_engine.CursorResult.rowcount`
|
is *only* useful in conjunction
|
with an UPDATE or DELETE statement. Contrary to what the Python
|
DBAPI says, it does *not* return the
|
number of rows available from the results of a SELECT statement
|
as DBAPIs cannot support this functionality when rows are
|
unbuffered.
|
|
* :attr:`_engine.CursorResult.rowcount`
|
may not be fully implemented by
|
all dialects. In particular, most DBAPIs do not support an
|
aggregate rowcount result from an executemany call.
|
The :meth:`_engine.CursorResult.supports_sane_rowcount` and
|
:meth:`_engine.CursorResult.supports_sane_multi_rowcount` methods
|
will report from the dialect if each usage is known to be
|
supported.
|
|
* Statements that use RETURNING may not return a correct
|
rowcount.
|
|
.. seealso::
|
|
:ref:`tutorial_update_delete_rowcount` - in the :ref:`unified_tutorial`
|
|
N)r Úrowcountrõ r rø r ©rT r rU rU rV rg » s
|
/
|
zCursorResult.rowcountc
|
C sF z | j ¡ W S tk
|
r@ } z| j | | j|¡ W 5 d}~X Y nX dS )a0 Return the 'lastrowid' accessor on the DBAPI cursor.
|
|
This is a DBAPI specific method and is only functional
|
for those backends which support it, for statements
|
where it is appropriate. It's behavior is not
|
consistent across backends.
|
|
Usage of this method is normally unnecessary when
|
using insert() expression constructs; the
|
:attr:`~CursorResult.inserted_primary_key` attribute provides a
|
tuple of primary key values for a newly inserted row,
|
regardless of database backend.
|
|
N)r Z get_lastrowidrõ r rø r rh rU rU rV Ú lastrowidð s zCursorResult.lastrowidc C s | j jS )aq True if this :class:`_engine.CursorResult` returns zero or more
|
rows.
|
|
I.e. if it is legal to call the methods
|
:meth:`_engine.CursorResult.fetchone`,
|
:meth:`_engine.CursorResult.fetchmany`
|
:meth:`_engine.CursorResult.fetchall`.
|
|
Overall, the value of :attr:`_engine.CursorResult.returns_rows` should
|
always be synonymous with whether or not the DBAPI cursor had a
|
``.description`` attribute, indicating the presence of result columns,
|
noting that a cursor that returns zero rows still has a
|
``.description`` if a row-returning statement was emitted.
|
|
This attribute should be True for all results that are against
|
SELECT statements, as well as for DML statements INSERT/UPDATE/DELETE
|
that use RETURNING. For INSERT/UPDATE/DELETE statements that were
|
not using RETURNING, the value will usually be False, however
|
there are some dialect-specific exceptions to this, such as when
|
using the MSSQL / pyodbc dialect a SELECT is emitted inline in
|
order to retrieve an inserted primary key value.
|
|
|
)r rN r[ rU rU rV rN s zCursorResult.returns_rowsc C s | j jS )al True if this :class:`_engine.CursorResult` is the result
|
of a executing an expression language compiled
|
:func:`_expression.insert` construct.
|
|
When True, this implies that the
|
:attr:`inserted_primary_key` attribute is accessible,
|
assuming the statement did not include
|
a user defined "returning" construct.
|
|
)r rK r[ rU rU rV Ú is_insert! s zCursorResult.is_insertc c s* | j j}|| | j}|d kr q&|V qd S rQ ©r rï r )rT rï r rU rU rV Ú_fetchiter_impl/ s
|
z CursorResult._fetchiter_implc C s | j | | j|¡S rQ rk )rT rè rU rU rV Ú_fetchone_impl8 s zCursorResult._fetchone_implc C s | j | | j¡S rQ )r rô r r[ rU rU rV Ú_fetchall_impl; s zCursorResult._fetchall_implNc C s | j | | j|¡S rQ )r ró r )rT rñ rU rU rV Ú_fetchmany_impl> s z CursorResult._fetchmany_implc C s | ¡ S rQ )rl r[ rU rU rV rX A s z CursorResult._raw_row_iteratorz Result[Any]zMergedResult[Any])ÚothersrP c s6 t j| }| jj}|r2tdd | f| D |_|S )Nc s s | ]}t d |jV qdS )r N)r rg )rZ râ rU rU rV r H s ÿz%CursorResult.merge.<locals>.<genexpr>)r# Úmerger Z _has_rowcountÚsumrg )rT rp Z merged_resultZsetup_rowcountsr$ rU rV rq D s þ
|
zCursorResult.merger c C s | j dd dS )aý Close this :class:`_engine.CursorResult`.
|
|
This closes out the underlying DBAPI cursor corresponding to the
|
statement execution, if one is still present. Note that the DBAPI
|
cursor is automatically released when the :class:`_engine.CursorResult`
|
exhausts all available rows. :meth:`_engine.CursorResult.close` is
|
generally an optional method except in the case when discarding a
|
:class:`_engine.CursorResult` that still has additional rows pending
|
for fetch.
|
|
After this method is called, it is no longer valid to call upon
|
the fetch methods, which will raise a :class:`.ResourceClosedError`
|
on subsequent use.
|
|
.. seealso::
|
|
:ref:`connections_toplevel`
|
|
Tr N)r r[ rU rU rV ÚcloseN s zCursorResult.closer' )rê rP c C s || _ | j | | j|¡ | S rQ )Z
|
_yield_perr rì r )rT rê rU rU rV rì d s zCursorResult.yield_per)F)F)N)-rÕ rÖ r× rØ rÙ rÚ Ú_NO_RESULT_METADATArF r4 rÿ Z
|
_is_cursorr¥ r? r r. rL rN rQ rR rT r\ r] r_ r` ra rc rd re rf r Zmemoized_propertyrg ri rN rj rl rm rn ro rX rq rs r rì r* rU rU r$ rV r2 g sb
|
>0
|
%
|
=
|
-
|
N
|
|
4
|
|
|
|
|
|
r2 )arØ Ú
|
__future__r r r@ rB Útypingr r r r r r r r
|
r r r r r r râ r r r r r r r r Ú r r Zsqlr r r9 Zsql.baser Z sql.compilerr r r! r" r# Z sql.type_apir$ r% Z util.typingr& r' Úbaser( rý r) Z
|
interfacesr* r+ r, r- r. r/ r0 r1 r2 r3 r4 r5 r7 rÚ r8 r9 r; r= r? rA rÇ rÏ Z_CursorKeyMapRecTyperL rÎ rB rÜ rù rþ r r Z_NO_CURSOR_DMLr Z_DEFAULT_FETCHr r+ r, rt r1 r2 Z ResultProxyrU rU rU rV Ú<module> sâ úÿ
|
úÿ > X 8%
|
