U
|
¸ý°dÑ ã @ sÊ d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z dd lm
|
Z
|
dd
|
lm Z dd lm Z d d l mZ d dl mZ d dl mZ d dl mZ d dl mZ d dl mZ d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ ddl mZ ddl m Z ddl m Z ddl m Z dd l!m"Z" dd l!m#Z# dd l!m$Z$ dd l!m%Z% dd l!m&Z& 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 m0Z0 dd)l1m2Z2 e
|
rnd d*l3m4Z4 d d+l3m5Z5 d d,l3m6Z6 d d-l7m8Z8 d d.l9m:Z: d d/l9m;Z; d d0l9m<Z< d d1l9m=Z= d d2l>m?Z? dd3l m@Z@ dd4l mAZA dd5lBmCZC e d6eDd7ZEe dcd9d:d;d<d<d<d=d>d?d@ dAdBZFe ddd9d:d;d<d<d<dCd>dDd@ dEdBZFded9d:d;d<d<d<dCd>dGd@ dHdBZFe dfdJd:d;d<d<d=d<d?dKdLdMZGe dgdJd:d;d<d<dNd<dOdKdPdMZGdhdJd:d;d<d<dNd<dQdKdRdMZGdSdT ZHG dUdV dVeZIG dWdX dXeIZJe* KdYdZ¡G d[d\ d\eIe.ZLe* KdYd]¡G d^d_ d_eJe/ZMe* KdYd`¡G dadb dbeJe-ZNdFS )izoadditional ORM persistence classes related to "bulk" operations,
|
specifically outside of the flush() process.
|
|
é )Ú annotations)ÚAny)Úcast)ÚDict)ÚIterable)ÚOptional)Úoverload)Ú TYPE_CHECKING)ÚTypeVar)ÚUnioné )Ú
|
attributes)Úcontext)Ú evaluator)Úexc)Úloading)Ú persistence)ÚNO_VALUE)ÚAbstractORMCompileState)Ú FromStatement)Ú ORMFromStatementCompileState)Ú QueryContexté )Úutil)ÚDialect)Úresult)Ú coercions)Údml)Ú
|
expression)Úroles)Úselect)Úsqltypes)Ú_entity_namespace_key)Ú CompileState)ÚOptions)ÚDeleteDMLState)ÚInsertDMLState)ÚUpdateDMLState)Ú
|
EMPTY_DICT)ÚLiteral)ÚDMLStrategyArgument)ÚOrmExecuteOptionsParameter)ÚSynchronizeSessionArgument)ÚMapper)Ú_BindArguments)ÚORMExecuteState)ÚSession)ÚSessionTransaction)Ú InstanceState)Ú
|
Connection)Úcursor)Ú_CoreAnyExecuteParamsÚ_O)Úbound.z
|
Mapper[_O]z<Union[Iterable[InstanceState[_O]], Iterable[Dict[str, Any]]]r1 Úboolz Literal[None]z$Optional[OrmExecuteOptionsParameter]ÚNone) ÚmapperÚmappingsÚsession_transactionÚisstatesÚreturn_defaultsÚ render_nullsÚuse_orm_insert_stmtÚexecution_optionsÚreturnc C s d S ©N© ©r: r; r< r= r> r? r@ rA rD rD úVd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/orm/bulk_persistence.pyÚ _bulk_insertJ s rG zOptional[dml.Insert]zcursor.CursorResult[Any]c C s d S rC rD rE rD rD rF rG X s Nz"Optional[cursor.CursorResult[Any]]c sÒ j }|jjrtd|rL|r<dd D } dd | D qddd D ndd D t | |¡ d }
|
fdd|j ¡ D } |rd} nt| d kr¦d} nd
|
} | D ]´\} }|d k rÔfd d| ¡ D nd } fd dt
|
j | fddD d| ||dD }t
|
j |d || || ||d}|d k r®|j rB|
|
d krH|}
|
q®|jr®| sXt|
|
|¡}
|
q®|r²|r²j}dd jD }| D ]&\}|tfdd|D f|_q|d k rÎ|
|
d k sÊt|
|
S d S )NzJconnection_callable / per-instance sharding not supported in bulk_insert()c S s g | ]}||j fqS rD ©Údict©Ú.0ÚstaterD rD rF Ú
|
<listcomp>z s z _bulk_insert.<locals>.<listcomp>c S s g | ] \}}|qS rD rD )rK rL Údict_rD rD rF rM { s c S s g | ]
|
}|j qS rD rH rJ rD rD rF rM } s c S s g | ] }t |qS rD rH ©rK ÚmrD rD rF rM s c s" g | ]\}}| j kr||fqS rD )Ú _pks_by_table)rK ÚtableÚmp©r: rD rF rM s
|
þTr Fc s g | ]}|j d kr|j qS ©r ©Úkey©rK Úb©r; rD rF rM ¡ s þrD c 3 s2 | ]*\}}}}}}}}d || |||fV qd S rC rD ) rK rL Z
|
state_dictÚparamsrS ÚconnZ value_paramsZ has_all_pksZhas_all_defaults©Ú
|
connectionr: rD rF Ú <genexpr>ª s$ ïøz _bulk_insert.<locals>.<genexpr>c 3 s | ]}d | fV qd S rC rD ©rK Úmappingr] rD rF r_ À s )Úbulkr> r? Úinclude_bulk_keys)Ú bookkeepingr@ rA c S s g | ]
|
}|j qS rD rV )rK ÚprD rD rF rM Û s c s g | ] } | qS rD rD ©rK rW )rN rD rF rM ß s )Ú base_mapperÚsessionÚconnection_callableÚNotImplementedErrorÚ_expand_compositesr^ Ú_sorted_tablesÚitemsÚlenÚ_get_embedded_bindparamsr Z_collect_insert_commandsZ_emit_insert_statementsÚ
|
_returningZ returns_rowsÚAssertionErrorZsplice_horizontallyZ_identity_classÚ_identity_key_propsÚtuplerW )r: r; r< r= r> r? r@ rA rg ÚstatesZ return_resultZmappers_to_runrd rR Ú super_mapperÚextra_bp_namesÚrecordsr Z identity_clsZidentity_propsrL rD )r^ rN r: r; rF rG f s
|
ÿ
|
|
|
þ û þù
|
úì ø
|
|
þ
|
|
Tú Mapper[Any])r: r; r< r= Úupdate_changed_onlyÚuse_orm_update_stmtÚenable_check_rowcountrB c C s d S rC rD ©r: r; r< r= ry rz r{ rD rD rF Ú _bulk_updateç s
|
r} zOptional[dml.Update]z_result.Result[Any]c C s d S rC rD r| rD rD rF r} ô s
|
z Optional[_result.Result[Any]]c s0 j }jjr"jjh ¡fdd |r\|rL fddD qtdd D ndd D t |jjrtd| |¡|d k r¬fdd|
|
¡ D nd }|j ¡ D ]^\} }
|
|
|
¡rº| jkrØqºtjd | fd
|
d D d ||d } tj|d |
|
| | d||d qº|d k r,t ¡ S d S )Nc s fdd j ¡ D S )Nc s( i | ] \}}|j ks | kr||qS rD )Zcommitted_state©rK ÚkÚv)Ú search_keysrL rD rF Ú
|
<dictcomp> s
|
|
þ z7_bulk_update.<locals>._changed_dict.<locals>.<dictcomp>)rI rm )r: rL )r )rL rF Ú _changed_dict s þz#_bulk_update.<locals>._changed_dictc s g | ]} |qS rD rD rJ )r r: rD rF rM s z _bulk_update.<locals>.<listcomp>c S s g | ]
|
}|j qS rD rH rJ rD rD rF rM s c S s g | ] }t |qS rD rH rO rD rD rF rM s zJconnection_callable / per-instance sharding not supported in bulk_update()c s g | ]}|j d kr|j qS rU rV rX rZ rD rF rM + s þrD c 3 s. | ]&}d | j r |j j nd fV qd S rC )Ú_version_id_proprW r` r] rD rF r_ ; s öÿøz _bulk_update.<locals>.<genexpr>T)rb rz rc F)rd rz r{ )rg Z_primary_key_propkeysr rW Úunionrk rh ri rj r^ ro rl rm ÚisarQ r Z_collect_update_commandsZ_emit_update_statementsÚ_resultÚ null_result) r: r; r< r= ry rz r{ rg rv rR ru rw rD )r r^ r: r; r rF r} s^
|
ÿ
|
|
û þù
|
ôíø
|
c sV | j sd S t ¡ } fdd|D }|D ] }| |¡D ]}|| | q>q0d S )Nc s i | ]}| | ¡ qS rD )Z)_populate_composite_bulk_save_mappings_fnrf ©Zcomposite_attrsrD rF r b s ÿ z&_expand_composites.<locals>.<dictcomp>)Z
|
compositesÚsetÚkeysÚ intersection)r: r; Zcomposite_keysZ
|
populatorsra rW rD r rF rk \ s
|
þrk c @ st e Zd ZU dZdZded< edd Zedd Zed d
|
Z ed d Z
|
ed d Z ddddZ edd Z dS )Ú ORMDMLStateTNz&Optional[ORMFromStatementCompileState]Úfrom_statement_ctxc c sô t j}|D ]ä\}}t tj|¡}t|trt||t d}|t krrt tj|¡|rhtjtj
|
|t ¡ ddn|fV qî||| |¡|E d H q
|
d|jkrÈ|j} t| d | d }
|
|||
|
|¡|E d H q
|
||sÒ|ntjtj
|
|t ¡ ddfV q
|
d S )N)ÚdefaultT)Útype_Zis_crudZentity_namespaceÚ proxy_key)r' Ú_get_crud_kv_pairsr Úexpectr Z DMLColumnRoleÚ
|
isinstanceÚstrr" r ÚExpressionElementRoler! ZNullTypeZ_bulk_update_tuplesÚ _annotations) Úclsr: Ú statementÚ kv_iteratorÚneeds_to_be_cacheableZcore_get_crud_kv_pairsr r ÚdescZk_annoÚattrrD rD rF Ú_get_orm_crud_kv_pairso sT
|
úü÷ ý
|
ÿý ÿüüz"ORMDMLState._get_orm_crud_kv_pairsc s6 j d rjs t |¡S fdd|D S )NÚplugin_subjectc s& g | ] }t j| ¡ d ¡qS )F)rI r r: rm )rK Z
|
value_dict©r r r rD rF rM s û ÿÿz8ORMDMLState._get_multi_crud_kv_pairs.<locals>.<listcomp>)Ú_propagate_attrsr: r' Ú_get_multi_crud_kv_pairs)r r r rD r rF r¢ ¤ s
|
|
ÿúz$ORMDMLState._get_multi_crud_kv_pairsc C sD |s t d|jd }|r |js.t |||¡S t| |j|||¡S )Nz0no test coverage for needs_to_be_cacheable=Falser )rq r¡ r: r' r Úlistr )r r r r r rD rD rF r ¶ s& ÿþ
|
|
ÿüÿz ORMDMLState._get_crud_kv_pairsc C s@ |j jd }|j}|jr |j}n|jj}||j|j|j|jdS )NÚ parententity)ÚnameÚtypeÚexprÚentityrR ) rR r r: Úis_aliased_classr¥ Úclass_Ú__name__r¨ Ú local_table)r r Úext_infor: Z _label_namerD rD rF Úget_entity_descriptionÌ s ûz"ORMDMLState.get_entity_descriptionc s2 dd dd fddfdd|j D D S )Nc S s | j dd ¡S )Nr¤ )r Úget)ÚcrD rD rF Ú _ent_for_colß s zCORMDMLState.get_returning_column_descriptions.<locals>._ent_for_colc S s4 |d kr | S | j dd ¡}|s"| S t|j|| S d S )Nr )r r¯ Úgetattrr¨ )r° Úentr rD rD rF Ú _attr_for_colâ s zDORMDMLState.get_returning_column_descriptions.<locals>._attr_for_colc s. g | ]&\}}|j |j |||j|jd qS ))r¥ r¦ r§ Úaliasedr¨ )rW r¦ r© r¨ )rK r° r³ )r´ rD rF rM ë s úûzAORMDMLState.get_returning_column_descriptions.<locals>.<listcomp>c s g | ]}| |fqS rD rD ©rK r° )r± rD rF rM ó s )Z_all_selected_columns)r r rD )r´ r± rF Ú!get_returning_column_descriptionsÝ s
|
|
ÿøz-ORMDMLState.get_returning_column_descriptions)Úuse_supplemental_colsc C s |j rt|j |dd}|j|j }|| _t ||¡ | _}| |¡ | ¡ }d|_ dd |j
|
D }|sr| |j ¡ |r|j |j d|i}n
|
|j| }|S )al establish ORM column handlers for an INSERT, UPDATE, or DELETE
|
which uses explicit returning().
|
|
called within compilation level create_for_statement.
|
|
The _return_orm_returning() method then receives the Result
|
after the statement was executed, and applies ORM loading to the
|
state that we first established here.
|
|
F)Z_adapt_on_namesrD c S s g | ]}|d k r|qS rC rD r¶ rD rD rF rM s z4ORMDMLState._setup_orm_returning.<locals>.<listcomp>Zsupplemental_cols)rp r ÚoptionsÚ _with_optionsÚselect_statementr Úcreate_for_statementr Z!setup_dml_returning_compile_stateZ _generateZprimary_columnsÚextendÚ primary_keyr> Z returning) ÚselfÚcompilerÚorm_level_statementZdml_level_statementÚ
|
dml_mapperr¸ ÚfsZfscZcols_to_returnrD rD rF Ú_setup_orm_returningø s6 ý
|
þ
|
ô óÿz ORMDMLState._setup_orm_returningc C sN |j }|jj}|jrF| dtj¡} t|j|j||| ||}
|
t ||
|
¡S |S d S )NÚ_sa_orm_load_options)
|
r ZcompiledÚ compile_stater r¯ r Údefault_load_optionsr» r Z instances) r rh r r[ rA Úbind_argumentsr Zexecution_contextrÆ Ú load_optionsZ querycontextrD rD rF Ú_return_orm_returning; s$ ÿù z!ORMDMLState._return_orm_returning)r« Ú
|
__module__Ú __qualname__Zis_dml_returningr Ú__annotations__Ú classmethodr r¢ r r® r· rÄ rÊ rD rD rD rF r k s
|
|
4
|
|
|
|
!ù Cr c
|
@ sÊ e Zd ZG dd deZedddddddddddddd d
|
Zed d Zed d Zedd Z edd Z
|
edd Z edd Z edd Z edd Zedd Zed d Zed d Zd!S )"ÚBulkUDCompileStatec @ sr e Zd ZU dZded< dZded< dZded< dZded < dZded
|
< d Z ded < d Z
|
ded< e Z d Z d Zd Zd S )z)BulkUDCompileState.default_update_optionsÚautor* Ú _dml_strategyr, Ú_synchronize_sessionFr8 Ú_can_use_returningÚ_is_delete_usingÚ_is_update_fromTÚ
|
_autoflushNúOptional[Mapper[Any]]Ú_subject_mapper)r« rË rÌ rÑ rÍ rÒ rÓ rÔ rÕ rÖ rØ r( Ú_resolved_valuesÚ_eval_conditionÚ _matched_rowsÚ_identity_tokenrD rD rD rF Údefault_update_options] s
|
rÝ F©Ú is_multitableÚis_update_fromÚis_delete_usingÚis_executemanyr rx r8 ©Údialectr: rß rà rá râ rB c C s
|
t d S rC )rj )r rä r: rß rà rá râ rD rD rF Úcan_use_returningj s z$BulkUDCompileState.can_use_returningc
|
C sâ t j dddddddh||j¡\}}||d< z|jd }W n tk
|
rZ d
|
sVtd Y n X |j|d < |d |ji7 }t|t s¬|j
|
dkr|ddi7 }qÂ|j
|
dkrÂt d¡n|j
|
dkrÂ|ddi7 }|j } | d k rþ| dkrât d¡|j
|
dkrþ| dkrþt d¡|sÊ|jr| ¡ |j
|
dkr|j dkrB| ||||||¡}nB|j dkrd| ||||||¡}n |j dkrª| ||||||¡}n$|j
|
dkrª|j dkrª|ddi7 }| |j |j|j|j
|
|jd¡}|t |¡ d|i¡fS )NÚ_sa_orm_update_optionsÚsynchronize_sessionÚ autoflushÚidentity_tokenrá rà Ú dml_strategyÚclauser Fú0statement had 'orm' plugin but no plugin_subjectr: rØ rÐ rÑ Úormrb úHCan't use "bulk" ORM insert strategy without passing separate parameters)rÐ ÚevaluateÚfetchFzSValid strategies for session synchronization are 'auto', 'evaluate', 'fetch', Falserð zkThe 'fetch' synchronization strategy is not available for 'bulk' ORM updates (i.e. multiple parameter sets)rï rÒ )rç rá rà rê rå )rÏ rÝ Úfrom_execution_optionsÚ_execution_optionsr¡ ÚKeyErrorrq r: r r£ rÑ Úsa_excÚInvalidRequestErrorrÒ Ú ArgumentErrorrÖ Ú_do_pre_synchronize_autoÚ _do_pre_synchronize_evaluateÚ_do_pre_synchronize_fetchÚ _annotaterÔ rÕ rÓ r Ú immutabledictr
)
|
r rh r r[ rA rÈ Ú is_pre_eventÚupdate_optionsr ZsyncrD rD rF Úorm_pre_session_execw s° úõý
|
|
|
|
ÿ
|
ÿÿ ú ú ú ûÿ
|
ÿþz'BulkUDCompileState.orm_pre_session_execc C s |d }|j dkrJ|jdkr.| ||||¡ qr|jdkrr| ||||¡ n(|j dkrr|jdkrn| ||||¡ |S | ||||||¡S )Nræ rí rï rð rb )rÑ rÒ Ú _do_post_synchronize_evaluateÚ_do_post_synchronize_fetchÚ"_do_post_synchronize_bulk_evaluaterÊ )r rh r r[ rA rÈ r rý rD rD rF Úorm_setup_cursor_resultï sB
|
|
ÿ
|
ÿ
|
|
ÿúz*BulkUDCompileState.orm_setup_cursor_resultc s~ d}j rjnd djf|krF|tfdd|djf D 7 }jjdk r`|jjf7 } rzt fdd|D }|S )a Apply extra criteria filtering.
|
|
For all distinct single-table-inheritance mappers represented in the
|
table being updated or deleted, produce additional WHERE criteria such
|
that only the appropriate subtypes are selected from the total results.
|
|
Additionally, add WHERE criteria originating from LoaderCriteriaOptions
|
collected from the statement.
|
|
rD NZadditional_entity_criteriac 3 s( | ] }|j s|j kr| ¡V qd S rC )Zinclude_aliasesr¨ Z_resolve_where_criteria)rK Zae)r rD rF r_ 1 s
|
üz@BulkUDCompileState._adjust_for_extra_criteria.<locals>.<genexpr>c 3 s | ]} |¡V qd S rC )Ztraverse)rK Úcrit)ÚadapterrD rF r_ = s )r© Z_adapterr: rs Z_single_table_criterion)r Úglobal_attributesr Z return_critrD )r r rF Ú_adjust_for_extra_criteria s" þýÿþ
|
z-BulkUDCompileState._adjust_for_extra_criteriac sÖ |j |jj k r|S dd |j jD | ¡ D ]f}|jdkr@ qn|j |jj krPq,t|j|jj }dd || D } ¡ D ]\}}|| |< q|q, fddt|j jD fdd|jjD fdd|D S ) aÇ translate from local inherited table columns to base mapper
|
primary key columns.
|
|
Joined inheritance mappers always establish the primary key in terms of
|
the base table. When we UPDATE a sub-table, we can only get
|
RETURNING for the sub-table's columns.
|
|
Here, we create a lookup from the local sub table's primary key
|
columns to the base table PK columns so that we can get identity
|
key values from RETURNING that's against the joined inheritance
|
sub-table.
|
|
the complexity here is to support more than one level deep of
|
inheritance, where we have to link columns to each other across
|
the inheritance hierarchy.
|
|
c S s i | ]
|
}||qS rD rD )rK ÚpkrD rD rF r \ s z@BulkUDCompileState._interpret_returning_rows.<locals>.<dictcomp>Nc S s i | ]\}}||qS rD rD )rK Zsuper_pkZsub_pkrD rD rF r e s c s i | ]\}} | |qS rD rD )rK ÚidxZlpk)Úlocal_pk_to_base_pkrD rF r i s ÿ c s g | ] } | qS rD rD )rK Zbpk)ÚlookuprD rF rM m s z@BulkUDCompileState._interpret_returning_rows.<locals>.<listcomp>c s" g | ] t fd dD qS )c 3 s | ]} | V qd S rC rD )rK r ©ÚrowrD rF r_ p s zJBulkUDCompileState._interpret_returning_rows.<locals>.<listcomp>.<genexpr>)rs )rK )Úprimary_key_convertr rF rM p s ) r¬ rg r¾ Ziterate_to_rootZinheritsrI Z_table_to_equatedrm Ú enumerate)r r: ÚrowsrS Zt_to_eZ
|
col_to_colr Zsuper_rD )r r
|
r rF Ú_interpret_returning_rowsA s&
|
|
|
þ
|
ÿz,BulkUDCompileState._interpret_returning_rowsc
|
s |j |j}fdd|D }|j d k r> fdd|D }g }|D ]<\}}}||} | dksj| tjkrF| |||| tjkf¡ qF|S )Nc s. g | ]&}|j ¡r|js| ¡ ||jfqS rD )r: r ZexpiredÚobjrI rJ rT rD rF rM w s þzGBulkUDCompileState._get_matched_objects_on_criteria.<locals>.<listcomp>c s& g | ] \}}}|j kr|||fqS rD ©ré )rK r rL rN r rD rF rM s
|
þT)rØ rÚ rÜ r Z_EXPIRED_OBJECTÚappend)
|
r rý rt Úeval_conditionÚraw_datar r rL rN Zevaled_conditionrD )ré r: rF Ú _get_matched_objects_on_criteriar s2
|
þ
|
þÿþüÿz3BulkUDCompileState._get_matched_objects_on_criteriac C s~ |j }|j}t |¡}d}|jr*||j7 }i }|jD ]}|jr4| |¡ q4|r^|| ||¡7 }|rn|j | } n dd }
|
|
|
} | S )NrD c S s dS )NTrD )r rD rD rF rÚ ¯ s zJBulkUDCompileState._eval_condition_from_statement.<locals>._eval_condition)
|
rØ rª r Ú_EvaluatorCompilerÚ_where_criteriarº Z_is_criteria_optionZget_global_criteriar Úprocess) r rý r r: Ú
|
target_clsÚevaluator_compilerr r Úoptr rÚ rD rD rF Ú _eval_condition_from_statement s"
|
|
|
z1BulkUDCompileState._eval_condition_from_statementc C sV z| ||¡}W n tjk
|
r& Y nX ||dd S |ddi7 }| ||||||¡S )aÌ setup auto sync strategy
|
|
|
"auto" checks if we can use "evaluate" first, then falls back
|
to "fetch"
|
|
evaluate is vastly more efficient for the common case
|
where session is empty, only has a few objects, and the UPDATE
|
statement can potentially match thousands/millions of rows.
|
|
OTOH more complex criteria that fails to work with "evaluate"
|
we would hope usually correlates with fewer net rows.
|
|
rï )rÚ rÒ rÒ rð )r r ÚUnevaluatableErrorrù )r rh r r[ rA rÈ rý r rD rD rF r÷ ¶ s( ÿþ úz+BulkUDCompileState._do_pre_synchronize_autoc
|
C sR z| ||¡}W n4 tjk
|
rD } zt d| ¡|W 5 d }~X Y nX |d|i S )Nz{Could not evaluate current criteria in Python: "%s". Specify 'fetch' or False for the synchronize_session execution option.rÚ )r r r rô rõ ) r rh r r[ rA rÈ rý r ÚerrrD rD rF rø æ s" ÿþÿü ÿz/BulkUDCompileState._do_pre_synchronize_evaluatec C s6 |j r
|
g S |jrt|jS |jr.t|j ¡ S g S d S rC )Z _multi_valuesÚ_ordered_valuesr£ Ú_valuesrm )r r: r rD rD rF Ú_get_resolved_values s
|
z'BulkUDCompileState._get_resolved_valuesc C sl g }|D ]^\}}|rXt |tjrXz|j| }W n tjk
|
rD Y qfX | |j|f¡ qt d| ¡q|S )NzCAttribute name not found, can't be synchronized back to objects: %r)
|
r r Z ColumnElementZ_columntopropertyÚorm_excZUnmappedColumnErrorr rW rô rõ )r r: Úresolved_valuesÚvaluesr r r rD rD rF Ú_resolved_keys_as_propnames s ÿÿz.BulkUDCompileState._resolved_keys_as_propnamesc sv j tjjf ¡j|j }|j|_d ddd fdd }|j|||||d} | ¡ }
|
|
|
d S )Nr/ r )Ú orm_contextrB c sv | j jf | j}j|jjj| jd} d k rH |krbt d¡n| jr^|s^t d¡n| |rnt
|
¡ S d S d S )N)rà rá râ zjFor synchronize_session='fetch', can't mix multiple backends where some support RETURNING and others don'tzFor synchronize_session='fetch', can't use multiple parameter sets in ORM mode, which this backend does not support with RETURNING) rh Zget_bindrÈ rå rä rÕ rÔ râ rô rõ r r )r' ÚbindZper_bind_result©rå r r: rý rD rF Úskip_for_returning@ s* ûÿ
|
ÿzHBulkUDCompileState._do_pre_synchronize_fetch.<locals>.skip_for_returning)rA rÈ Z
|
_add_event)rÛ rÓ )
|
rØ r r¾ Zselect_identity_tokenÚ select_fromr¹ rº r ÚexecuteZfetchall) r rh r r[ rA rÈ rý Z select_stmtr* r Ú matched_rowsrD r) rF rù s,
|
ÿþÿ!ûþz,BulkUDCompileState._do_pre_synchronize_fetchN)r« rË rÌ r$ rÝ rÎ rå rþ r r r r r r÷ rø r" r& rù rD rD rD rF rÏ \ s: ø
|
w
|
,
|
$
|
0
|
&
|
|
/
|
|
|
|
rÏ rí Úinsertc s e Zd ZU G dd deZdZded< edd Zedd d
|
d d d ddddZ ed d fdd Z
|
edd Z dd Z dd Z ZS )Ú BulkORMInsertc @ sV e Zd ZU dZded< dZded< dZded< dZd ed
|
< d Zded < dZ ded < dS )z$BulkORMInsert.default_insert_optionsrÐ r* rÑ Fr8 Ú _render_nullsÚ_return_defaultsNr× rØ TrÖ Ú_populate_existing)
|
r« rË rÌ rÑ rÍ r0 r1 rØ rÖ r2 rD rD rD rF Údefault_insert_optionsr s
|
r3 NzOptional[FromStatement]r» c C s t j ddddh||j¡\}}||d< z|jd }W n tk
|
rT dsPtdY n X |j|d < |d
|
|ji7 }|s |jd kr|d d i7 }q¶|jdkr¶t
|
d¡n|jd kr¶|d di7 }|jdkrØ|sÌt j }n | t j ¡}|sê|jrê| ¡ | d|ji¡}|t |¡ d|i¡fS )NÚ_sa_orm_insert_optionsrê rè Zpopulate_existingrë r Frì r: rØ rÐ rÑ rí rb rî Úraw)r/ r3 rñ rò r¡ ró rq r: rÑ rô rõ r Z_orm_load_exec_optionsr
rÖ rú r rû ) r rh r r[ rA rÈ rü Úinsert_optionsr rD rD rF rþ | sR üý
|
|
|
ÿ
|
|
ÿ
|
ÿ
|
ÿþz"BulkORMInsert.orm_pre_session_execr0 z
|
dml.Insertr5 r+ r. r3 ú_result.Result©rh r r[ rA rÈ r\ rB c
|
C s< | d| j¡}|jdkr"t d¡|jdkrD|j||p8i |d}|S |jdkrÄ|j} |jd k rt| jrtt d| ¡| d k st
|
|j d k st
|
t | t dt|tr¦|gn||j d |j|j||d
|
}n&|jd krä|j||pÚi |d}nt
|
t|jsø|S |jr(| d tj¡}
|
|
|
d di7 }
|
| d |
|
i¡}| ||||||¡S )Nr4 )r5 rb rí rÐ zHValid strategies for ORM insert strategy are 'raw', 'orm', 'bulk', 'autor5 )rA rb z`bulk INSERT with a 'post values' clause (typically upsert) not supported for multi-table mapper úIterable[Dict[str, Any]]F)r= r> r? r@ rA rí rÅ r2 T)r¯ r3 rÑ rô rö r, rØ Z_post_values_clauseZ _multiple_persistence_tablesrõ rq Ú _transactionrG r r rI r1 r0 r8 rp r2 r rÇ r
rÊ ) r rh r r[ rA rÈ r\ r6 r r: rÉ rD rD rF Úorm_execute_statementÁ s ÿ
|
ÿ
|
ÿ
|
ÿþÿ þõ
|
ÿ
|
ÿ ÿúz#BulkORMInsert.orm_execute_statement)rB c sz t tt j||f|}|d k r*|j }nd}|s6|S |jd }|j dd¡}|dkrb| |¡ n|dkrv| ||¡ |S )NTr rê r5 rb rí )
|
r r/ Úsuperr¼ Ústackr¡ r r¯ Ú_setup_for_bulk_insertÚ_setup_for_orm_insert)r r rÀ Úkwr¿ Útoplevelr: rê ©Ú __class__rD rF r¼ s þ
|
|
z"BulkORMInsert.create_for_statementc s dd fdd| ¡ D D S )Nc S s& i | ] \}}}|d k r |j n||qS rC rV )rK Úcolr r rD rD rF r 5 s ÿ z<BulkORMInsert._resolved_keys_as_col_keys.<locals>.<dictcomp>c 3 s$ | ] \}} j |¡||fV qd S rC )r° r¯ r~ rT rD rF r_ 7 s z;BulkORMInsert._resolved_keys_as_col_keys.<locals>.<genexpr>)rm )r r: Zresolved_value_dictrD rT rF Ú_resolved_keys_as_col_keys3 s
|
|
ÿþz(BulkORMInsert._resolved_keys_as_col_keysc C s0 t tj| j }}| j||||dd}|| _d S )NF©r r¸ )r r ÚInsertr rÄ )r¿ rÀ r: r rÁ rD rD rF r? < s ûz#BulkORMInsert._setup_for_orm_insertc sv t tj| j }}|j}|d |d }| ¡ } |_| jrX fdd| j ¡ D | _| j ||||dd}|| _dS )zÑestablish an INSERT statement within the context of
|
bulk insert.
|
|
This method will be within the "conn.execute()" call that is invoked
|
by persistence._emit_insert_statement().
|
|
Z_emit_insert_tableZ_emit_insert_mapperc s i | ]\}}|j kr||qS rD ©rR ©rK rD Úval©Zemit_insert_tablerD rF r \ s
|
þ z8BulkORMInsert._setup_for_bulk_insert.<locals>.<dictcomp>TrF N)
|
r r rG r r Ú_clonerR Ú_dict_parametersrm rÄ )r¿ rÀ r rÁ ÚanZemit_insert_mapperrD rK rF r> H s& þ
|
þûz$BulkORMInsert._setup_for_bulk_insert)r« rË rÌ r$ r3 r» rÍ rÎ rþ r; r¼ rE r? r> Ú __classcell__rD rD rB rF r/ p s
|
|
D Y
|
r/ Úupdatec
|
s¨ e Zd Zedd Zdd Zdd Zeddd d
|
d d d d fdd ZedddddddddddddddZedd Z edd Z
|
ed d Z ed d Z Z S )!Ú BulkORMUpdatec K sF | | ¡}|j dd¡}|dkr.| ||¡ n|dkrB| ||¡ |S )Nrê Ú unspecifiedrb )rí rR )Ú__new__r r¯ Ú_setup_for_bulk_updateÚ_setup_for_orm_update)r r rÀ r@ r¿ rê rD rD rF r¼ o s
|
ÿ z"BulkORMUpdate.create_for_statementc K s2 |}|j jd }|j | _}| ||¡| _| j||ddd |jrNt| j| _| ¡ }|j |_ |j
|
rn| j|_
|
n|jr|| j|_| | j |¡}|r|j | }tj| ||f| d} |j dd ¡}
|
|j dd ¡} | dk rî|
|
dkoì| j|j|| jd} |
|
dkr| rd} |jt|j j }| j||||| d }|| _d S )
|
Nr¤ T©rA Z process_criteria_for_toplevelFrç rå rð )rß rF )rR r r: r" rÙ Ú_init_global_attributesr! rI rL r¬ r r r Úwherer' Ú__init__r¯ rå rä rß r> r£ r¾ rÄ r ) r¿ r rÀ r@ rÁ r r: Únew_stmtÚnew_critr¸ rç rå rD rD rF rU sn ü
|
ÿ
|
ÿ ÿ ÿþ
|
ÿûz#BulkORMUpdate._setup_for_orm_updatec s~ t tj|}|j}|d |d }| ¡ } |_tj| ||f| | jrTt
|
d¡| j rt fdd| j ¡ D | _ || _ dS )zÑestablish an UPDATE statement within the context of
|
bulk insert.
|
|
This method will be within the "conn.execute()" call that is invoked
|
by persistence._emit_update_statement().
|
|
Z_emit_update_tableZ_emit_update_mapperzbulk ORM UPDATE does not support ordered_values() for custom UPDATE statements with bulk parameter sets. Use a non-bulk UPDATE statement or use values().c s i | ]\}}|j kr||qS rD rH rI ©Zemit_update_tablerD rF r ø s
|
þ z8BulkORMUpdate._setup_for_bulk_update.<locals>.<dictcomp>N)r r ZUpdater rL rR r' rY r rô rõ rM rm r )r¿ r rÀ r@ rN Ú_rD r\ rF rT Û s" þÿ
|
þz$BulkORMUpdate._setup_for_bulk_updater0 z
|
dml.Updater5 r+ r. r3 r7 r8 c sØ | d| j¡}|jdkr"t d¡|jdkr¾|j }|jdksBt|jr\|jdkr\t d¡|j } | d k snt|j
|
d k s|tt | t dt |tr|gn||j
|
d d ||d
|
}
|
| ||||||
|
¡S t ||||||¡S d S ) Nræ )rí rÐ rb zBValid strategies for ORM UPDATE strategy are 'orm', 'auto', 'bulk'rb rð rï zÑbulk synchronize of persistent objects not supported when using bulk update with additional WHERE criteria right now. add synchronize_session=None execution option to bypass synchronize of persistent objects.r9 F)r= ry rz r{ )r¯ rÝ rÑ rô rö r rÒ rq rõ rØ r: r} r r rI r r< r; ) r rh r r[ rA rÈ r\ rý r{ r: r rB rD rF r; ÿ sb ÿ
|
ÿ
|
ÿþÿ þö ú úz#BulkORMUpdate.orm_execute_statementFrÞ r rx r8 rã c C sL |j o |jj}|sdS |r |jS |r*|jS |rH|jsHt d|j d¡dS )NFú Dialect "zæ" does not support RETURNING with UPDATE..FROM; for synchronize_session='fetch', please add the additional execution option 'is_update_from=True' to the statement to indicate that a separate SELECT should be used for this backend.T)Zupdate_returningr¬ Úimplicit_returningZ update_executemany_returningZupdate_returning_multifromrô Ú CompileErrorr¥ ©r rä r: rß rà rá râ Z normal_answerrD rD rF rå G s ÿ
|
ÿz BulkORMUpdate.can_use_returningc sÞ |sd S |j }dd |jD }|j}|D ]° | fdd|D |j¡}| |¡} | sXq(t |¡}
|
| j} | j
|
|
|
¡} | D ]} | | kr| | | | < q|| j j | d | ¡ | | t| ¡ |
|
|
| ¡ | ¡}|r(| | |¡ q(d S )Nc S s g | ]
|
}|j qS rD rV )rK ÚproprD rD rF rM u s zDBulkORMUpdate._do_post_synchronize_bulk_evaluate.<locals>.<listcomp>c 3 s | ]} | V qd S rC rD rf ©ÚparamrD rF r_ { s zCBulkORMUpdate._do_post_synchronize_bulk_evaluate.<locals>.<genexpr>)rØ rr Ú identity_mapÚ identity_key_from_primary_keyrÜ Zfast_get_stater Ú
|
differencerI Ú
|
unmodifiedr ÚmanagerÚdispatchÚrefreshÚ_commitr£ Ú_expire_attributes)r rh r[ r rý r: Zpk_keysre Ú identity_keyrL Úevaluated_keysrN Ú to_evaluaterW Ú to_expirerD rc rF r m s4 þ
|
|
ÿz0BulkORMUpdate._do_post_synchronize_bulk_evaluatec C s0 | ||j ¡ ¡}| |||dd |D ¡ d S )Nc S s g | ]\}}}}|||fqS rD rD )rK r rL rN r] rD rD rF rM ¦ s
|
z?BulkORMUpdate._do_post_synchronize_evaluate.<locals>.<listcomp>)r re Ú
|
all_statesÚ#_apply_update_set_values_to_objects)r rh r r rý Úmatched_objectsrD rD rF rÿ s þ üz+BulkORMUpdate._do_post_synchronize_evaluatec s j |j}|r0| |¡}fdd|D }nj} fddfdddd |D D D }|sjd S | |dd |D ¡ d S )Nc s g | ]}t | jf qS rD ©rs rÜ ©rK r ©rý rD rF rM µ s ÿz<BulkORMUpdate._do_post_synchronize_fetch.<locals>.<listcomp>c s g | ]}| j kr j | qS rD )re )rK rn )rh rD rF rM ¼ s
|
ôc s6 g | ].\}}j d ks |j kr jt||dqS )Nr )rÜ rf r£ )rK r¾ ré )Ú target_mapperrý rD rF rM ¾ s
|
|
øþc S s g | ]}|d d
|d fqS )r éÿÿÿÿrD rv rD rD rF rM Ã s c S s" g | ]}|t |¡t |¡fqS rD )r Úinstance_stateÚ instance_dict)rK r rD rD rF rM Ó s
|
üý)rØ Úreturned_defaults_rowsr rÛ rs ) r rh r r rý r| Úpk_rowsr- ÚobjsrD )rh rx rý rF r © s8 ÿ
|
þ
|
ÿûþúüz(BulkORMUpdate._do_post_synchronize_fetchc C s2 |j }|j}t |¡}| ||¡}| ||¡} i }
|
| D ]@\} } z| t t j
|
| ¡¡} W n tj k
|
rl Y q6X | |
|
| < q6t |
|
¡ }dd | D }t }|D ]\}}}|j |¡}|D ] } | |kr¶|
|
| ||| < q¶|jj |d|¡ | |t |¡ | |¡ |¡}|r| ||¡ | |¡ q| |¡ dS )zeapply values to objects derived from an update statement, e.g.
|
UPDATE..SET <values>
|
|
c S s h | ] \}}|qS rD rD r~ rD rD rF Ú <setcomp>ø s zDBulkORMUpdate._apply_update_set_values_to_objects.<locals>.<setcomp>N)rØ rª r r r" r& r r r r r r r£ r r rh r ri rj rk rl rg rm ÚaddZ_register_altered)r rh rý r rt r: r r r$ Zresolved_keys_as_propnamesZvalue_evaluatorsrW ÚvalueZ
|
_evaluatorro Úattribrt r rL rN rp rq rD rD rF rs Ý s@
|
ÿ ÿ
|
z1BulkORMUpdate._apply_update_set_values_to_objects)r« rË rÌ rÎ r¼ rU rT r; rå r rÿ r rs rO rD rD rB rF rQ m s(
|
\$ Gø %
|
*
|
|
3rQ Údeletec
|
s e Zd Zedd Zeddddddd d
|
fd d Zed d d d dddddddddddZedd Zedd Z Z S )Ú BulkORMDeletec K sú | | ¡}|}|jjd }|j |_}|j||ddd | ¡ }|j|_| |j|¡} | rd|j | }t
|
j |||f| d}
|
|j dd ¡} |j dd ¡} | dk rÆ| dkoÄ|j |j||j|j dd¡d } | rÜd}
|
|j|jj }|j|||||
|
d
|
}||_|S ) Nr¤ TrV Frç rå rð rá )rß rá rF )rS rR r r: rW rL r¬ r r rX r% rY r¯ rå rä rß r> r¾ rÄ r ) r r rÀ r@ r¿ rÁ r r: rZ r[ r¸ rç rå rD rD rF r¼ sh
|
ü ÿ
|
ÿ ÿ ÿüþ ûz"BulkORMDelete.create_for_statementr0 z
|
dml.Deleter5 r+ r. r3 r7 r8 c sL | d| j¡}|jdkr"t d¡|jdkr6t d¡t ||||||¡S )Nræ rb zBulk ORM DELETE not supported right now. Statement may be invoked at the Core level using session.connection().execute(stmt, parameters))rí rÐ z:Valid strategies for ORM DELETE strategy are 'orm', 'auto')r¯ rÝ rÑ rô rõ rö r< r; )r rh r r[ rA rÈ r\ rý rB rD rF r; ] s( ÿ
|
ÿ
|
ÿ ÿz#BulkORMDelete.orm_execute_statementFrÞ r rx r8 rã c C sB |j o |jj}|sdS |r |jS |r>|js>t d|j d¡dS )NFr^ zè" does not support RETURNING with DELETE..USING; for synchronize_session='fetch', please add the additional execution option 'is_delete_using=True' to the statement to indicate that a separate SELECT should be used for this backend.T)Zdelete_returningr¬ r_ Zdelete_returning_multifromrô r` r¥ ra rD rD rF rå s ÿ
|
ÿz BulkORMDelete.can_use_returningc C sZ | ||j ¡ ¡}g }|D ],\}}} }
|
|
|
r<| | |jj¡ q| |¡ q|rV| |¡ d S rC )r re rr Z_expireZ _modifiedr Ú_remove_newly_deleted) r rh r r rý rt Z to_deleter] rL rN Zis_partially_expiredrD rD rF rÿ ª s þ z+BulkORMDelete._do_post_synchronize_evaluatec s j }|j}|r0| ||¡} fdd|D }n j}|D ]L} | dd
}
|
| d } |jt|
|
| d} | |jkr:| t |j| ¡g¡ q:d S )Nc s g | ]}t | jf qS rD ru rv rw rD rF rM Ë s ÿz<BulkORMDelete._do_post_synchronize_fetch.<locals>.<listcomp>r ry r )
|
rØ r| r rÛ rf r£ re r
r rz ) r rh r r rý rx r| r} r- r r¾ ré rn rD rw rF r ¾ s2 ÿ
|
þ þ
|
ÿÿÿz(BulkORMDelete._do_post_synchronize_fetch)
|
r« rË rÌ rÎ r¼ r; rå rÿ r rO rD rD rB rF r s
|
G "ø )
|
r )..)..)NN).T).T)NT)OÚ__doc__Ú
|
__future__r Útypingr r r r r r r r
|
r Ú r r r r r# r r Úbaser r r r r rô r Zenginer r r Zsqlr r r r r r! Zsql.baser" r# r$ Zsql.dmlr% r& r' r( Z util.typingr) Ú_typingr* r+ r, r: r- rh r. r/ r0 r1 rL r2 r3 r4 Zengine.interfacesr5 Úobjectr6 rG r} rk r rÏ Z
|
plugin_forr/ rQ r rD rD rD rF Ú<module>
|
s¼ ø" ø" ø ù ù ù [ r
|
}
|
(
|
|
