o E6dl@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]mappingszz _bulk_insert..cSsg|]\}}|qSrIrI)rTrUdict_rIrIrKrV{cSg|]}|jqSrIrQrSrIrIrKrV}cSg|]}t|qSrIrQrTmrIrIrKrVrYcs"g|] \}}|jvr||fqSrI) _pks_by_table)rTtablempr8rIrKrVs  Tr Fc g|] }|jdvr|jqSrkeyrTbr:rIrKrV rIc 3s4|]\}}}}}}}}d|||||fVqdSrHrI) rTrUZ state_dictparamsraconnZ value_paramsZ has_all_pksZhas_all_defaults connectionr8rIrK s*  z_bulk_insert..c3s|] }d|fVqdSrHrIrTmappingrmrIrKros)bulkr?r@include_bulk_keys) bookkeepingrArCcSrZrIre)rTprIrIrKrVr[cg|]}|qSrIrIrTrf)rXrIrKrVrY) base_mappersessionconnection_callableNotImplementedError_expand_compositesrn_sorted_tablesitemslen_get_embedded_bindparamsrZ_collect_insert_commandsZ_emit_insert_statements _returningZ returns_rowsZsplice_horizontallyZ_identity_class_identity_key_propstuplerf)r8r:r<r=r?r@rArCrxstatesZ return_resultZmappers_to_runrtr` super_mapperextra_bp_namesrecordsrZ identity_clsZidentity_propsrUrI)rnrXr8r:rKrLfs            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)Zcommitted_staterTkv) search_keysrUrIrK s z7_bulk_update.._changed_dict..)rRr~)r8rU)r)rUrK _changed_dicts 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_proprfrprmrIrKro:s  z_bulk_update..T)rrrrsF)rtrr)rxZ_primary_key_propkeysrrfunionr|ryrzr{rnrr}r~isar_rZ_collect_update_commandsZ_emit_update_statements_result null_result) r8r:r<r=rrrrxrr`rrrI)rrnr8r:rrKrs`         csV|jsdSt}fdd|D}|D]}||D]}|||qqdS)Ncsi|] }||qSrI)Z)_populate_composite_bulk_save_mappings_fnrwZcomposite_attrsrIrKras z&_expand_composites..)Z compositessetkeys intersection)r8r:Zcomposite_keysZ populatorsrqrfrIrrKr|[s  r|c@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_Zis_crudZentity_namespace proxy_key)r'_get_crud_kv_pairsrexpectrZ DMLColumnRole isinstancestrr"rExpressionElementRoler!ZNullTypeZ_bulk_update_tuples _annotations) clsr8 statement kv_iteratorneeds_to_be_cacheableZcore_get_crud_kv_pairsrrdescZk_annoattrrIrIrK_get_orm_crud_kv_pairsnsV       z"ORMDMLState._get_orm_crud_kv_pairscs6jdr jst|Sfdd|DS)Nplugin_subjectc s&g|]}tj|dqS)F)rRrr8r~)rTZ 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_infor8Z _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 )Z_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)Z_adapt_on_namesrIcSsg|]}|dur|qSrHrIrrIrIrKrVsz4ORMDMLState._setup_orm_returning..Zsupplemental_cols)rrrC_execution_optionsoptions _with_optionsselect_statementrcreate_for_statementrZ!setup_dml_returning_compile_stateZ _generateZprimary_columnsextend primary_keyr?Z returning) selfcompilerorm_level_statementZdml_level_statement dml_mapperrfsZfscZcols_to_returnrIrIrK_setup_orm_returnings:      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_optionsrrZ instances) rryrrkrCbind_argumentsrZexecution_contextr load_optionsZ querycontextrIrIrK_return_orm_returning9s(  z!ORMDMLState._return_orm_returning)r __module__ __qualname__Zis_dml_returningr__annotations__ classmethodrrrrrrrrIrIrIrKrjs"   3    ! 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       rF is_multitableis_update_fromis_delete_usingis_executemanydialectrr8rrr>rrrrEcCstrH)r{)rrr8rrrrrIrIrKcan_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> dml_strategyridentity_token autoflushrsynchronize_sessionclauserF0statement had 'orm' plugin but no plugin_subjectr8rrr core_onlyrormrrHCan't use "bulk" ORM insert strategy without passing separate parameters)revaluatefetchFzSValid strategies for session synchronization are 'auto', 'evaluate', 'fetch', FalserzkThe 'fetch' synchronization strategy is not available for 'bulk' ORM updates (i.e. multiple parameter sets)rr)rrrrr)rrfrom_execution_optionsrrKeyErrorr8r`rrrrsa_excInvalidRequestErrorr ArgumentErrorr_do_pre_synchronize_auto_do_pre_synchronize_evaluate_do_pre_synchronize_fetch _annotaterrrr immutabledictr) rryrrkrCr is_pre_eventupdate_optionsrZsyncrIrIrKorm_pre_session_execws                 z'BulkUDCompileState.orm_pre_session_execcCs|d}|jdkr%|jdkr|||||n"|jdkr$|||||n|jdkr9|jdkr7||||||S|||||||S)Nrrrrrr)rr_do_post_synchronize_evaluate_do_post_synchronize_fetch"_do_post_synchronize_bulk_evaluater)rryrrkrCrrrrIrIrKorm_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. rINZadditional_entity_criteriac3s*|]}|js |jur|VqdSrH)Zinclude_aliasesrZ_resolve_where_criteria)rTZae)rrIrKro0s z@BulkUDCompileState._adjust_for_extra_criteria..c3s|]}|VqdSrH)traverse)rTcrit)adapterrIrKro<s)rZ_adapterr8rZ_single_table_criterion)rglobal_attributesrZ return_critrI)rrrK_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)rTZsuper_pkZsub_pkrIrIrKrdrWcsi|] \}}||qSrIrI)rTidxZlpk)local_pk_to_base_pkrIrKrhscrvrIrI)rTZbpk)lookuprIrKrVlsz@BulkUDCompileState._interpret_returning_rows..cs"g|] tfddDqS)c3|]}|VqdSrHrI)rTr rowrIrKroozJBulkUDCompileState._interpret_returning_rows...)r)rT)primary_key_convertr$rKrVos") rrxrZiterate_to_rootZinheritsrRZ_table_to_equatedr~ enumerate)rr8rowsraZt_to_eZ col_to_colrZsuper_rI)r!r"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)r8rZexpiredobjrRrSrbrIrKrVvs zGBulkUDCompileState._get_matched_objects_on_criteria..cs&g|]\}}}|jkr|||fqSrIr)rTr+rUrXr,rIrKrV~s  T)rrrrZ_EXPIRED_OBJECTappend) rrreval_conditionraw_datarr+rUrXZevaled_conditionrI)rr8rK _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)r+rIrIrKrszJBulkUDCompileState._eval_condition_from_statement.._eval_condition) rrr_EvaluatorCompiler_where_criteriarZ_is_criteria_optionZget_global_criteriarprocess) rrrr8 target_clsevaluator_compilerrroptr.rrIrIrK_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. r)rrrr)r8rUnevaluatableErrorr)rryrrkrCrrr.rIrIrKrs( 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)r8rr9r r ) rryrrkrCrrr.errrIrIrKrs" z/BulkUDCompileState._do_pre_synchronize_evaluatecCs2|jrgS|jr t|jS|jrt|jSgSrH)Z _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) rrZ ColumnElementZ_columntopropertyorm_excZUnmappedColumnErrorr-rfr r )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)rrrzjFor 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) ryZget_bindrrrrrrr r rr)rBbindZper_bind_resultrrr8rrIrKskip_for_returning>s, zHBulkUDCompileState._do_pre_synchronize_fetch..skip_for_returning)rCrZ _add_event)rr)rBr/rEr) rr rZselect_identity_token select_fromrrr3executeZfetchall) rryrrkrCrrZ select_stmtrEr matched_rowsrIrDrKrs* !z,BulkUDCompileState._do_pre_synchronize_fetchNrrr8rrr>rr>rr>rr>rEr>)rrrr$rrrrrrr*r0r8rrr=rArrIrIrIrKr\s<  w + $ 0 &  /   rrinsertcsveZdZUGdddeZdZded<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) rrrrrrLrMrrrNrIrIrIrKdefault_insert_optionsps     rONzOptional[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>rrZpopulate_existingrrFrr8rrrrrrrrawr)rKrOr rrr r8rr r rZ_orm_load_exec_optionsrrrrr) rryrrkrCrrinsert_optionsrrIrIrKrzsX          z"BulkORMInsert.orm_pre_session_execryr0r dml.Insertrkr5rCr+rr.rlr3rE_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)NrP)rQrrrrzHValid strategies for ORM insert strategy are 'raw', 'orm', 'bulk', 'autorQ)rCrrz`bulk INSERT with a 'post values' clause (typically upsert) not supported for multi-table mapper Iterable[Dict[str, Any]]F)r=r?r@rArCrrrNT)rrOrr r rGrZ_post_values_clauseZ_multiple_persistence_tablesr  _transactionrLrrrRrMrLAssertionErrorr>rrNrrrr) rryrrkrCrrlrRrr8rrIrIrKorm_execute_statementsx           z#BulkORMInsert.orm_execute_statementc stttj||fi|}|dur|j }nd}|s|S|jd}|jdd}|dkr4|||S|dkr>| |||S)NTrrrQrrr) rrKsuperrstackrrr_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)rrrrbrIrKro2s z;BulkORMInsert._resolved_keys_as_col_keys..)r~)rr8Zresolved_value_dictrIrbrK_resolved_keys_as_col_keys.s  z(BulkORMInsert._resolved_keys_as_col_keyscCs0ttj|j}}|j||||dd}||_dS)NFrr)rrInsertrr)rrr8rrrIrIrKr\7s 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(). Z_emit_insert_tableZ_emit_insert_mapperc i|] \}}|jur||qSrIr`rTravalZemit_insert_tablerIrKrW  z8BulkORMInsert._setup_for_bulk_insert..TrcNzCan't use RETURNING * with bulk ORM INSERT. Please use a different INSERT form, such as INSERT..VALUES or INSERT with a Core Connection)rrrdrr_cloner`_dict_parametersr~rrrrr  CompileError)rrrranZemit_insert_mapperrIrirKr[Cs2   z$BulkORMInsert._setup_for_bulk_insert)ryr0rrSrkr5rCr+rr.rlr3rErT)rErK)rrrr$rOrrrrrXrrbr\r[ __classcell__rIrIr_rKrKns   C X  rKupdatecseZdZeddZddZddZed,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 unspecifiedrrrr)rrr) __new__rrrZ_setup_for_bulk_updater`r'__init___setup_for_orm_update)rrrr]rrr^rIrIrKrts      z"BulkORMUpdate.create_for_statementc KsH|}|j }|jjd}|j|_}||||_|j||||d|jr+t|j|_| }|j |_|j r;|j|_ n|jrB|j|_| |j |} | rP|j| }tj|||fi|d} |sbd} n|jdd} |jdd} | dur| dko|j|j||jd} | dkr| rd} |jt|j j}|r|j||||| d }||_dS) Nrr^Zprocess_criteria_for_toplevelFrrr)rTrc)rZr`rr8r=r_init_global_attributesr<rRrkrr;rrwherer'rurrrrr?rrrr) rrrr]rr^rr8new_stmtnew_critrrrrIrIrKrvsl         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(). 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().crerIrfrgZemit_update_tablerIrKr rjz8BulkORMUpdate._setup_for_bulk_update..N)rrZUpdaterrkr`r'rur;r r rlr~r)rrrr]rn_rIr|rKrts"   z$BulkORMUpdate._setup_for_bulk_updateryr0r dml.Updaterkr5rCr+rr.rlr3rErTc 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)rrrrrzOValid strategies for ORM UPDATE strategy are 'orm', 'auto', 'bulk', 'core_only'rrrrzbulk 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.rUF)r=rrr)rrrr r r3rr rrVrrrrRrrYrX) rryrrkrCrrlrrr8rr_rIrKrXs^       z#BulkORMUpdate.orm_execute_statementFrrrr8rrr>rrrcCsL|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)Zupdate_returningrimplicit_returningZupdate_executemany_returningZupdate_returning_multifromr rmrrrr8rrrrZ normal_answerrIrIrKr]s   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#rHrIrwparamrIrKror&zCBulkORMUpdate._do_post_synchronize_bulk_evaluate..)rr identity_mapidentity_key_from_primary_keyrZfast_get_stater differencerR unmodifiedrmanagerdispatchrefresh_commitr_expire_attributes)rryrkrrr8Zpk_keysr identity_keyrUevaluated_keysrX to_evaluaterf to_expirerIrrKrs:     z0BulkORMUpdate._do_post_synchronize_bulk_evaluatecCs0|||j}||||dd|DdS)NcSsg|] \}}}}|||fqSrIrI)rTr+rUrXr}rIrIrKrVsz?BulkORMUpdate._do_post_synchronize_evaluate..)r0r all_states#_apply_update_set_values_to_objects)rryrrrmatched_objectsrIrIrKrs z+BulkORMUpdate._do_post_synchronize_evaluatec sj|j}|r||}fdd|D}nj}fddfdddd|DDD}|s5dS||dd|DdS)Ncg|] }t|jfqSrIrrrTr%rrIrKrVz.cs g|] }|jvrj|qSrI)r)rTr)ryrIrKrVs   cs6g|]\}}jdus|jkrjt||dqS)Nr,)rrr)rTrr) target_mapperrrIrKrVs  cSs g|] }|dd|dfqS)rrIrrIrIrKrVscSs"g|] }|t|t|fqSrI)r instance_state instance_dict)rTr+rIrIrKrVs)rreturned_defaults_rowsr*rr) rryrrrrpk_rowsrHZobjsrI)ryrrrKrs6   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)rrrr2r=rAr4rrrrr9rrrrrrrrrrraddZ_register_altered)rryrrrr8r5r6r?Zresolved_keys_as_propnamesZvalue_evaluatorsrfvalueZ _evaluatorrattribrr+rUrXrrrIrIrKrsB         z1BulkORMUpdate._apply_update_set_values_to_objects)ryr0rr~rkr5rCr+rr.rlr3rErTrI)rrrrrrvrtrXrrrrrrorIrIr_rKrqrs* b$K$ *  3rqdeletecs`eZdZeddZed$fdd Zedddddd%ddZed d!Zed"d#ZZ S)& BulkORMDeletecKsX||}|jdd}|dks|dkr'd|jjvr'tj|||fi||S|j }|}|jjd}|j|_} |j||||d| } | j | _| |j | } | rX| j | } tj|| |fi|d} |sjd} n|jdd} |jdd}|dur| d ko|j|j| |j|jd dd }|rd } | j| jj} |r|j||| | | d } | |_|S)NrrrrrrwFrrrr)rrTrc)rsrrr`r%rurZr8rxrkrrrryrrrr?rrr)rrrr]rrr^rrr8rzr{rrrrIrIrKr(sx      z"BulkORMDelete.create_for_statementryr0r dml.Deleterkr5rCr+rr.rlr3rErTcsL|d|j}|jdkrtd|jdvrtdt||||||S)NrrrzBulk ORM DELETE not supported right now. Statement may be invoked at the Core level using session.connection().execute(stmt, parameters))rrrzGValid strategies for ORM DELETE strategy are 'orm', 'auto', 'core_only')rrrr r r rYrX)rryrrkrCrrlrr_rIrKrXs    z#BulkORMDelete.orm_execute_statementFrrrr8rrr>rrrcCsB|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)Zdelete_returningrrZdelete_returning_multifromr rmrrrIrIrKrs   zBulkORMDelete.can_use_returningc Cs^|||j}g}|D]\}}} } | r|| |jjq ||q |r-||dSdSrH)r0rrZ_expireZ _modifiedr-_remove_newly_deleted) rryrrrrZ to_deleter}rUrXZis_partially_expiredrIrIrKrs z+BulkORMDelete._do_post_synchronize_evaluatec sj}|j}|r|||}fdd|D}nj}|D]&} | dd} | d} |jt| | d} | |jvrC|t |j| gqdS)NcrrIrrrrIrKrVrz.rrr,) rrr*rrrrrr r) rryrrrrrrrHr%rrrrIrrKrs4   z(BulkORMDelete._do_post_synchronize_fetch)ryr0rrrkr5rCr+rr.rlr3rErTrI) rrrrrrXrrrrorIrIr_rKr&s Y( 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>rErr1)r8rr:r;r<r1r=r>rr>rrrr>rEr)O__doc__ __future__rtypingrrrrrrr r r r rrrr>rrbaserrrrrr rZenginerrrsqlrrrrr r!Zsql.baser"r#r$Zsql.dmlr%r&r'r(Z util.typingr)Z_typingr*r+r,r8r-ryr.r/r0r1rUr2r3r4Zengine.interfacesr5objectr6rLrr|rrZ plugin_forrKrqrrIrIrIrKs                                                        [s   6