a [g @sdZddlmZddlmZddlmZddlmZddlmZddlmZddlm 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 rnd d*l3m4Z4d d+l3m5Z5d d,l3m6Z6d d-l7m8Z8d d.l9m:Z:d d/l9m;Z;d d0l9mm?Z?dd3lm@Z@dd4lmAZAdd5lBmCZCe d6eDd7ZEe d8d8d9d:d;dd?d@dA dBdCZFe d8d8d9d:d;dd=d@dMdNdOZGe d8dJdKdLd;dr?r@rAr8r9rDrDm/var/www/html/cobodadashboardai.evdpl.com/venv/lib/python3.9/site-packages/sqlalchemy/orm/bulk_persistence.py _bulk_insertJs rGzOptional[dml.Insert]zcursor.CursorResult[Any]cCsdSrCrDrErDrDrFrGXs Nz"Optional[cursor.CursorResult[Any]]c sj}|jjrtd|rbtr0tttt|rRddD} dd| DqddDn@tr|ttt t t f|rt nddDt ||d} fdd|jD} |rd} nt| d krd} nd } | D]\} }|durfd d|Dnd }fd dtj| fddDd| ||dD}tj|d|| || ||d}|dur|jr| dur|} q|jr| sJ| |} q|r|rj}ddjD}| D](\}|tfdd|Ddf|_q|dur| dus J| SdS)NzJconnection_callable / per-instance sharding not supported in bulk_insert()cSsg|]}||jfqSrDdict.0staterDrDrF z _bulk_insert..cSsg|] \}}|qSrDrD)rKrLdict_rDrDrFrMrNcSsg|] }|jqSrDrHrJrDrDrFrMrNcSsg|] }t|qSrDrHrKmrDrDrFrMrNcs"g|]\}}|jvr||fqSrD) _pks_by_table)rKtablempr<rDrFrMs Tr Fcs g|]}|jdvr|jqSrkeyrKbr=rDrFrMsrDc 3s2|]*\}}}}}}}}d|||||fVqdSrCrD) rKrLZ state_dictparamsrTconnZ value_paramsZ has_all_pksZhas_all_defaults connectionr<rDrF s$ z_bulk_insert..c3s|]}d|fVqdSrCrDrKmappingr^rDrFr`rN)bulkr@rAinclude_bulk_keys) bookkeepingr8r9cSsg|] }|jqSrDrW)rKprDrDrFrMrNcsg|] }|qSrDrDrKrX)rOrDrFrMrN) base_mappersessionconnection_callableNotImplementedErrorr rrr2r6rstrrlist_expand_compositesr__sorted_tablesitemslen_get_embedded_bindparamsrZ_collect_insert_commandsZ_emit_insert_statements _returningZ returns_rowsZsplice_horizontallyZ_identity_class_identity_key_propstuplerX)r<r=r>r?r@rAr8r9rhstatesZ return_resultZmappers_to_runrerS super_mapperextra_bp_namesrecordsrZ identity_clsZidentity_propsrLrD)r_rOr<r=rFrGfs               T)use_orm_update_stmtenable_check_rowcount Mapper[Any])r<r=r>r?update_changed_onlyrzr{rBcCsdSrCrDr<r=r>r?r}rzr{rDrDrF _bulk_updates rzOptional[dml.Update]z_result.Result[Any]cCsdSrCrDr~rDrDrFr s zOptional[_result.Result[Any]]c s0j}jjr"jjhfdd|r\|rLfddDqtddDnddDt|jjrtd| ||durfdd| Dnd }|j D]^\} }  | r| jvrqtjd| fd d Dd ||d } tj|d| | | d||dq|dur,tSdS)NcsfddjDS)Ncs(i|] \}}|jvs|vr||qSrD)Zcommitted_staterKkv) search_keysrLrDrF )sz7_bulk_update.._changed_dict..)rIrp)r<rL)r)rLrF _changed_dict(s z#_bulk_update.._changed_dictcsg|]}|qSrDrDrJ)rr<rDrFrM1rNz _bulk_update..cSsg|] }|jqSrDrHrJrDrDrFrM3rNcSsg|] }t|qSrDrHrPrDrDrFrM5rNzJconnection_callable / per-instance sharding not supported in bulk_update()cs g|]}|jdvr|jqSrVrWrYr[rDrFrMCsrDc3s.|]&}d|jr |jjndfVqdSrC)_version_id_proprXrar^rDrFr`Ss z_bulk_update..T)rcrzrdF)rerzr{)rhZ_primary_key_propkeysrrXunionrnrirjrkr_rrrorpisarRrZ_collect_update_commandsZ_emit_update_statements_result null_result) r<r=r>r?r}rzr{rhrxrSrwryrD)rr_r<r=rrFrs^        csV|jsdSt}fdd|D}|D] }||D]}|||q>q0dS)Ncsi|]}||qSrD)Z)_populate_composite_bulk_save_mappings_fnrgZcomposite_attrsrDrFrzsz&_expand_composites..)Z compositessetkeys intersection)r<r=Zcomposite_keysZ populatorsrbrXrDrrFrnts  rnc@steZdZUdZdZded<eddZeddZed d Z ed d Z ed dZ ddddZ eddZ dS) ORMDMLStateTNz&Optional[ORMFromStatementCompileState]from_statement_ctxc cstj}|D]\}}ttj|}t|trt||t d}|t urrttj||rhtjtj |t ddn|fVq||| ||EdHq d|jvr|j} t| d| d} ||| ||EdHq ||s|ntjtj |t ddfVq dS)N)defaultT)type_Zis_crudZentity_namespace proxy_key)r'_get_crud_kv_pairsrexpectrZ DMLColumnRole isinstancerlr"rExpressionElementRoler!ZNullTypeZ_bulk_update_tuples _annotations) clsr< statement kv_iteratorneeds_to_be_cacheableZcore_get_crud_kv_pairsrrdescZk_annoattrrDrDrF_get_orm_crud_kv_pairssR       z"ORMDMLState._get_orm_crud_kv_pairscs6jdrjs t|Sfdd|DS)Nplugin_subjectc s&g|]}tj|dqS)F)rIrr<rp)rKZ value_dictrrrrDrFrMs z8ORMDMLState._get_multi_crud_kv_pairs..)_propagate_attrsr<r'_get_multi_crud_kv_pairs)rrrrDrrFrs  z$ORMDMLState._get_multi_crud_kv_pairscCsD|s Jd|jd}|r |js.t|||St||j|||S)Nz0no test coverage for needs_to_be_cacheable=Falser)rr<r'rrmr)rrrrrrDrDrFrs"  zORMDMLState._get_crud_kv_pairscCs@|jjd}|j}|jr |j}n|jj}||j|j|j|jdS)N parententity)nametypeexprentityrS) rSrr<is_aliased_classrclass___name__r local_table)rrext_infor<Z _label_namerDrDrFget_entity_descriptions z"ORMDMLState.get_entity_descriptioncs2ddddfddfdd|jDDS)NcSs|jddS)Nr)rget)crDrDrF _ent_for_colszCORMDMLState.get_returning_column_descriptions.._ent_for_colcSs4|dur |S|jdd}|s"|St|j||SdS)Nr)rrgetattrr)rentrrDrDrF _attr_for_cols zDORMDMLState.get_returning_column_descriptions.._attr_for_colcs.g|]&\}}|j|j|||j|jdqS))rrraliasedr)rXrrr)rKrr)rrDrFrMszAORMDMLState.get_returning_column_descriptions..csg|]}||fqSrDrDrKr)rrDrFrMs)Z_all_selected_columns)rrrD)rrrF!get_returning_column_descriptionss  z-ORMDMLState.get_returning_column_descriptions)use_supplemental_colsc Cs|jrt|j|dd}|jfi|j}|j|j}||_t|||_ }| || }d|_dd|j D}|s| |j|r|j|jd|i}n |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_namesrDcSsg|]}|dur|qSrCrDrrDrDrFrM8rNz4ORMDMLState._setup_orm_returning..Zsupplemental_cols)rsrr9_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_returnrDrDrF_setup_orm_returnings6      z ORMDMLState._setup_orm_returningc CsZ|j}|jj}|jrR|jjjsR|dtj} t|j|j |||| ||} t || S|SdS)N_sa_orm_load_options) rcompiled compile_statercompile_options_is_starrrdefault_load_optionsrrZ instances) rrirr\r9bind_argumentsrZexecution_contextr load_optionsZ querycontextrDrDrF_return_orm_returningVs*  z!ORMDMLState._return_orm_returning)r __module__ __qualname__Zis_dml_returningr__annotations__ classmethodrrrrrrrrDrDrDrFrs   7    ! Crc @seZdZGdddeZedddddddddddddd d Zed d Zed dZeddZ eddZ eddZ eddZ eddZ eddZeddZeddZedd 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_tokenrrDrDrDrFdefault_update_options{s        rF is_multitableis_update_fromis_delete_usingis_executemanyrr|r:dialectr<rrrrrBcCs tdSrC)rk)rrr<rrrrrDrDrFcan_use_returnings z$BulkUDCompileState.can_use_returningc Cstjdhd||j\}}||d<z|jd}WntyPdsLJdYn0|rn|j|d<|d|ji7}d |jjvr|d d i7}nNt |t s|j d kr|d d i7}q|j dkrt dn|j d kr|d di7}|j} | dur| dvrt d|j dkr| dkrt d|s|jr.||j d kr|jd kr\|||||||}nB|jdkr~|||||||}n |jdkr|||||||}n$|j dkr|jd kr|ddi7}||j|j|j|j |jd}|t|d|ifS)N_sa_orm_update_options> dml_strategyrrpopulate_existingsynchronize_session autoflushidentity_tokenclauserF0statement had 'orm' plugin but no plugin_subjectr<rrr core_onlyrormrcHCan'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_optionsrrKeyErrorr<rSrrrmrsa_excInvalidRequestErrorr ArgumentErrorr_do_pre_synchronize_auto_do_pre_synchronize_evaluate_do_pre_synchronize_fetch _annotaterrrr immutabledictr) rrirr\r9r is_pre_eventupdate_optionsrsyncrDrDrForm_pre_session_execs                    z'BulkUDCompileState.orm_pre_session_execcCs|d}|jdkrJ|jdkr.|||||qr|jdkrr|||||n(|jdkrr|jdkrn||||||S|||||||S)Nrrrrrc)rr_do_post_synchronize_evaluate_do_post_synchronize_fetch"_do_post_synchronize_bulk_evaluater)rrirr\r9rrrrDrDrForm_setup_cursor_results0     z*BulkUDCompileState.orm_setup_cursor_resultcs~d}jrjnddjf|vrF|tfdd|djfD7}jjdur`|jjf7}rztfdd|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. rDNZadditional_entity_criteriac3s(|] }|js|jur|VqdSrC)Zinclude_aliasesrZ_resolve_where_criteria)rKZae)rrDrFr`Psz@BulkUDCompileState._adjust_for_extra_criteria..c3s|]}|VqdSrC)traverse)rKcrit)adapterrDrFr`\rN)rZ_adapterr<ruZ_single_table_criterion)rglobal_attributesrZ return_critrD)r rrF_adjust_for_extra_criteria;s"   z-BulkUDCompileState._adjust_for_extra_criteriacsXz.|j|jjur ||jjn ||jWntyDgYS0fdd|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|] }|qSrDrDrKrowpk_keysrDrFrMrNz@BulkUDCompileState._interpret_returning_rows..)rrhZ _tuple_getterrr)rrr<rowsrDrrF_interpret_returning_rows`s  z,BulkUDCompileState._interpret_returning_rowsc s|j|j}fdd|D}|jdur>fdd|D}g}|D]<\}}}||} | dusj| tjurF||||| tjufqF|S)Ncs.g|]&}|jr|js|||jfqSrD)r<rZexpiredobjrIrJrUrDrFrMszGBulkUDCompileState._get_matched_objects_on_criteria..cs&g|]\}}}|jkr|||fqSrDr)rKrrLrOrrDrFrMs T)rrrrZ_EXPIRED_OBJECTappend) rrrveval_conditionraw_datarrrLrOZevaled_conditionrD)rr<rF _get_matched_objects_on_criterias2  z3BulkUDCompileState._get_matched_objects_on_criteriac Cs~|j}|j}t|}d}|jr*||j7}i}|jD]}|jr4||q4|r^||||7}|rn|j |} n dd} | } | S)NrDcSsdS)NTrD)rrDrDrFrszJBulkUDCompileState._eval_condition_from_statement.._eval_condition) rrr_EvaluatorCompiler_where_criteriarZ_is_criteria_optionZget_global_criteriarprocess) rrrr< target_clsevaluator_compilerr r optrrrDrDrF_eval_condition_from_statements"     z1BulkUDCompileState._eval_condition_from_statementcCsTz|||}Wntjy$Yn0||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)r!rUnevaluatableErrorr)rrirr\r9rrrrDrDrFrs& z+BulkUDCompileState._do_pre_synchronize_autoc CsTz|||}Wn6tjyF}ztd||WYd}~n d}~00|d|iS)Nz{Could not evaluate current criteria in Python: "%s". Specify 'fetch' or False for the synchronize_session execution option.r)r!rr"rr) rrirr\r9rrrerrrDrDrFrs z/BulkUDCompileState._do_pre_synchronize_evaluatecCs6|jr gS|jrt|jS|jr.t|jSgSdSrC)Z _multi_values_ordered_valuesrm_valuesrp)rr<rrDrDrF_get_resolved_valuess z'BulkUDCompileState._get_resolved_valuesc Csjg}|D]\\}}|rVt|tjrVz|j|}WntjyBYqd0||j|fqt d|q|S)NzCAttribute name not found, can't be synchronized back to objects: %r) rrZ ColumnElement_columntopropertyorm_excZUnmappedColumnErrorrrXrr)rr<resolved_valuesvaluesrrrrDrDrF_resolved_keys_as_propnamess z.BulkUDCompileState._resolved_keys_as_propnamesc svjtjjfj|j}|j|_ddddfdd }|j|||||d} | } | dS)Nr/r) orm_contextrBcsz|jjfi|j}j|jjj|jd}durL|krft dn|jrb|sbt dn||rrt SdSdS)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 RETURNING) riZget_bindrrrrrrrrrr)r,bindZper_bind_resultrrr<rrDrFskip_for_returningPs* zHBulkUDCompileState._do_pre_synchronize_fetch..skip_for_returning)r9rZ _add_event)rr) rr rZselect_identity_token select_fromrrrexecuteZfetchall) rrirr\r9rrZ select_stmtr/r matched_rowsrDr.rFr.s, !z,BulkUDCompileState._do_pre_synchronize_fetchN)rrrr$rrrrr rrrr!rrr&r+rrDrDrDrFrzs:  x + $ " &  /   rrinsertc seZdZUGdddeZdZded<eddZedd d d d d ddddZ eddfdd 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) rrrrrr5r6rrrrDrDrDrFdefault_insert_optionss      r7NzOptional[FromStatement]rc Cstjdhd||j\}}||d<z|jd}WntyPdsLJdYn0|rn|j|d<|d|ji7}|s|jd kr|d d i7}q|jd krt d n|jd kr|d d i7}|jdkr|st j }n | t j }|s|j r| |d|ji}|t| d|ifS)N_sa_orm_insert_options>rArrrrrFrr<rrrrrcrrawr)r4r7rrrrr<rrrrZ_orm_load_exec_optionsrrrrr) rrirr\r9rrinsert_optionsrrDrDrFrsT          z"BulkORMInsert.orm_pre_session_execr0z dml.Insertr5r+r.r3_result.Resultrirr\r9rr]rBc Cs<|d|j}|jdvr"td|jdkrD|j||p8i|d}|S|jdkr|j} |jdurt| jrtt d| | dusJ|j dusJt | t dt |tr|gn||j d |j|j||d }n&|jd kr|j||pi|d}ntt|js|S|jr(|d tj} | d di7} |d | i}|||||||S)Nr8)r9rcrrzHValid strategies for ORM insert strategy are 'raw', 'orm', 'bulk', 'autor9)r9rcz`bulk INSERT with a 'post values' clause (typically upsert) not supported for multi-table mapper Iterable[Dict[str, Any]]F)r?r@rAr8r9rrrT)rr7rrrr1rZ_post_values_clauseZ_multiple_persistence_tablesr _transactionrGrrrIr6r5AssertionErrorr:rsrrrrr) rrirr\r9rr]r:rr<rrDrDrForm_execute_statementsz          z#BulkORMInsert.orm_execute_statement)rBc s~tttj||fi|}|dur.|j }nd}|s:|S|jd}|jdd}|dkrf||n|dkrz| |||S)NTrrr9rcr) rr4superrstackrrr_setup_for_bulk_insert_setup_for_orm_insert)rrrkwrtoplevelr<r __class__rDrFr)s     z"BulkORMInsert.create_for_statementcs ddfdd|DDS)NcSs&i|]\}}}|dur|jn||qSrCrW)rKcolrrrDrDrFrBsz.c3s$|]\}}j|||fVqdSrC)rrrrUrDrFr`Dsz;BulkORMInsert._resolved_keys_as_col_keys..)rp)rr<Zresolved_value_dictrDrUrF_resolved_keys_as_col_keys@s  z(BulkORMInsert._resolved_keys_as_col_keyscCs0ttj|j}}|j||||dd}||_dS)NFrr)rrInsertrr)rrr<rrrDrDrFrDIsz#BulkORMInsert._setup_for_orm_insertcsttj|j}}|j}|d|d}|}|_|jrXfdd|jD|_|j ||||dd}|j dur|j j j rt 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_mappercs i|]\}}|jur||qSrDrSrKrIvalZemit_insert_tablerDrFris z8BulkORMInsert._setup_for_bulk_insert..TrKNzCan't use RETURNING * with bulk ORM INSERT. Please use a different INSERT form, such as INSERT..VALUES or INSERT with a Core Connection)rrrLrr_clonerS_dict_parametersrprrrrr CompileError)rrrranZemit_insert_mapperrDrPrFrCUs4  z$BulkORMInsert._setup_for_bulk_insert)rrrr$r7rrrrr@rrJrDrC __classcell__rDrDrGrFr4s   CX  r4updatec seZdZeddZddZddZeddd d d d d dfdd ZedddddddddddddddZeddZ eddZ eddZ edd Z Z S)! BulkORMUpdatecKs||}|jdd}|j }|r:|dkr:|||nL|dksV|dkrnd|jjvrntj|||fi|n|rz|dvr||||S)Nr unspecifiedrcrr)rrX) __new__rrrB_setup_for_bulk_updaterSr'__init___setup_for_orm_update)rrrrErrrFrDrDrFrs"     z"BulkORMUpdate.create_for_statementc Ks^|}|j }|jjd}|j|_}||||_|j||||d|jrVt|j|_| }|jjd|urv|j |_|j r|j|_ n|jr|j|_| |j |} | r|j| }tj|||fi|d} |sd} n|jdd} |jdd} | dur| dko|j|j||jd} | dkr:| r:d} |j|jj}|rT|j||||| d }||_dS) NrrFZprocess_criteria_for_toplevelFrrr)rTrK)rBrSrr<r&r_init_global_attributesr%rIrQrr$rr wherer'r[rrrrr@rrr) rrrrErrFrr<new_stmtnew_critrrrrDrDrFr\sj         z#BulkORMUpdate._setup_for_orm_updatec sttj|}|j}|d|d}|}|_tj|||fi||jrXt d|j rxfdd|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().cs i|]\}}|jur||qSrDrMrNZemit_update_tablerDrFrs z8BulkORMUpdate._setup_for_bulk_update..N)rrZUpdaterrQrSr'r[r$rrrRrpr)rrrrErT_rDrbrFrZs"  z$BulkORMUpdate._setup_for_bulk_updater0z dml.Updater5r+r.r3r;r<c s|d|j}|jr<|dtj}|ddi7}|d|i}|jdvrPtd|jdkr|j } |j dkspJ|j r|j d krt d |j } | dusJ|j dusJt| td t|tr|gn||j d d || d } ||||||| St||||||SdS)NrrrT)rrrcrzOValid strategies for ORM UPDATE strategy are 'orm', 'auto', 'bulk', 'core_only'rcrrzbulk 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.r=F)r?r}rzr{)rrrrrrrrrrrrrr>rrrrIr rAr@) rrirr\r9rr]rrr{r<rrGrDrFr@#sp       z#BulkORMUpdate.orm_execute_statementFrrr|r:rcCsL|jo |jj}|sdS|r |jS|r*|jS|rH|jsHtd|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_multifromrrSrrrr<rrrrZ normal_answerrDrDrFrys   zBulkORMUpdate.can_use_returningcs|sdS|j}dd|jD}|j}|D]|fdd|D|j}||} | sXq(t|} | j} | j | } | D]} | | vr|| | | <q|| j j | d| | | t| | | | }|r(| | |q(dS)NcSsg|] }|jqSrDrW)rKproprDrDrFrMrNzDBulkORMUpdate._do_post_synchronize_bulk_evaluate..c3s|]}|VqdSrCrDrgparamrDrFr`rNzCBulkORMUpdate._do_post_synchronize_bulk_evaluate..)rrt identity_mapidentity_key_from_primary_keyrZfast_get_stater differencerI unmodifiedrmanagerdispatchrefresh_commitrm_expire_attributes)rrir\rrr<rrj identity_keyrLevaluated_keysrO to_evaluaterX to_expirerDrhrFrs4   z0BulkORMUpdate._do_post_synchronize_bulk_evaluatec CsF|||j}|||||jjddd|D||dS)NrcSsg|]\}}}}|||fqSrDrD)rKrrLrOrcrDrDrFrMrNz?BulkORMUpdate._do_post_synchronize_evaluate..)rrj all_states#_apply_update_set_values_to_objectsrcompiled_parameters prefetch_colspostfetch_cols)rrirrrmatched_objectsrDrDrFrs  z+BulkORMUpdate._do_post_synchronize_evaluatec sj|j}|r2|||}fdd|D}nj}fddfdddd|DDD}|sldS|||jjddd|D||dS)Ncsg|]}t|jfqSrDrurrrrDrFrMsz.cs g|]}|jvrj|qSrD)rj)rKrs)rirDrFrMs cs6g|].\}}jdus |jkrjt||dqS)Nr)rrkrm)rKrr) target_mapperrrDrFrMs  cSs g|]}|dd|dfqS)rrDrrDrDrFrMsrcSs"g|]}|t|t|fqSrD)r instance_state instance_dict)rKrrDrDrFrMs ) rreturned_defaults_rowsrrrxrryrzr{) rrirrrrpk_rowsr2ZobjsrD)rirrrFrs<    z(BulkORMUpdate._do_post_synchronize_fetchc s|jj}t|} ||} || } i} | D]>\} }z| tt j |}Wntj yjYq60|| | <q6t | dd| D}t}fdd|D}fdd|D}fdd|D}|D]\}}}|fdd|D||j||j}|D] } | |vr| | ||| <q|jj|d |||t ||||}|r|||||q||d S) zeapply values to objects derived from an update statement, e.g. UPDATE..SET cSsh|] \}}|qSrDrDrrDrDrF 5rNzDBulkORMUpdate._apply_update_set_values_to_objects..cs.h|]&}|jvr|jvr|jvr|qSrD)rXr'reffective_paramsrtr<rDrFr9s    cs"h|]}|jvrj|jqSrDr'rXrrUrDrFr@s csg|]}j|j|jfqSrDrrrUrDrFrMFszEBulkORMUpdate._apply_update_set_values_to_objects..csi|]\}}||qSrDrD)rKZ col_to_propZc_key)rrDrFrMszEBulkORMUpdate._apply_update_set_values_to_objects..N)rrrrr&r+rrrrrr"rmrrrlrVrrrIrmrrnrorprqaddZ_register_altered)rrirrrr|rzr{rrr)Zresolved_keys_as_propnamesZvalue_evaluatorsrXvalueZ _evaluatorZattribrvZ to_prefetchrvZprefetch_transferrrLrOrurDrrFrxs`             z1BulkORMUpdate._apply_update_set_values_to_objects)rrrrrr\rZr@rrrrrxrUrDrDrGrFrWs( b$ U $ *  5rWdeletec seZdZeddZeddddddd d fd d Zed d d d dddddddddddZeddZeddZZ S) BulkORMDeletecKsp||}|jdd}|dks4|dkrNd|jjvrNtj|||fi||S|j }|}|jjd}|j|_} |j||||d| } | jjd| ur| j | _| |j | } | r| j | } tj|| |fi|d} |sd} n|jdd} |jdd}|dur4| d ko2|j|j| |j|jd dd }|rLd } | j| jj} |rf|j||| | | d } | |_|S)NrrXrrr]Frrrr)rrTrK)rYrrrSr%r[rBr<r^rQrrr r_rrrr@rrr)rrrrErrrFrrr<r`rarrrrDrDrFrms        z"BulkORMDelete.create_for_statementr0z dml.Deleter5r+r.r3r;r<csL|d|j}|jdkr"td|jdvr6tdt||||||S)NrrczBulk 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')rrrrrrrAr@)rrirr\r9rr]rrGrDrFr@s    z#BulkORMDelete.orm_execute_statementFrrr|r:rcCsB|jo |jj}|sdS|r |jS|r>|js>td|jddS)NFrdz" 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_returningrreZdelete_returning_multifromrrSrrfrDrDrFrs   zBulkORMDelete.can_use_returningc CsZ|||j}g}|D],\}}} } | r<|| |jjq||q|rV||dSrC)rrjrwZ_expireZ _modifiedr_remove_newly_deleted) rrirrrr|Z to_deletercrLrOZis_partially_expiredrDrDrFrs z+BulkORMDelete._do_post_synchronize_evaluatec sj}|j}|r2||||}fdd|D}nj}|D]L} | dd} | d} |jt| | d} | |jvr<|t |j| gq.rrr) rrrrrkrmrjrr r) rrirrrrrrr2rrrrsrDr~rFr&s0   z(BulkORMDelete._do_post_synchronize_fetch) rrrrrr@rrrrUrDrDrGrFrks [  ( r)O__doc__ __future__rtypingrrrrrrr r r r rrrr(rrbaserrrrrrrZenginerrrsqlrrrrr r!Zsql.baser"r#r$Zsql.dmlr%r&r'r(Z util.typingr)Z_typingr*r+r,r<r-rir.r/r0r1rLr2r3r4Zengine.interfacesr5objectr6rGrrnrrZ plugin_forr4rWrrDrDrDrF s                                                     $  $"" " \x  i