o )f@spdZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z dd lm Z dd lm Z dd lm Z d d l mZd dl mZd dl mZd dl mZd dl mZd dl mZd dlmZd dlmZd dlmZd dlmZd dlmZddl mZddl mZddlmZddlmZ ddl!m"Z"ddl!m#Z#ddl!m$Z$ddl!m%Z%dd l!m&Z&dd!l!m'Z'dd"l(m)Z)dd#l(m*Z*dd$l(m+Z+dd%l,m-Z-dd&l,m.Z.dd'l,m/Z/dd(lm0Z0dd)l1m2Z2e r7d d*l3m4Z4d d+l3m5Z5d d,l3m6Z6d d-l7m8Z8d d.l9m:Z:d d/l9m;Z;d d0l9mm?Z?dd3lm@Z@dd4lmAZAdd5lBmCZCe d6eDd7ZEe 8 8dmdndIdJZFe 8 8dmdodMdJZF N NdpdqdPdJZFe 8 QdrdsdVdWZGe 8 QdrdtdZdWZG N Qdudvd\dWZGd]d^ZHGd_d`d`eZIGdadbdbeIZJe*KdcddGdedfdfeIe.ZLe*KdcdgGdhdidieJe/ZMe*KdcdjGdkdldleJe-ZNdNS)wzoadditional 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.mapper Mapper[_O]mappingsxz _bulk_insert..cSsg|]\}}|qSrIrI)rTrUdict_rIrIrKrVycSg|]}|jqSrIrQrSrIrIrKrV{cSg|]}t|qSrIrQrTmrIrIrKrV}rYcs"g|] \}}|jvr||fqSrI) _pks_by_table)rTtablempr8rIrKrVs  Tr Fc g|] }|jdvr|jqSrkeyrTbr:rIrKrV rIc 3s4|]\}}}}}}}}d|||||fVqdSrHrI) rTrU state_dictparamsraconn value_params has_all_pkshas_all_defaults connectionr8rIrK s*  z_bulk_insert..c3s|] }d|fVqdSrHrIrTmappingrqrIrKrss)bulkr?r@include_bulk_keys) bookkeepingrArCcSrZrIre)rTprIrIrKrVr[cg|]}|qSrIrIrTrf)rXrIrKrVrY) base_mappersessionconnection_callableNotImplementedError_expand_compositesrr_sorted_tablesitemslen_get_embedded_bindparamsr_collect_insert_commands_emit_insert_statements _returning returns_rowssplice_horizontally_identity_class_identity_key_propstuplerf)r8r:r<r=r?r@rArCr|states return_resultmappers_to_runrxr` super_mapperextra_bp_namesrecordsr identity_clsidentity_propsrUrI)rrrXr8r:rKrLds            T Mapper[Any]update_changed_onlyuse_orm_update_stmtenable_check_rowcountcCrGrHrIr8r:r<r=rrrrIrIrK _bulk_update rOptional[dml.Update]_result.Result[Any]cCrGrHrIrrIrIrKrrOptional[_result.Result[Any]]c s.j}jjrjjhfdd|r.|r&fddDnddDn ddDt|jjrBtd| ||durVfdd| Dnd }|j D]/\} }  | rk| jvrlq]tjd| fd d Dd ||d } tj|d| | | d||dq]|durtSdS)NcsfddjDS)Ncs(i|]\}}|jvs|vr||qSrI)committed_staterTkv) search_keysrUrIrK s z7_bulk_update.._changed_dict..)rRr)r8rU)r)rUrK _changed_dict s z#_bulk_update.._changed_dictcsg|]}|qSrIrIrS)rr8rIrKrVrWz _bulk_update..cSrZrIrQrSrIrIrKrVr[cSr\rIrQr]rIrIrKrVrYzJconnection_callable / per-instance sharding not supported in bulk_update()crcrdrergrirIrKrV&rjrIc3s0|]}d|jr|jjndfVqdSrH)_version_id_proprfrtrqrIrKrs6s  z_bulk_update..T)rvrrwF)rxrr)r|_primary_key_propkeysrrfunionrr}r~rrrrrrisar_r_collect_update_commands_emit_update_statements_result null_result) r8r:r<r=rrrr|rr`rrrI)rrrr8r:rrKrs`         csV|jsdSt}fdd|D}|D]}||D]}|||qqdS)Ncsi|] }||qSrI))_populate_composite_bulk_save_mappings_fnr{composite_attrsrIrKr]s z&_expand_composites..) compositessetkeys intersection)r8r:composite_keys populatorsrurfrIrrKrWs  rc@steZdZUdZdZded<eddZeddZed d Z ed d Z ed dZ ddddZ eddZ dS) ORMDMLStateTNz&Optional[ORMFromStatementCompileState]from_statement_ctxc cstj}|D]r\}}ttj|}t|trGt||t d}|t ur:ttj||r5tjtj |t ddn|fVq||| ||EdHqd|jvre|j} t| d| d} ||| ||EdHq||sj|n tjtj |t ddfVqdS)N)defaultT)type_is_crudentity_namespace proxy_key)r'_get_crud_kv_pairsrexpectr DMLColumnRole isinstancestrr"rExpressionElementRoler!NullType_bulk_update_tuples _annotations) clsr8 statement kv_iteratorneeds_to_be_cacheablecore_get_crud_kv_pairsrrdesck_annoattrrIrIrK_get_orm_crud_kv_pairsjsV      z"ORMDMLState._get_orm_crud_kv_pairscs6jdr jst|Sfdd|DS)Nplugin_subjectc s&g|]}tj|dqS)F)rRrr8r)rT value_dictrrrrIrKrVsz8ORMDMLState._get_multi_crud_kv_pairs..)_propagate_attrsr8r'_get_multi_crud_kv_pairs)rrrrIrrKrs  z$ORMDMLState._get_multi_crud_kv_pairscCsD|sJd|jd}|r|jst|||St||j|||S)Nz0no test coverage for needs_to_be_cacheable=Falser)rr8r'rlistr)rrrrrrIrIrKrs"  zORMDMLState._get_crud_kv_pairscCs@|jjd}|j}|jr|j}n|jj}||j|j|j|jdS)N parententity)nametypeexprentityr`) r`rr8is_aliased_classrclass___name__r local_table)rrext_infor8 _label_namerIrIrKget_entity_descriptions z"ORMDMLState.get_entity_descriptioncs2ddddfddfdd|jDDS)NcSs|jddS)Nr)rget)crIrIrK _ent_for_colszCORMDMLState.get_returning_column_descriptions.._ent_for_colcSs0|dur|S|jdd}|s|St|j||S)Nr)rrgetattrr)rentrrIrIrK _attr_for_cols zDORMDMLState.get_returning_column_descriptions.._attr_for_colcs.g|]\}}|j|j|||j|jdqS))rrraliasedr)rfrrr)rTrr)rrIrKrVszAORMDMLState.get_returning_column_descriptions..csg|]}||fqSrIrIrTr)rrIrKrVs )_all_selected_columns)rrrI)rrrK!get_returning_column_descriptionss z-ORMDMLState.get_returning_column_descriptions)use_supplemental_colsc Cs|jrTt|j|dd}|jdi|j}|j|j}||_t|||_ }| || }d|_dd|j D}|sB| |j|rO|j|jd|i}|S|j|}|S)alestablish 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)_adapt_on_namesrIcSsg|]}|dur|qSrHrIrrIrIrKrVsz4ORMDMLState._setup_orm_returning..supplemental_cols)rrrC_execution_optionsoptions _with_optionsselect_statementrcreate_for_statementr!setup_dml_returning_compile_state _generateprimary_columnsextend primary_keyr? returning) selfcompilerorm_level_statementdml_level_statement dml_mapperrfsfsccols_to_returnrIrIrK_setup_orm_returnings8      z ORMDMLState._setup_orm_returningc CsT|j}|jj}|jr(|jjjs(|dtj} t|j|j ||| ||} t || S|S)N_sa_orm_load_options) rcompiled compile_statercompile_options_is_starrrdefault_load_optionsrr instances) rr}rrlrCbind_argumentsrexecution_contextr load_options querycontextrIrIrK_return_orm_returning9s(  z!ORMDMLState._return_orm_returning)r __module__ __qualname__is_dml_returningr__annotations__ classmethodrrrrrrrrIrIrIrKrfs"   7    ! Crc@seZdZGdddeZedddddd(ddZeddZeddZeddZ eddZ eddZ eddZ eddZ edd Zed!d"Zed#d$Zed%d&Zd'S))BulkUDCompileStatec@sreZdZUdZded<dZded<dZded<dZded <dZded <d Z ded <d Z ded<e Z d Z d Zd Zd S)z)BulkUDCompileState.default_update_optionsautor* _dml_strategyr,_synchronize_sessionFr>_can_use_returning_is_delete_using_is_update_fromT _autoflushNOptional[Mapper[Any]]_subject_mapper)rrrrrrrrrrrr(_resolved_values_eval_condition _matched_rows_identity_tokenrIrIrIrKdefault_update_options]s       r"F is_multitableis_update_fromis_delete_usingis_executemanydialectrr8rr$r>r%r&r'rEcCstrH)r)rr(r8r$r%r&r'rIrIrKcan_use_returningjs z$BulkUDCompileState.can_use_returningc Cstjdhd||j\}}||d<z|jd}Wn ty$Jdw|r3|j|d<|d|ji7}d |jjvr@|d d i7}n't |t s\|j d krQ|d d i7}n|j dkr[t dn |j d krg|d di7}|j} | dur| dvrwt d|j dkr| dkrt d|s|jr||j d kr|jd kr|||||||}n0|jdkr|||||||}n |jdkr|||||||}n|j dkr|jd kr|ddi7}||j|j|j|j |jd}|t|d|ifS)N_sa_orm_update_options> autoflush dml_strategyidentity_tokenr%r&synchronize_sessionclauserF0statement had 'orm' plugin but no plugin_subjectr8rrr core_onlyrormrvHCan't use "bulk" ORM insert strategy without passing separate parameters)revaluatefetchFzSValid strategies for session synchronization are 'auto', 'evaluate', 'fetch', Falser5zkThe 'fetch' synchronization strategy is not available for 'bulk' ORM updates (i.e. multiple parameter sets)r4r)r.r&r%r,r))rr"from_execution_optionsrrKeyErrorr8r`rrrrsa_excInvalidRequestErrorr ArgumentErrorr_do_pre_synchronize_auto_do_pre_synchronize_evaluate_do_pre_synchronize_fetch _annotaterrrr immutabledictr) rr}rrlrCr  is_pre_eventupdate_optionsrsyncrIrIrKorm_pre_session_execws                 z'BulkUDCompileState.orm_pre_session_execcCs|d}|jdkr%|jdkr|||||n"|jdkr$|||||n|jdkr9|jdkr7||||||S|||||||S)Nr*r2r4r5rv)rr_do_post_synchronize_evaluate_do_post_synchronize_fetch"_do_post_synchronize_bulk_evaluater)rr}rrlrCr rrArIrIrKorm_setup_cursor_results2     z*BulkUDCompileState.orm_setup_cursor_resultcs~d}jrjnddjf|vr#|tfdd|djfD7}jjdur0|jjf7}r=tfdd|D}|S)aApply 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. rINadditional_entity_criteriac3s*|]}|js |jur|VqdSrH)include_aliasesr_resolve_where_criteria)rTae)rrIrKrs0s z@BulkUDCompileState._adjust_for_extra_criteria..c3s|]}|VqdSrH)traverse)rTcrit)adapterrIrKrs<s)r_adapterr8r_single_table_criterion)rglobal_attributesr return_critrI)rNrrK_adjust_for_extra_criterias"  z-BulkUDCompileState._adjust_for_extra_criteriacs|j|jjur |Sdd|jjD|D]2}|jdurn*|j|jjur'qt|j|jj}dd||D}D] \}}|||<q=qfddt|jjDfdd|jjDfdd|DS) atranslate 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. cSsi|]}||qSrIrI)rTpkrIrIrKr[r[z@BulkUDCompileState._interpret_returning_rows..NcSsi|]\}}||qSrIrI)rTsuper_pksub_pkrIrIrKrdrWcsi|] \}}||qSrIrI)rTidxlpk)local_pk_to_base_pkrIrKrhscrzrIrI)rTbpk)lookuprIrKrVlsz@BulkUDCompileState._interpret_returning_rows..cs"g|] tfddDqS)c3|]}|VqdSrHrI)rTrWrowrIrKrsozJBulkUDCompileState._interpret_returning_rows...)r)rT)primary_key_convertr]rKrVos") rr|riterate_to_rootinheritsrR_table_to_equatedr enumerate)rr8rowsrat_to_e col_to_colrTsuper_rI)rYr[r`rK_interpret_returning_rows@s(     z,BulkUDCompileState._interpret_returning_rowsc s|j|j}fdd|D}|jdurfdd|D}g}|D]\}}}||} | dus5| tjurA||||| tjufq#|S)Ncs.g|]}|jr|js|||jfqSrI)r8rexpiredobjrRrSrbrIrKrVvs zGBulkUDCompileState._get_matched_objects_on_criteria..cs&g|]\}}}|jkr|||fqSrIr-)rTrkrUrXrlrIrKrV~s  T)rrr!r_EXPIRED_OBJECTappend) rrAreval_conditionraw_datarrkrUrXevaled_conditionrI)r-r8rK _get_matched_objects_on_criteriaqs0   z3BulkUDCompileState._get_matched_objects_on_criteriac Cs|j}|j}t|}d}|jr||j7}i}|jD] }|jr$||q|r/||||7}|r8|j |} | Sdd} | } | S)NrIcSsdSNTrI)rkrIrIrKrszJBulkUDCompileState._eval_condition_from_statement.._eval_condition) rrr_EvaluatorCompiler_where_criteriar_is_criteria_optionget_global_criteriarSprocess) rrArr8 target_clsevaluator_compilerrMrQoptrorrIrIrK_eval_condition_from_statements&     z1BulkUDCompileState._eval_condition_from_statementcCsTz|||}Wn tjyYnw||ddS|ddi7}|||||||S)asetup 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. r4)rrrr5)r|rUnevaluatableErrorr=)rr}rrlrCr rArorIrIrKr;s( z+BulkUDCompileState._do_pre_synchronize_autoc CsHz|||}Wntjy}ztd||d}~ww|d|iS)Nz{Could not evaluate current criteria in Python: "%s". Specify 'fetch' or False for the synchronize_session execution option.r)r|rr}r8r9) rr}rrlrCr rAroerrrIrIrKr<s" z/BulkUDCompileState._do_pre_synchronize_evaluatecCs2|jrgS|jr t|jS|jrt|jSgSrH) _multi_values_ordered_valuesr_valuesr)rr8rrIrIrK_get_resolved_valuess z'BulkUDCompileState._get_resolved_valuesc Cshg}|D]-\}}|r+t|tjr+z|j|}Wn tjy!Yqw||j|fqt d||S)NzCAttribute name not found, can't be synchronized back to objects: %r) rr ColumnElement_columntopropertyorm_excUnmappedColumnErrorrnrfr8r9)rr8resolved_valuesvaluesrrrrIrIrK_resolved_keys_as_propnames s z.BulkUDCompileState._resolved_keys_as_propnamesc spjtjjfj|j}|j|_dd fdd }|j|||||d} | } | dS) N orm_contextr/rErcst|jjdi|j}j|jjj|jd}dur&|kr%t dn |jr0|s0t d||r8t SdS)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 RETURNINGrI) r}get_bindr r)r(rrr'r8r9rr)rbindper_bind_resultr)rr8rArIrKskip_for_returning>s, zHBulkUDCompileState._do_pre_synchronize_fetch..skip_for_returning)rCr  _add_event)r r)rr/rEr) rr rselect_identity_token select_fromrrruexecutefetchall) rr}rrlrCr rA select_stmtrr matched_rowsrIrrKr=s* !z,BulkUDCompileState._do_pre_synchronize_fetchNr(rr8rr$r>r%r>r&r>r'r>rEr>)rrrr$r"rr)rCrGrSrirrr|r;r<rrr=rIrIrIrKr\s<  w + $ 0 &  /   rr2insertcsveZdZUGdddeZdZded<eddZed ddZ ed!fdd Z eddZ ddZ ddZ ZS)" BulkORMInsertc@sVeZdZUdZded<dZded<dZded<dZd ed <d Zded <dZ ded <dS)z$BulkORMInsert.default_insert_optionsrr*rFr> _render_nulls_return_defaultsNrrTr_populate_existing) rrrrrrrrrrrIrIrIrKdefault_insert_optionsps     rNzOptional[FromStatement]rc Cs tjdhd||j\}}||d<z|jd}Wn ty$Jdw|r3|j|d<|d|ji7}|sL|jd krA|d d i7}n|jd krKt d n |jd krW|d d i7}|jdkrh|sbt j }n| t j }|sq|j rq| |d|ji}|t| d|ifS)N_sa_orm_insert_options>r+r,r@populate_existingr/rFr0r8rrrr2rvr3rawr,)rrr6rrr7r8rr8r9r_orm_load_exec_optionsrrr>rr?) rr}rrlrCr r@insert_optionsrrIrIrKrCzsX          z"BulkORMInsert.orm_pre_session_execr}r0r dml.Insertrlr5rCr+r r.rmr3rE_result.Resultc Cs:|d|j}|jdvrtd|jdkr"|j||pi|d}|S|jdkrb|j} |jdur:| jr:t d| | dus@J|j dusGJt | t dt |trS|gn||j d |j|j||d }n|jd krr|j||pmi|d}ntt|js||S|jr|d tj} | d di7} |d | i}|||||||S)Nr)rrvr2rzHValid strategies for ORM insert strategy are 'raw', 'orm', 'bulk', 'autor)rCrvz`bulk INSERT with a 'post values' clause (typically upsert) not supported for multi-table mapper Iterable[Dict[str, Any]]F)r=r?r@rArCr2rrT)rrrr8r:rr_post_values_clause_multiple_persistence_tablesr9 _transactionrLrrrRrrAssertionErrorr>rrrrrr) rr}rrlrCr rmrrr8r rIrIrKorm_execute_statementsx           z#BulkORMInsert.orm_execute_statementc stttj||fi|}|dur|j }nd}|s|S|jd}|jdd}|dkr4|||S|dkr>| |||S)NTrr,rrvr2) rrsuperrstackrrr_setup_for_bulk_insert_setup_for_orm_insert)rrrkwrtoplevelr8r, __class__rIrKrs"    z"BulkORMInsert.create_for_statementcs ddfdd|DDS)NcSs&i|]\}}}|dur|jn||qSrHre)rTcolrrrIrIrKr0sz.c3s&|]\}}j|||fVqdSrH)rrrrbrIrKrs2s z;BulkORMInsert._resolved_keys_as_col_keys..)r)rr8resolved_value_dictrIrbrK_resolved_keys_as_col_keys.s  z(BulkORMInsert._resolved_keys_as_col_keyscCs0ttj|j}}|j||||dd}||_dS)NFrr)rrInsertrr)rrr8rrrIrIrKr7s z#BulkORMInsert._setup_for_orm_insertcsttj|j}}|j}|d|d}|}|_|jr,fdd|jD|_|j ||||dd}|j durE|j j j rEt d||_dS) zestablish 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(). _emit_insert_table_emit_insert_mapperc i|] \}}|jur||qSrIr`rTrvalemit_insert_tablerIrKrW  z8BulkORMInsert._setup_for_bulk_insert..TrNzCan't use RETURNING * with bulk ORM INSERT. Please use a different INSERT form, such as INSERT..VALUES or INSERT with a Core Connection)rrrrr_cloner`_dict_parametersrrrrrr8 CompileError)rrrranemit_insert_mapperrIrrKrCs2   z$BulkORMInsert._setup_for_bulk_insert)r}r0rrrlr5rCr+r r.rmr3rEr)rEr)rrrr$rrrrrCrrrrr __classcell__rIrIrrKrns   C X  rupdatecseZdZeddZddZddZed,fdd Zedddddd-d"d#Zed$d%Z ed&d'Z ed(d)Z ed*d+Z Z S). BulkORMUpdatecKs||}|jdd}|j }|r|dkr||||S|dks,|dkr9d|jjvr9tj|||fi||S|r?|dvrE||||S)Nr, unspecifiedrvr1r)r2r) __new__rrr_setup_for_bulk_updater`r'__init___setup_for_orm_update)rrrrrr,rrIrIrKrts      z"BulkORMUpdate.create_for_statementc Ks<|}|j }|jjd}|j|_}||||_|j||||d|jr+t|j|_| }|j r7|j|_ n|jr>|j|_| |j |} | rL|j | }tj|||fi|d} |s^d} n|jdd} |jdd} | dur~| dko}|j|j||jd} | dkr| rd} |j|jj}|r|j||||| d }||_dS) Nrrprocess_criteria_for_toplevelFr.r)r5)r$Tr)rr`rr8rr_init_global_attributesrrRrrrSrQwherer'rrr)r(r$r?rrr) rrrrrrrr8new_stmtnew_critrr.r)rIrIrKrsf         z#BulkORMUpdate._setup_for_orm_updatec sttj|}|j}|d|d}|}|_tj|||fi||jr,t d|j r<fdd|j D|_ ||_ dS)zestablish 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(). _emit_update_table_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().crrIrremit_update_tablerIrKrrz8BulkORMUpdate._setup_for_bulk_update..N)rrUpdaterrr`r'rrr8r9rrr)rrrrr_rIrrKrs"   z$BulkORMUpdate._setup_for_bulk_updater}r0r dml.Updaterlr5rCr+r r.rmr3rErc s|d|j}|jdvrtd|jdkr_|j }|jdks!J|jr.|jdkr.td|j} | dus7J|j dus>Jt | t dt |t rJ|gn||j d d ||d } ||||||| St||||||S) Nr*)r2rrvr1zOValid strategies for ORM UPDATE strategy are 'orm', 'auto', 'bulk', 'core_only'rvr5r4zbulk 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.rF)r=rrr)rr"rr8r:rurr9rrrrrrRrGrr) rr}rrlrCr rmrArr8rrrIrKrs^       z#BulkORMUpdate.orm_execute_statementFr#r(rr8rr$r>r%r&r'cCsL|jo|jj}|s dS|r|jS|r|jS|r$|js$td|jddS)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)update_returningrimplicit_returningupdate_executemany_returningupdate_returning_multifromr8rrrr(r8r$r%r&r' normal_answerrIrIrKr)Zs   zBulkORMUpdate.can_use_returningcs|sdS|j}dd|jD}|j}|D]X|fdd|D|j}||} | s,qt|} | j} | j | } | D] } | | vrJ| | | <q>| j j | d| | | t| | | | }|rl| | |qdS)NcSrZrIre)rTproprIrIrKrVr[zDBulkORMUpdate._do_post_synchronize_bulk_evaluate..c3r\rHrIr{paramrIrKrsr_zCBulkORMUpdate._do_post_synchronize_bulk_evaluate..)rr identity_mapidentity_key_from_primary_keyr!fast_get_stater differencerR unmodifiedrmanagerdispatchrefresh_commitr_expire_attributes)rr}rlrrAr8pk_keysr identity_keyrUevaluated_keysrX to_evaluaterf to_expirerIrrKrFs:     z0BulkORMUpdate._do_post_synchronize_bulk_evaluatecCs0|||j}||||dd|DdS)NcSsg|] \}}}}|||fqSrIrI)rTrkrUrXrrIrIrKrVsz?BulkORMUpdate._do_post_synchronize_evaluate..)rrr all_states#_apply_update_set_values_to_objects)rr}rrrAmatched_objectsrIrIrKrDs z+BulkORMUpdate._do_post_synchronize_evaluatec sj|j}|r||}fdd|D}nj}fddfdddd|DDD}|s5dS||dd|DdS)Ncg|] }t|jfqSrIrr!rTr^rArIrKrVz.cs g|] }|jvrj|qSrI)r)rTr)r}rIrKrVs   cs6g|]\}}jdus|jkrjt||dqS)Nrl)r!rr)rTrr-) target_mapperrArIrKrVs  cSs g|] }|dd|dfqS)rrIrrIrIrKrVscSs"g|] }|t|t|fqSrI)r instance_state instance_dict)rTrkrIrIrKrVs)rreturned_defaults_rowsrir r) rr}rrrArpk_rowsrobjsrI)r}rrArKrEs6   z(BulkORMUpdate._do_post_synchronize_fetchc Cs.|j}|j}t|}|||}|||} i} | D]\} } z |tt j | } Wn tj y5Yqw| | | <qt | }dd| D}t}|D]B\}}}|j|}|D]} | |vrh| | ||| <qZ|jj|d|||t ||||}|r|||||qM||dS)zeapply values to objects derived from an update statement, e.g. UPDATE..SET cSsh|]\}}|qSrIrIrrIrIrK rYzDBulkORMUpdate._apply_update_set_values_to_objects..N)rrrrtrrrxrrrrr}rrrrrrrrrrradd_register_altered)rr}rArrr8ryrzrresolved_keys_as_propnamesvalue_evaluatorsrfvalue _evaluatorrattribrrkrUrXrrrIrIrKrsB         z1BulkORMUpdate._apply_update_set_values_to_objects)r}r0rrrlr5rCr+r r.rmr3rErr)rrrrrrrrr)rFrDrErrrIrIrrKrrs* _$K$ *  3rdeletecs`eZdZeddZed$fdd Zedddddd%ddZed d!Zed"d#ZZ S)& BulkORMDeletecKsP||}|jdd}|dks|dkr'd|jjvr'tj|||fi||S|j }|}|jjd}|j|_} |j||||d| } | |j | } | rT| j | } tj|| |fi|d} |sfd} n|jdd} |jdd}|dur| d ko|j |j| |j|jd dd }|rd } | j| jj} |r|j||| | | d } | |_|S)Nr,rr1rrFr.r)r5r&)r$r&Tr)rrrr`r%rrr8rrrSrQrr)r(r$r?rrr)rrrrrr,rrrr8rrrr.r)rIrIrKr%sv      z"BulkORMDelete.create_for_statementr}r0r dml.Deleterlr5rCr+r r.rmr3rErcsL|d|j}|jdkrtd|jdvrtdt||||||S)Nr*rvzBulk ORM DELETE not supported right now. Statement may be invoked at the Core level using session.connection().execute(stmt, parameters))r2rr1zGValid strategies for ORM DELETE strategy are 'orm', 'auto', 'core_only')rr"rr8r9r:rr)rr}rrlrCr rmrArrIrKr~s    z#BulkORMDelete.orm_execute_statementFr#r(rr8rr$r>r%r&r'cCsB|jo|jj}|s dS|r|jS|r|jstd|jddS)NFrz" 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)delete_returningrrdelete_returning_multifromr8rrrrIrIrKr)s   zBulkORMDelete.can_use_returningc Cs^|||j}g}|D]\}}} } | r|| |jjq ||q |r-||dSdSrH)rrrr_expire _modifiedrn_remove_newly_deleted) rr}rrrAr to_deleterrUrXis_partially_expiredrIrIrKrDs z+BulkORMDelete._do_post_synchronize_evaluatec sj}|j}|r|||}fdd|D}nj}|D]&} | dd} | d} |jt| | d} | |jvrC|t |j| gqdS)NcrrIrrrrIrKrVrz.rrrl) rrrir rrrrr r) rr}rrrArrrrr^rr-rrIrrKrEs4   z(BulkORMDelete._do_post_synchronize_fetch)r}r0rr rlr5rCr+r r.rmr3rErr) rrrrrrr)rDrErrIrIrrKr #s X( r )..)r8r9r:r;r<r1r=r>r?r>r@r>rArBrCrDrErF)r8r9r:r;r<r1r=r>r?r>r@r>rArNrCrDrErO)NN)r8r9r:r;r<r1r=r>r?r>r@r>rArNrCrDrErP).T)r8rr:r;r<r1r=r>rr>rrBrr>rErF)r8rr:r;r<r1r=r>rr>rrrr>rErrs)r8rr:r;r<r1r=r>rr>rrrr>rEr)O__doc__ __future__rtypingrrrrrrr r r r rrrrrrbaserrrrrr8renginerrrsqlrrrrr r!sql.baser"r#r$sql.dmlr%r&r'r( util.typingr)_typingr*r+r,r8r-r}r.r/r0r1rUr2r3r4engine.interfacesr5objectr6rLrrrr plugin_forrrr rIrIrIrKs                                                        [w   3