o g@s|dZddlmZddlmZddlmZddlmZddlmZddlmZddlm 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 d8d8d9dodJdKZFe d8d8d9dpdNdKZFdOdOd9dqdQdKZFe d8dRdSdrdXdYZGe d8dRdSdsd\dYZGdOdRdSdtd^dYZGd_d`ZHGdadbdbeZIGdcddddeIZJe*KdedfGdgdhdheIe.ZLe*KdediGdjdkdkeJe/ZMe*KdedlGdmdndneJe-ZNdOS)uzoadditional 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.)use_orm_insert_stmtexecution_optionsmapper Mapper[_O]mappingsr?rArBr8r9rIrI[/var/www/html/flaskapp/venv/lib/python3.10/site-packages/sqlalchemy/orm/bulk_persistence.py _bulk_insertJ rLOptional[dml.Insert]cursor.CursorResult[Any]cCrGrHrIrJrIrIrKrLXrMN"Optional[cursor.CursorResult[Any]]c sj}|jjr td|r1trtttt|r)ddD} dd| Dn(ddDn tr>ttt t t f|rEt nddDt ||d} fdd|jD} |rid} n t| d krrd} nd } | D]W\} }|durfd d|Dnd }fd dtj| fddDd| ||dD}tj|d|| || ||d}|dur|jr| dur|} qv|jr| sJ| |} qv|r|rj}ddjD}| D]\}|tfdd|Ddf|_q|dur| dusJ| SdS)NzJconnection_callable / per-instance sharding not supported in bulk_insert()cSsg|]}||jfqSrIdict.0staterIrIrK z _bulk_insert..cSsg|]\}}|qSrIrI)rTrUdict_rIrIrKrVcSg|]}|jqSrIrQrSrIrIrKrVcSg|]}t|qSrIrQrTmrIrIrKrVrYcs"g|] \}}|jvr||fqSrI) _pks_by_table)rTtablempr:rIrKrVs  Tr Fc g|] }|jdvr|jqSrkeyrTbr<rIrKrV rIc 3s4|]\}}}}}}}}d|||||fVqdSrHrI) rTrU state_dictparamsraconn value_params has_all_pkshas_all_defaults connectionr:rIrK s*  z_bulk_insert..c3s|] }d|fVqdSrHrIrTmappingrqrIrKrss)bulkrArBinclude_bulk_keys) bookkeepingr8r9cSrZrIre)rTprIrIrKrVr[csg|]}|qSrIrIrTrf)rXrIrKrVrY) base_mappersessionconnection_callableNotImplementedErrorr rrr2r6rstrrlist_expand_compositesrr_sorted_tablesitemslen_get_embedded_bindparamsr_collect_insert_commands_emit_insert_statements _returning returns_rowssplice_horizontally_identity_class_identity_key_propstuplerf)r:r<r>r?rArBr8r9r{states return_resultmappers_to_runrxr` super_mapperextra_bp_namesrecordsr identity_clsidentity_propsrUrI)rrrXr:r<rKrLfs             T)use_orm_update_stmtenable_check_rowcount Mapper[Any]update_changed_onlyrrcCrGrHrIr:r<r>r?rrrrIrIrK _bulk_update rOptional[dml.Update]_result.Result[Any]cCrGrHrIrrIrIrKr rOptional[_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)r:rU)r)rUrK _changed_dict(s z#_bulk_update.._changed_dictcsg|]}|qSrIrIrS)rr:rIrKrV1rWz _bulk_update..cSrZrIrQrSrIrIrKrV3r[cSr\rIrQr]rIrIrKrV5rYzJconnection_callable / per-instance sharding not supported in bulk_update()crcrdrergrirIrKrVCrjrIc3s0|]}d|jr|jjndfVqdSrH)_version_id_proprfrtrqrIrKrsSs  z_bulk_update..T)rvrrwF)rxrr)r{_primary_key_propkeysrrfunionrr|r}r~rrrrrisar_r_collect_update_commands_emit_update_statements_result null_result) r:r<r>r?rrrr{rr`rrrI)rrrr:r<rrKrs`         csV|jsdSt}fdd|D}|D]}||D]}|||qqdS)Ncsi|] }||qSrI))_populate_composite_bulk_save_mappings_fnrzcomposite_attrsrIrKrzs z&_expand_composites..) compositessetkeys intersection)r:r<composite_keys populatorsrurfrIrrKrts  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 isinstancerr"rExpressionElementRoler!NullType_bulk_update_tuples _annotations) clsr: statement kv_iteratorneeds_to_be_cacheablecore_get_crud_kv_pairsrrdesck_annoattrrIrIrK_get_orm_crud_kv_pairssV      z"ORMDMLState._get_orm_crud_kv_pairscs6jdr jst|Sfdd|DS)Nplugin_subjectc s&g|]}tj|dqS)F)rRrr:r)rT value_dictrrrrIrKrVsz8ORMDMLState._get_multi_crud_kv_pairs..)_propagate_attrsr:r'_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)rr:r'rrr)rrrrrrIrIrKrs"  zORMDMLState._get_crud_kv_pairscCs@|jjd}|j}|jr|j}n|jj}||j|j|j|jdS)N parententity)nametypeexprentityr`) r`rr:is_aliased_classrclass___name__r local_table)rrext_infor: _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|qSrHrIrrIrIrKrV8sz4ORMDMLState._setup_orm_returning..supplemental_cols)rrr9_execution_optionsoptions _with_optionsselect_statementrcreate_for_statementr!setup_dml_returning_compile_state _generateprimary_columnsextend primary_keyrA returning) selfcompilerorm_level_statementdml_level_statement dml_mapperrfsfsccols_to_returnrIrIrK_setup_orm_returnings8      z ORMDMLState._setup_orm_returningc CsV|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|rrlr9bind_argumentsrexecution_contextr load_options querycontextrIrIrK_return_orm_returningVs*  z!ORMDMLState._return_orm_returning)r __module__ __qualname__is_dml_returningr__annotations__ classmethodrrrrrrr rIrIrIrKrs"   7    ! Crc@seZdZGdddeZedddddd(ddZeddZeddZeddZ eddZ eddZ eddZ eddZ edd Zed!d"Zed#d$Zed%d&Zd'S))BulkUDCompileStatec@s~eZdZUdZded<dZded<dZded<dZded <dZded <d Z ded <d Z ded<e Z d Z d Zd ZdZded<d S)z)BulkUDCompileState.default_update_optionsautor* _dml_strategyr,_synchronize_sessionFr@_can_use_returning_is_delete_using_is_update_fromT _autoflushNOptional[Mapper[Any]]_subject_mapper_populate_existing)rrrrrrrrrrrr(_resolved_values_eval_condition _matched_rows_identity_tokenrrIrIrIrKdefault_update_options{s       r"F is_multitableis_update_fromis_delete_usingis_executemanydialectrr:rr$r@r%r&r'rEcCstrH)r~)rr(r:r$r%r&r'rIrIrKcan_use_returnings 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&populate_existingsynchronize_sessionclauserF0statement had 'orm' plugin but no plugin_subjectr:rrr core_onlyrormrvHCan't use "bulk" ORM insert strategy without passing separate parameters)revaluatefetchFzSValid strategies for session synchronization are 'auto', 'evaluate', 'fetch', Falser6zkThe 'fetch' synchronization strategy is not available for 'bulk' ORM updates (i.e. multiple parameter sets)r5r)r/r&r%r,r))rr"from_execution_optionsrrKeyErrorr:r`rrrrsa_excInvalidRequestErrorr ArgumentErrorr_do_pre_synchronize_auto_do_pre_synchronize_evaluate_do_pre_synchronize_fetch _annotaterrrr immutabledictr) rr|rrlr9r  is_pre_eventupdate_optionsrsyncrIrIrKorm_pre_session_execs                  z'BulkUDCompileState.orm_pre_session_execcCs|d}|jdkr%|jdkr|||||n"|jdkr$|||||n|jdkr9|jdkr7||||||S|||||||S)Nr*r3r5r6rv)rr_do_post_synchronize_evaluate_do_post_synchronize_fetch"_do_post_synchronize_bulk_evaluater )rr|rrlr9r rrBrIrIrKorm_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)rrIrKrsPs z@BulkUDCompileState._adjust_for_extra_criteria..c3s|]}|VqdSrH)traverse)rTcrit)adapterrIrKrs\s)r_adapterr:r_single_table_criterion)rglobal_attributesr return_critrI)rOrrK_adjust_for_extra_criteria;s"  z-BulkUDCompileState._adjust_for_extra_criteriacsXz|j|jjur||jjn||jWn ty"gYSwfdd|DS)areturn rows that indicate PK cols in mapper.primary_key position for RETURNING rows. Prior to 2.0.36, this method seemed to be written for some kind of inheritance scenario but the scenario was unused for actual joined inheritance, and the function instead seemed to perform some kind of partial translation that would remove non-PK cols if the PK cols happened to be first in the row, but not otherwise. The joined inheritance walk feature here seems to have never been used as it was always skipped by the "local_table" check. As of 2.0.36 the function strips away non-PK cols and provides the PK cols for the table in mapper PK order. csg|]}|qSrIrIrTrowpk_keysrIrKrVrYz@BulkUDCompileState._interpret_returning_rows..)rr{ _tuple_getterrr8)rrr:rowsrIrWrK_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)r:rexpiredobjrRrSrbrIrKrVs zGBulkUDCompileState._get_matched_objects_on_criteria..cs&g|]\}}}|jkr|||fqSrIr-)rTr]rUrXr^rIrKrVs  T)rrr!r_EXPIRED_OBJECTappend) rrBreval_conditionraw_datarr]rUrXevaled_conditionrI)r-r:rK _get_matched_objects_on_criterias0   z3BulkUDCompileState._get_matched_objects_on_criteriac Cs|j}|j}t|}d}|jr||j7}i}|jD] }|jr$||q|r/||||7}|r8|j |} | Sdd} | } | S)NrIcSsdS)NTrI)r]rIrIrKrszJBulkUDCompileState._eval_condition_from_statement.._eval_condition) rrr_EvaluatorCompiler_where_criteriar_is_criteria_optionget_global_criteriarTprocess) rrBrr: target_clsevaluator_compilerrNrRoptrarrIrIrK_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. r5)rrrr6)rmrUnevaluatableErrorr>)rr|rrlr9r rBrarIrIrKr<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)rmrrnr9r:) rr|rrlr9r rBraerrrIrIrKr=s" z/BulkUDCompileState._do_pre_synchronize_evaluatecCs2|jrgS|jr t|jS|jrt|jSgSrH) _multi_values_ordered_valuesr_valuesr)rr:rrIrIrK_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_excUnmappedColumnErrorr`rfr9r:)rr:resolved_valuesvaluesrrrrIrIrK_resolved_keys_as_propnamess 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'r9r:rr)r{bindper_bind_resultr)rr:rBrIrKskip_for_returningPs, zHBulkUDCompileState._do_pre_synchronize_fetch..skip_for_returning)r9r  _add_event)r r)r{r/rEr) rr rselect_identity_token select_fromrrrfexecutefetchall) rr|rrlr9r rB select_stmtrr matched_rowsrIrrKr>.s* !z,BulkUDCompileState._do_pre_synchronize_fetchNr(rr:rr$r@r%r@r&r@r'r@rEr@)rrrr$r"rr)rDrHrTr[rdrmr<r=rsrzr>rIrIrIrKrzs< x + $ " &  /   rr3insertcsveZdZUGdddeZdZded<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_defaultsNrrTrr) rrrrrrrrrrrIrIrIrKdefault_insert_optionss     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,rBr.r0rFr1r:rrrr3rvr4rawr,)rrr7rrr8r:rr9r:r_orm_load_exec_optionsrrr?rr@) rr|rrlr9r rAinsert_optionsrrIrIrKrDsX          z"BulkORMInsert.orm_pre_session_execr|r0r dml.Insertrlr5r9r+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)rrvr3rzHValid strategies for ORM insert strategy are 'raw', 'orm', 'bulk', 'autor)r9rvz`bulk INSERT with a 'post values' clause (typically upsert) not supported for multi-table mapper Iterable[Dict[str, Any]]F)r?rArBr8r9r3rrT)rrrr9r;rr_post_values_clause_multiple_persistence_tablesr: _transactionrLrrrRrrAssertionErrorr@rrrrrr ) rr|rrlr9r rmrrr:r rIrIrKorm_execute_statementsx           z#BulkORMInsert.orm_execute_statementc stttj||fi|}|dur|j }nd}|s|S|jd}|jdd}|dkr4|||S|dkr>| |||S)NTrr,rrvr3) rrsuperrstackrrr_setup_for_bulk_insert_setup_for_orm_insert)rrrkwrtoplevelr:r, __class__rIrKr)s"    z"BulkORMInsert.create_for_statementcs ddfdd|DDS)NcSs&i|]\}}}|dur|jn||qSrHre)rTcolrrrIrIrKrBsz.c3s&|]\}}j|||fVqdSrH)rrrrbrIrKrsDs z;BulkORMInsert._resolved_keys_as_col_keys..)r)rr:resolved_value_dictrIrbrK_resolved_keys_as_col_keys@s  z(BulkORMInsert._resolved_keys_as_col_keyscCs0ttj|j}}|j||||dd}||_dS)NFrr)rrInsertrr)rrr:rrrIrIrKrIs 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_tablerIrKri  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_parametersrrrrrr9 CompileError)rrrranemit_insert_mapperrIrrKrUs2   z$BulkORMInsert._setup_for_bulk_insert)r|r0rrrlr5r9r+r r.rmr3rEr)rEr)rrrr$rrrrrDrrrrr __classcell__rIrIrrKrs   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, unspecifiedrvr2r)r3r) __new__rrr_setup_for_bulk_updater`r'__init___setup_for_orm_update)rrrrrr,rrIrIrKrs      z"BulkORMUpdate.create_for_statementc KsT|}|j }|jjd}|j|_}||||_|j||||d|jr+t|j|_| }|jjd|ur;|j |_|j rC|j|_ n|jrJ|j|_| |j |} | rX|j| }tj|||fi|d} |sjd} n|jdd} |jdd} | dur| dko|j|j||jd} | dkr| rd} |j|jj}|r|j||||| d }||_dS) Nrrprocess_criteria_for_toplevelFr/r)r6)r$Tr)rr`rr:rsr_init_global_attributesrrrRrrrqrTrRwherer'rrr)r(r$rArrr) rrrrrrrr:new_stmtnew_critrr/r)rIrIrKrsj         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'rrqr9r:rrr)rrrrr_rIrrKrs"   z$BulkORMUpdate._setup_for_bulk_updater|r0r dml.Updaterlr5r9r+r r.rmr3rErc s|d|j}|jr|dtj}|ddi7}|d|i}|jdvr(td|jdkrv|j } |j dks8J|j rE|j d krEt d |j } | dusNJ|j dusUJt| td t|tra|gn||j d d || d } ||||||| St||||||S)Nr*rrT)r3rrvr2zOValid strategies for ORM UPDATE strategy are 'orm', 'auto', 'bulk', 'core_only'rvr6r5zbulk 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"rrrrrr9r;rfrr:rrrrrrRrHrr) rr|rrlr9r rmrBr rr:rrrIrKr#sn        z#BulkORMUpdate.orm_execute_statementFr#r(rr:rr$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_multifromr9rrrr(r:r$r%r&r' normal_answerrIrIrKr)ys   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..c3s|]}|VqdSrHrIrzparamrIrKrsszCBulkORMUpdate._do_post_synchronize_bulk_evaluate..)rr identity_mapidentity_key_from_primary_keyr!fast_get_stater differencerR unmodifiedrmanagerdispatchrefresh_commitr_expire_attributes)rr|rlrrBr:rXr identity_keyrUevaluated_keysrX to_evaluaterf to_expirerIrrKrGs:     z0BulkORMUpdate._do_post_synchronize_bulk_evaluatec CsF|||j}|||||jjddd|D||dS)NrcSsg|] \}}}}|||fqSrIrI)rTr]rUrXrrIrIrKrVsz?BulkORMUpdate._do_post_synchronize_evaluate..)rdr all_states#_apply_update_set_values_to_objectsrcompiled_parameters prefetch_colspostfetch_cols)rr|rrrBmatched_objectsrIrIrKrEs  z+BulkORMUpdate._do_post_synchronize_evaluatec sj|j}|r|||}fdd|D}nj}fddfdddd|DDD}|s6dS|||jjddd|D||dS)Ncg|] }t|jfqSrIrr!rUrBrIrKrVz.cs g|] }|jvrj|qSrI)r)rTr)r|rIrKrVs   cs6g|]\}}jdus|jkrjt||dqS)Nr^)r!rr)rTrr-) target_mapperrBrIrKrVs  cSs g|] }|dd|dfqS)rrIrUrIrIrKrVsrcSs"g|] }|t|t|fqSrI)r instance_state instance_dict)rTr]rIrIrKrVs) rreturned_defaults_rowsr[r rrrrr) rr|rrrBrpk_rowsrobjsrI)r|rrBrKrFs<    z(BulkORMUpdate._do_post_synchronize_fetchc s|jj}t|} ||} || } i} | D]\} }z | tt j |}Wn tj y5Yqw|| | <qt | dd| D}t}fdd|D}fdd|D}fdd|D}|D]U\}}}|fdd|D||j||j}|D]} | |vr| | ||| <q|jj|d |||t ||||}|r|||||qm||d S) zeapply values to objects derived from an update statement, e.g. UPDATE..SET cSsh|]\}}|qSrIrIrrIrIrK 5rYzDBulkORMUpdate._apply_update_set_values_to_objects..cs.h|]}|jvr|jvr|jvr|qSrI)rfrureffective_paramsrr:rIrKr9s   cs"h|] }|jvrj|jqSrIrurfrrbrIrKr@s   csg|] }j|j|jfqSrIrrrbrIrKrVFszEBulkORMUpdate._apply_update_set_values_to_objects..csi|] \}}||qSrIrI)rT col_to_propc_key)rrIrKrMszEBulkORMUpdate._apply_update_set_values_to_objects..N)rrrrersrzrirrrrrnrrrrrrrRrrrrrradd_register_altered)rr|rBrrrrrrjrkrxresolved_keys_as_propnamesvalue_evaluatorsrfvalue _evaluatorattribr to_prefetchrprefetch_transferr]rUrXrrIrrKrsd            z1BulkORMUpdate._apply_update_set_values_to_objects)r|r0rrrlr5r9r+r r.rmr3rErr)rrrrrrrrr)rGrErFrrrIrIrrKrs* b$U$ *  5rdeletecs`eZdZeddZed$fdd Zedddddd%ddZed d!Zed"d#ZZ S)& BulkORMDeletecKsh||}|jdd}|dks|dkr'd|jjvr'tj|||fi||S|j }|}|jjd}|j|_} |j||||d| } | jjd| urR| j | _| |j | } | r`| j | } tj|| |fi|d} |srd} n|jdd} |jdd}|dur| d ko|j|j| |j|jd dd }|rd } | j| jj} |r|j||| | | d } | |_|S)Nr,rr2rrFr/r)r6r&)r$r&Tr)rrrr`r%rrr:rrrrTrRrr)r(r$rArrr)rrrrrr,rrrr:rrrr/r)rIrIrKrmsz      z"BulkORMDelete.create_for_statementr|r0r dml.Deleterlr5r9r+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))r3rr2zGValid strategies for ORM DELETE strategy are 'orm', 'auto', 'core_only')rr"rr9r:r;rr)rr|rrlr9r rmrBrrIrKrs    z#BulkORMDelete.orm_execute_statementFr#r(rr:rr$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_multifromr9rrrrIrIrKr)s   zBulkORMDelete.can_use_returningc Cs^|||j}g}|D]\}}} } | r|| |jjq ||q |r-||dSdSrH)rdrr_expire _modifiedr`_remove_newly_deleted) rr|rrrBr to_deleterrUrXis_partially_expiredrIrIrKrEs z+BulkORMDelete._do_post_synchronize_evaluatec sj}|j}|r||||}fdd|D}nj}|D]&} | dd} | d} |jt| | d} | |jvrD|t |j| gqdS)NcrrIrrUrrIrKrV3rz.rrr^) rrr[r rrrr r r) rr|rrrBrrrrrVrr-rrIrrKrF&s4   z(BulkORMDelete._do_post_synchronize_fetch)r|r0rrrlr5r9r+r r.rmr3rErr) rrrrrrr)rErFrrIrIrrKrks [( r)r:r;r<r=r>r1r?r@rAr@rBr@r8rCr9rDrErF)r:r;r<r=r>r1r?r@rAr@rBr@r8rNr9rDrErO)r:r;r<r=r>r1r?r@rAr@rBr@r8rNr9rDrErP)r:rr<r=r>r1r?r@rr@rrCrr@rErF)r:rr<r=r>r1r?r@rr@rrrr@rEr)r:rr<r=r>r1r?r@rr@rrrr@rEr)O__doc__ __future__rtypingrrrrrrr r r r rrrrvrrbaserrrrrr9renginerrrsqlrrrrr r!sql.baser"r#r$sql.dmlr%r&r'r( util.typingr)_typingr*r+r,r:r-r|r.r/r0r1rUr2r3r4engine.interfacesr5objectr6rLrrrr plugin_forrrrrIrIrIrKs                                                        \x   i