a
    •˜ëjÀ  ã                   @  sî  d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm	Z	 dd	lm
Z
 dd
lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ  ddl!m"Z" ddl!m#Z# ddl!m$Z$ ddl!m%Z% dd l!m&Z& dd!l!m'Z' dd"l(m)Z) dd#l(m*Z* dd$l(m+Z+ dd%l,m-Z- dd&l,m.Z. dd'l,m/Z/ dd(lm0Z0 dd)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? dd3lm@Z@ dd4lmAZA dd5lBmCZC ed6eDd7�ZEe	d8d8d9œd:d;d<d=d=d=d>d?d@dAœ	dBdC„ƒZFe	d8d8d9œd:d;d<d=d=d=dDd?dEdAœ	dFdC„ƒZFdGdGd9œd:d;d<d=d=d=dDd?dHdAœ	dIdC„ZFe	d8dJdKœdLd;d<d=d=d>d=d@dMœdNdO„ƒZGe	d8dJdKœdLd;d<d=d=dPd=dQdMœdRdO„ƒZGdGdJdKœdLd;d<d=d=dPd=dSdMœdTdO„ZGdUdV„ ZHG dWdX„ dXeƒZIG dYdZ„ dZeIƒZJe* Kd[d\¡G d]d^„ d^eIe.ƒƒZLe* Kd[d_¡G d`da„ daeJe/ƒƒZMe* Kd[db¡G dcdd„ ddeJe-ƒƒZNdGS )ezoadditional 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_stmtÚexecution_optionsz
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_nullsr8   r9   Úreturnc                C  s   d S ©N© ©r<   r=   r>   r?   r@   rA   r8   r9   rD   rD   ú^/mnt/bigstor/www/usecases/.venv/lib/python3.9/site-packages/sqlalchemy/orm/bulk_persistence.pyÚ_bulk_insertJ   s    rG   zOptional[dml.Insert]zcursor.CursorResult[Any]c                C  s   d S rC   rD   rE   rD   rD   rF   rG   X   s    Nz"Optional[cursor.CursorResult[Any]]c                  s  ˆj }|jjrtdƒ‚|rbtr0tttt  ˆƒ‰|rRdd„ ˆD ƒ}	dd„ |	D ƒ‰q¢dd„ ˆD ƒ‰n@tr|ttt	t
tf  ˆƒ‰|rŠtˆƒ‰ndd„ ˆD ƒ‰tˆˆƒ | |¡‰ d }
‡fdd„|j ¡ D ƒ}|rÒd}nt|ƒd	kräd}nd
}|D ]¶\}}|d u�r‡fdd„| ¡ D ƒnd}‡ ‡fdd„tj|‡ ‡fdd„ˆD ƒd|||d�D ƒ}tj|d ||||||d�}|d urì|j�r‚|
d u �rˆ|}
qì|jrì|�s˜J ‚|
 |¡}
qì|�rô|�rôˆj}dd„ ˆjD ƒ}|	D ](\}‰|t‡fdd„|D ƒƒd f|_�qÊ|d u�r|
d u�sJ ‚|
S d S )NzJconnection_callable / per-instance sharding not supported in bulk_insert()c                 S  s   g | ]}||j f‘qS rD   ©Údict©Ú.0ÚstaterD   rD   rF   Ú
<listcomp>   ó    z _bulk_insert.<locals>.<listcomp>c                 S  s   g | ]\}}|‘qS rD   rD   )rK   rL   Údict_rD   rD   rF   rM   €   rN   c                 S  s   g | ]
}|j ‘qS rD   rH   rJ   rD   rD   rF   rM   ‚   rN   c                 S  s   g | ]}t |ƒ‘qS rD   rH   ©rK   ÚmrD   rD   rF   rM   –   rN   c                   s"   g | ]\}}|ˆ j v r||f‘qS rD   )Ú_pks_by_table)rK   ÚtableÚmp©r<   rD   rF   rM   �   s   
þTr   Fc                   s    g | ]}|j ˆ d  v r|j ‘qS ©r   ©Úkey©rK   Úb©r=   rD   rF   rM   ·   s   þrD   c           	   	   3  s2   | ]*\}}}}}}}}d ||ˆˆ |||fV  qd S rC   rD   )	rK   rL   Z
state_dictÚparamsrT   ÚconnZvalue_paramsZhas_all_pksZhas_all_defaults©Ú
connectionr<   rD   rF   Ú	<genexpr>À   s$   ïøz_bulk_insert.<locals>.<genexpr>c                 3  s   | ]}d |ˆˆ fV  qd S rC   rD   ©rK   Úmappingr^   rD   rF   r`   Ö   rN   )Úbulkr@   rA   Úinclude_bulk_keys)Úbookkeepingr8   r9   c                 S  s   g | ]
}|j ‘qS rD   rW   )rK   ÚprD   rD   rF   rM   ñ   rN   c                   s   g | ]}ˆ | ‘qS rD   rD   ©rK   rX   )rO   rD   rF   rM   õ   rN   )Úbase_mapperÚsessionÚconnection_callableÚNotImplementedErrorr	   r   r   r2   r6   r   Ústrr   ÚlistÚ_expand_compositesr_   Ú_sorted_tablesÚitemsÚlenÚ_get_embedded_bindparamsr   Z_collect_insert_commandsZ_emit_insert_statementsÚ
_returningZreturns_rowsZsplice_horizontallyZ_identity_classÚ_identity_key_propsÚtuplerX   )r<   r=   r>   r?   r@   rA   r8   r9   rh   ÚstatesZreturn_resultZmappers_to_runre   rS   Úsuper_mapperÚextra_bp_namesÚrecordsr   Zidentity_clsZidentity_propsrL   rD   )r_   rO   r<   r=   rF   rG   f   s�    ÿ



þûþù
úìø

ý

T)Úuse_orm_update_stmtÚenable_check_rowcountúMapper[Any])r<   r=   r>   r?   Úupdate_changed_onlyrz   r{   rB   c                C  s   d S rC   rD   ©r<   r=   r>   r?   r}   rz   r{   rD   rD   rF   Ú_bulk_updateþ   s    
r   zOptional[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 }ˆj‰ˆjr"ˆjjh ˆ¡‰‡fdd„‰ |r\|rL‡ ‡fdd„ˆD ƒ‰qtdd„ ˆD ƒ‰ndd„ ˆD ƒ‰tˆˆƒ |jjr„tdƒ‚| 	|¡‰|d ur¬‡fdd„| 
¡ D ƒnd	}|j ¡ D ]^\}	}
ˆ |
¡rº|	ˆjvrØqºtjd |	‡‡fd
d„ˆD ƒd||d�}tj|d |
|	|d||d� qº|d u�r,t ¡ S d S )Nc                   s   ‡‡ fdd„ˆ j  ¡ D ƒS )Nc                   s(   i | ] \}}|ˆj v s|ˆ v r||“qS rD   )Zcommitted_state©rK   ÚkÚv)Úsearch_keysrL   rD   rF   Ú
<dictcomp>)  s   þz7_bulk_update.<locals>._changed_dict.<locals>.<dictcomp>)rI   rp   )r<   rL   )rƒ   )rL   rF   Ú_changed_dict(  s    þz#_bulk_update.<locals>._changed_dictc                   s   g | ]}ˆ ˆ|ƒ‘qS rD   rD   rJ   )r…   r<   rD   rF   rM   1  rN   z _bulk_update.<locals>.<listcomp>c                 S  s   g | ]
}|j ‘qS rD   rH   rJ   rD   rD   rF   rM   3  rN   c                 S  s   g | ]}t |ƒ‘qS rD   rH   rP   rD   rD   rF   rM   5  rN   zJconnection_callable / per-instance sharding not supported in bulk_update()c                   s    g | ]}|j ˆ d  v r|j ‘qS rV   rW   rY   r[   rD   rF   rM   C  s   þrD   c                 3  s.   | ]&}d |ˆˆ ˆj r |ˆj j nd fV  qd S rC   )Ú_version_id_proprX   ra   r^   rD   rF   r`   S  s   öÿøz_bulk_update.<locals>.<genexpr>T)rc   rz   rd   F)re   rz   r{   )rh   Z_primary_key_propkeysr†   rX   Úunionrn   ri   rj   rk   r_   rr   ro   rp   ÚisarR   r   Z_collect_update_commandsZ_emit_update_statementsÚ_resultÚnull_result)r<   r=   r>   r?   r}   rz   r{   rh   rx   rS   rw   ry   rD   )r…   r_   r<   r=   rƒ   rF   r     s^    

ÿ

ûþù
ôíø
c                   sV   | j ‰ ˆ sd S tˆ  ¡ ƒ}‡ fdd„|D ƒ}|D ] }| |¡D ]}|| |ƒ q>q0d S )Nc                   s   i | ]}|ˆ |   ¡ “qS rD   )Z)_populate_composite_bulk_save_mappings_fnrg   ©Zcomposite_attrsrD   rF   r„   z  s   ÿz&_expand_composites.<locals>.<dictcomp>)Z
compositesÚsetÚkeysÚintersection)r<   r=   Zcomposite_keysZ
populatorsrb   rX   rD   r‹   rF   rn   t  s    
þrn   c                   @  s€   e Zd ZU dZdZded< edd„ ƒZedd„ ƒZed	d
„ ƒZ	edd„ ƒZ
edd„ ƒZedd„ ƒZddœdd„Zedd„ ƒZdS )ÚORMDMLStateTNz&Optional[ORMFromStatementCompileState]Úfrom_statement_ctxc                 c  sô   t j}|D ]ä\}}t tj|¡}t|tƒrŒt||t	d�}|t	u rrt tj|¡|rhtjtj
|t ¡ dd�n|fV  qî||| |¡|ƒE d H  q
d|jv rÈ|j}	t|	d |	d ƒ}
|||
 |¡|ƒE d H  q
||sÒ|ntjtj
|t ¡ dd�fV  q
d S )N)ÚdefaultT)Útype_Zis_crudZentity_namespaceÚ	proxy_key)r'   Ú_get_crud_kv_pairsr   Úexpectr   ZDMLColumnRoleÚ
isinstancerl   r"   r   ÚExpressionElementRoler!   ZNullTypeZ_bulk_update_tuplesÚ_annotations)Úclsr<   Ú	statementÚkv_iteratorÚneeds_to_be_cacheableZcore_get_crud_kv_pairsr�   r‚   ÚdescZk_annoÚattrrD   rD   rF   Ú_get_orm_crud_kv_pairs‡  sR    
úüöý
ÿýÿüûz"ORMDMLState._get_orm_crud_kv_pairsc                 C  s.   |j j d¡}|r&|jr&||jd ur*d S |S )NÚplugin_subject)rS   Ú_propagate_attrsÚgetr<   )r™   rš   r    rD   rD   rF   Ú_get_dml_plugin_subject¿  s    ÿþÿýz#ORMDMLState._get_dml_plugin_subjectc                   s0   ˆ   ˆ¡‰ˆst ˆ|¡S ‡ ‡‡fdd„|D ƒS )Nc              	     s&   g | ]}t ˆ  ˆjˆ| ¡ d ¡ƒ‘qS )F)rI   rŸ   r<   rp   )rK   Z
value_dict©r™   r    rš   rD   rF   rM   Õ  s   ûÿÿz8ORMDMLState._get_multi_crud_kv_pairs.<locals>.<listcomp>)r£   r'   Ú_get_multi_crud_kv_pairs)r™   rš   r›   rD   r¤   rF   r¥   Ì  s    
ÿúz$ORMDMLState._get_multi_crud_kv_pairsc                 C  s>   |sJ dƒ‚|   |¡}|s(t |||¡S t|  |j|||¡ƒS )Nz0no test coverage for needs_to_be_cacheable=False)r£   r'   r”   rm   rŸ   r<   )r™   rš   r›   rœ   r    rD   rD   rF   r”   Þ  s"    ÿþ
ÿüÿzORMDMLState._get_crud_kv_pairsc                 C  s@   |j jd }|j}|jr |j}n|jj}||j|j|j|jdœS )NÚparententity)ÚnameÚtypeÚexprÚentityrS   )	rS   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   dd„ ‰dd„ ‰ ‡ fdd„‡fdd„|j D ƒD ƒS )Nc                 S  s   | j  dd ¡S )Nr¦   )r˜   r¢   )ÚcrD   rD   rF   Ú_ent_for_col  s    zCORMDMLState.get_returning_column_descriptions.<locals>._ent_for_colc                 S  s4   |d u r| S | j  dd ¡}|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|jd œ‘qS ))r§   r¨   r©   Úaliasedrª   )rX   r¨   r«   rª   )rK   r±   r´   )rµ   rD   rF   rM     s   úûzAORMDMLState.get_returning_column_descriptions.<locals>.<listcomp>c                   s   g | ]}|ˆ |ƒf‘qS 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 r¦t|j |dd�}|jf i |j¤Ž}|j|jŽ }|| _t ||¡ | _	}| 
|¡ | ¡ }d|_ dd„ |jD ƒ}|s„| |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 ur|‘qS rC   rD   r·   rD   rD   rF   rM   D  rN   z4ORMDMLState._setup_orm_returning.<locals>.<listcomp>Zsupplemental_cols)rs   r   r9   Ú_execution_optionsÚoptionsÚ_with_optionsÚselect_statementr   Úcreate_for_statementr�   Z!setup_dml_returning_compile_stateZ	_generateZprimary_columnsÚextendÚprimary_keyr@   Z	returning)	ÚselfÚcompilerÚorm_level_statementZdml_level_statementÚ
dml_mapperr¹   ÚfsZfscZcols_to_returnrD   rD   rF   Ú_setup_orm_returning  s6    ý
ÿ
ôóÿz ORMDMLState._setup_orm_returningc              	   C  sZ   |j }|jj}|jrR|jjjsR| dtj¡}	t|j|j	||||	||ƒ}
t
 ||
¡S |S d S )NÚ_sa_orm_load_options)r   ZcompiledÚcompile_stater�   Úcompile_optionsÚ_is_starr¢   r   Údefault_load_optionsr½   r   Z	instances)r™   ri   rš   r\   r9   Úbind_argumentsr   Zexecution_contextrÈ   Úload_optionsZquerycontextrD   rD   rF   Ú_return_orm_returningb  s*    
ÿþÿø
z!ORMDMLState._return_orm_returning)r­   Ú
__module__Ú__qualname__Zis_dml_returningr�   Ú__annotations__ÚclassmethodrŸ   r£   r¥   r”   r°   r¸   rÆ   rÎ   rD   rD   rD   rF   r�   ƒ  s$   

7




!ùCr�   c                
   @  sÊ   e Zd ZG dd„ deƒZedddddœddddddddœd	d
„ƒZedd„ ƒZedd„ ƒZedd„ ƒZ	edd„ ƒZ
edd„ ƒZedd„ ƒZedd„ ƒZedd„ ƒZedd„ ƒZedd„ ƒZedd „ ƒZd!S )"ÚBulkUDCompileStatec                   @  s~   e Zd ZU dZded< dZded< dZded< dZded	< dZded
< dZ	ded< dZ
ded< eZdZdZdZdZded< dS )z)BulkUDCompileState.default_update_optionsÚautor*   Ú_dml_strategyr,   Ú_synchronize_sessionFr:   Ú_can_use_returningÚ_is_delete_usingÚ_is_update_fromTÚ
_autoflushNúOptional[Mapper[Any]]Ú_subject_mapperÚ_populate_existing)r­   rÏ   rÐ   rÕ   rÑ   rÖ   r×   rØ   rÙ   rÚ   rÜ   r(   Ú_resolved_valuesÚ_eval_conditionÚ_matched_rowsÚ_identity_tokenrÝ   rD   rD   rD   rF   Údefault_update_options‡  s   
râ   F©Úis_multitableÚis_update_fromÚis_delete_usingÚis_executemanyr   r|   r:   ©Údialectr<   rä   rå   ræ   rç   rB   c                C  s
   t ƒ ‚d S rC   )rk   )r™   ré   r<   rä   rå   ræ   rç   rD   rD   rF   Úcan_use_returning•  s    z$BulkUDCompileState.can_use_returningc           
      C  s  t j dh d£||j¡\}}||d< z|jd }W n tyP   dsLJ dƒ‚Y n0 |rn|j|d< |d|ji7 }d	|jjvrˆ|d
di7 }nNt	|t
ƒsÀ|jdkrª|d
di7 }qÖ|jdkrÖt d¡‚n|jdkrÖ|d
di7 }|j}	|	d u�r|	dvrøt d¡‚|jdk�r|	dk�rt d¡‚|�sþ|j�r.| ¡  |jdk�r |jdk�r\|  ||||||¡}nB|jdk�r~|  ||||||¡}n |jdk�rÄ|  ||||||¡}n$|jdk�rÄ|jdk�rÄ|ddi7 }| |j|j|j|j|jdœ¡}|�sòtj}n| tj¡}|t |¡ d|i¡fS )NÚ_sa_orm_update_options>   Ú	autoflushrå   Úidentity_tokenræ   Úsynchronize_sessionÚdml_strategyÚpopulate_existingÚclauser    Fú0statement had 'orm' plugin but no plugin_subjectr<   rÜ   r¦   rÕ   Ú	core_onlyrÔ   Úormrc   ú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_optionsrº   r¡   ÚKeyErrorr<   rS   r˜   r–   rm   rÕ   Úsa_excÚInvalidRequestErrorrÖ   ÚArgumentErrorrÚ   Ú_do_pre_synchronize_autoÚ_do_pre_synchronize_evaluateÚ_do_pre_synchronize_fetchÚ	_annotaterØ   rÙ   r×   r   Ú_orm_load_exec_optionsr‡   r   Úimmutabledict)
r™   ri   rš   r\   r9   rÌ   Úis_pre_eventÚupdate_optionsr    ÚsyncrD   rD   rF   Úorm_pre_session_exec¢  s´    	ôý



ÿ

ÿÿúúúûÿÿ
ÿþz'BulkUDCompileState.orm_pre_session_execc                 C  s†   |d }|j dkrJ|jdkr.|  ||||¡ qr|jdkrr|  ||||¡ n(|j dkrr|jdkrn|  ||||¡ |S |  ||||||¡S )Nrë   rô   rö   r÷   rc   )rÕ   rÖ   Ú_do_post_synchronize_evaluateÚ_do_post_synchronize_fetchÚ"_do_post_synchronize_bulk_evaluaterÎ   )r™   ri   rš   r\   r9   rÌ   r   r  rD   rD   rF   Úorm_setup_cursor_result+  s0    

ÿ
ÿ

ÿúz*BulkUDCompileState.orm_setup_cursor_resultc                   s~   d}ˆj rˆjnd‰ dˆjf|v rF|t‡fdd„|dˆjf D ƒƒ7 }ˆjjdur`|ˆjjf7 }ˆ rzt‡ fdd„|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   NZadditional_entity_criteriac                 3  s(   | ] }|j s|jˆ u r| ˆ ¡V  qd S rC   )Zinclude_aliasesrª   Z_resolve_where_criteria)rK   Zae)r¯   rD   rF   r`   l  s   üz@BulkUDCompileState._adjust_for_extra_criteria.<locals>.<genexpr>c                 3  s   | ]}ˆ   |¡V  qd S rC   )Útraverse)rK   Úcrit)ÚadapterrD   rF   r`   x  rN   )r«   Z_adapterr<   ru   Z_single_table_criterion)r™   Úglobal_attributesr¯   Zreturn_critrD   )r  r¯   rF   Ú_adjust_for_extra_criteriaW  s"    þýÿþ
z-BulkUDCompileState._adjust_for_extra_criteriac                   sX   z.|j |jj ur | |j j¡‰ n| |j¡‰ W n tyD   g  Y S 0 ‡ fdd„|D ƒS )aÚ  return 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.

        c                   s   g | ]}ˆ |ƒ‘qS rD   rD   ©rK   Úrow©Úpk_keysrD   rF   rM   �  rN   z@BulkUDCompileState._interpret_returning_rows.<locals>.<listcomp>)r®   rh   Z_tuple_getterrÀ   rù   )r™   r   r<   ÚrowsrD   r  rF   Ú_interpret_returning_rows|  s    
z,BulkUDCompileState._interpret_returning_rowsc           
        sˆ   |j ‰|j}‡fdd„|D ƒ}|j‰ ˆ d ur>‡ fdd„|D ƒ}g }|D ]<\}}}||ƒ}	|	du sj|	tju rF| ||||	tju f¡ qF|S )Nc                   s.   g | ]&}|j  ˆ ¡r|js| ¡ ||jf‘qS rD   )r<   rˆ   ZexpiredÚobjrI   rJ   rU   rD   rF   rM   ¤  s   þzGBulkUDCompileState._get_matched_objects_on_criteria.<locals>.<listcomp>c                   s&   g | ]\}}}|j ˆ kr|||f‘qS rD   ©rí   )rK   r  rL   rO   r  rD   rF   rM   ¬  s   
þT)rÜ   rß   rá   r   Z_EXPIRED_OBJECTÚappend)
r™   r  rv   Úeval_conditionÚraw_datar   r  rL   rO   Zevaled_conditionrD   )rí   r<   rF   Ú _get_matched_objects_on_criteriaŸ  s2    
þ
þÿþüÿz3BulkUDCompileState._get_matched_objects_on_criteriac                 C  s~   |j }|j}t |¡}d}|jr*||j7 }i }|jD ]}|jr4| |¡ q4|r^||  ||¡7 }|rn|j	|Ž }	ndd„ }
|
}	|	S )NrD   c                 S  s   dS )NTrD   )r  rD   rD   rF   rß   Ü  s    zJBulkUDCompileState._eval_condition_from_statement.<locals>._eval_condition)
rÜ   r¬   r   Ú_EvaluatorCompilerÚ_where_criteriar¼   Z_is_criteria_optionZget_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  sT   z|   ||¡}W n tjy$   Y n0 ||ddœ S |ddi7 }|  ||||||¡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™   ri   rš   r\   r9   rÌ   r  r  rD   rD   rF   rý   ã  s&    ÿþúz+BulkUDCompileState._do_pre_synchronize_autoc           	   
   C  sT   z|   ||¡}W n6 tjyF } zt d| ¡|‚W Y d }~n
d }~0 0 |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™   ri   rš   r\   r9   rÌ   r  r  ÚerrrD   rD   rF   rþ     s    
ÿþÿüÿz/BulkUDCompileState._do_pre_synchronize_evaluatec                 C  s6   |j r
g S |jrt|jƒS |jr.t|j ¡ ƒS g S d S rC   )Z_multi_valuesÚ_ordered_valuesrm   Ú_valuesrp   )r™   r<   rš   rD   rD   rF   Ú_get_resolved_values-  s    
z'BulkUDCompileState._get_resolved_valuesc              	   C  sj   g }|D ]\\}}|rVt |tjƒrVz|j| }W n tjyB   Y qd0 | |j|f¡ qt 	d| ¡‚q|S )NzCAttribute name not found, can't be synchronized back to objects: %r)
r–   r   ZColumnElementÚ_columntopropertyÚorm_excZUnmappedColumnErrorr  rX   rú   rû   )r™   r<   Úresolved_valuesÚvaluesr�   r‚   rž   rD   rD   rF   Ú_resolved_keys_as_propnames8  s    ÿÿz.BulkUDCompileState._resolved_keys_as_propnamesc                   sv   ˆj ‰tˆjˆjf Ž  ˆ¡j|jŽ }|j|_d ‰ dddœ‡ ‡‡‡fdd„}|j|||||d�}	|	 	¡ }
ˆ|
ˆ dœ S )Nr/   r   )Úorm_contextrB   c                   sz   | j jf i | j¤Ž}ˆj|jˆˆjˆj| jd�}ˆ d urLˆ |krft 	d¡‚n| jrb|sbt 	d¡‚n|‰ |rrt
 ¡ 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'tz‚For synchronize_session='fetch', can't use multiple parameter sets in ORM mode, which this backend does not support with RETURNING)ri   Zget_bindrÌ   rê   ré   rÙ   rØ   rç   rú   rû   r‰   rŠ   )r-  ÚbindZper_bind_result©rê   r™   r<   r  rD   rF   Úskip_for_returningl  s*    ûÿ
ÿzHBulkUDCompileState._do_pre_synchronize_fetch.<locals>.skip_for_returning)r9   rÌ   Z
_add_event)rà   r×   )
rÜ   r    rÀ   Zselect_identity_tokenÚselect_fromr»   r¼   r  ÚexecuteZfetchall)r™   ri   rš   r\   r9   rÌ   r  Zselect_stmtr0  r   Úmatched_rowsrD   r/  rF   rÿ   J  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<   ø 
 	
+
$
"
&

/



rÓ   rô   Úinsertc                	      sŠ   e Zd ZU G dd„ deƒZdZded< edd„ ƒZedd	d
dddddœdd„ƒZ	ed dœ‡ fdd„ƒZ
edd„ ƒZdd„ Zdd„ Z‡  ZS )ÚBulkORMInsertc                   @  sV   e Zd ZU dZded< dZded< dZded< dZd	ed
< dZded< dZ	ded< dS )z$BulkORMInsert.default_insert_optionsrÔ   r*   rÕ   Fr:   Ú_render_nullsÚ_return_defaultsNrÛ   rÜ   TrÚ   rÝ   )
r­   rÏ   rÐ   rÕ   rÑ   r6  r7  rÜ   rÚ   rÝ   rD   rD   rD   rF   Údefault_insert_optionsž  s   
r8  NzOptional[FromStatement]r½   c           	      C  s  t j dh d£||j¡\}}||d< z|jd }W n tyP   dsLJ dƒ‚Y n0 |rn|j|d< |d|ji7 }|s |jd	krŠ|d
di7 }q¶|jdkr¶t 	d¡‚n|jd	kr¶|d
di7 }|jdkrØ|sÌt
j}n| t
j¡}|sê|jrê| ¡  | d|ji¡}|t |¡ d|i¡fS )NÚ_sa_orm_insert_options>   rï   rì   rð   rA   rñ   r    Frò   r<   rÜ   rÔ   rÕ   rô   rc   rõ   Úrawrï   )r5  r8  rø   rº   r¡   rù   r<   rÕ   rú   rû   r   r  r‡   rÚ   r   r   r  )	r™   ri   rš   r\   r9   rÌ   r  Úinsert_optionsr    rD   rD   rF   r  ¨  sT    üý


ÿ

ÿ
ÿ
ÿþz"BulkORMInsert.orm_pre_session_execr0   z
dml.Insertr5   r+   r.   r3   ú_result.Result©ri   rš   r\   r9   rÌ   r]   rB   c              
   C  s<  |  d| j¡}|jdvr"t d¡‚|jdkrD|j||p8i |d�}|S |jdkrÄ|j}	|jd urt|	jrtt 	d|	› �¡‚|	d us€J ‚|j
d usŽJ ‚t|	tdt|tƒr¦|gn|ƒ|j
d	|j|j||d
�}n&|jdkrä|j||pÚi |d�}ntƒ ‚t|jƒsø|S |j�r(|  dtj¡}
|
ddi7 }
| d|
i¡}|  ||||||¡S )Nr9  )r:  rc   rô   rÔ   zHValid strategies for ORM insert strategy are 'raw', 'orm', 'bulk', 'autor:  )r9   rc   z`bulk INSERT with a 'post values' clause (typically upsert) not supported for multi-table mapper úIterable[Dict[str, Any]]F)r?   r@   rA   r8   r9   rô   rÇ   rÝ   T)r¢   r8  rÕ   rú   rü   r2  rÜ   Z_post_values_clauseZ_multiple_persistence_tablesrû   Ú_transactionrG   r   r–   rI   r7  r6  ÚAssertionErrorr:   rs   rÝ   r   rË   r‡   rÎ   )r™   ri   rš   r\   r9   rÌ   r]   r;  r   r<   rÍ   rD   rD   rF   Úorm_execute_statementì  sz    
ÿ
ÿ

ÿ
ÿþþÿþõ

ÿ
ÿÿúz#BulkORMInsert.orm_execute_statement)rB   c                   s~   t ttƒ j||fi |¤Žƒ}|d ur.|j }nd}|s:|S |jd }|j dd¡}|dkrf| |¡ n|dkrz| 	||¡ |S )NTr    rï   r:  rc   rô   )
r   r5  Úsuperr¾   Ústackr¡   r˜   r¢   Ú_setup_for_bulk_insertÚ_setup_for_orm_insert)r™   rš   rÂ   ÚkwrÁ   Útoplevelr<   rï   ©Ú	__class__rD   rF   r¾   E  s     þ

z"BulkORMInsert.create_for_statementc                   s    dd„ ‡ fdd„|  ¡ D ƒD ƒS )Nc                 S  s&   i | ]\}}}|d ur|j n||“qS rC   rW   )rK   Úcolr�   r‚   rD   rD   rF   r„   ^  s   ÿz<BulkORMInsert._resolved_keys_as_col_keys.<locals>.<dictcomp>c                 3  s$   | ]\}}ˆ j  |¡||fV  qd S rC   )r±   r¢   r€   rU   rD   rF   r`   `  s   z;BulkORMInsert._resolved_keys_as_col_keys.<locals>.<genexpr>)rp   )r™   r<   Zresolved_value_dictrD   rU   rF   Ú_resolved_keys_as_col_keys\  s
    
ÿþz(BulkORMInsert._resolved_keys_as_col_keysc                 C  s0   t tj| jƒ }}| j||||dd�}|| _d S )NF©rÄ   r¹   )r   r   ÚInsertrš   rÆ   )rÁ   rÂ   r<   rš   rÃ   rD   rD   rF   rE  e  s    ûz#BulkORMInsert._setup_for_orm_insertc                   s”   t tj| jƒ }}|j}|d |d  ‰ }| ¡ }ˆ |_| jrX‡ fdd„| j ¡ D ƒ| _| j	||||dd�}| j
durŠ| j
jjrŠt d¡‚|| _dS )	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 ˆ u r||“qS rD   ©rS   ©rK   rJ  Úval©Zemit_insert_tablerD   rF   r„   …  s   
þz8BulkORMInsert._setup_for_bulk_insert.<locals>.<dictcomp>TrL  NzˆCan't use RETURNING * with bulk ORM INSERT.  Please use a different INSERT form, such as INSERT..VALUES or INSERT with a Core Connection)r   r   rM  rš   r˜   Ú_clonerS   Ú_dict_parametersrp   rÆ   r�   rÉ   rÊ   rú   ÚCompileError)rÁ   rÂ   rš   rÃ   ÚanZemit_insert_mapperrD   rQ  rF   rD  q  s4    þ
þû	ÿþÿz$BulkORMInsert._setup_for_bulk_insert)r­   rÏ   rÐ   r$   r8  r½   rÑ   rÒ   r  rA  r¾   rK  rE  rD  Ú__classcell__rD   rD   rH  rF   r5  œ  s   

CX
r5  Úupdatec                
      s¨   e Zd Zedd„ ƒZdd„ Zdd„ Zeddd	d
ddddœ‡ fdd„ƒZedddddœddddddddœdd„ƒZedd„ ƒZ	edd„ ƒZ
edd„ ƒZedd „ ƒZ‡  ZS )!ÚBulkORMUpdatec                 K  sŠ   |   | ¡}|j dd¡}|j }|r:|dkr:| ||¡ nL|dksV|dkrnd|jjvrntj|||fi |¤Ž n|rz|dv r†| ||¡ |S )Nrï   Úunspecifiedrc   ró   r¦   )rô   rY  )	Ú__new__r˜   r¢   rC  Ú_setup_for_bulk_updaterS   r'   Ú__init__Ú_setup_for_orm_update)r™   rš   rÂ   rF  rÁ   rï   rG  rD   rD   rF   r¾   ¢  s"    
ÿÿþ
ýz"BulkORMUpdate.create_for_statementc                 K  s^  |}|j  }|jjd }|j | _}|  ||¡| _| j||||d� |jrVt| jƒ| _| 	¡ }|jjd |u rv|j
|_|jr†| j|_n|jr”| j|_|  | j|¡}	|	r°|j|	Ž }tj| ||fi |¤Ž d}
|sÔd }n|j dd ¡}|j dd ¡}|du�r|dk�o| j|j|| jd�}|dk�r:|�r:d}
|j|jjŽ }|�rT| j|||||
d	�}|| _d S )
Nr¦   ©rG  Zprocess_criteria_for_toplevelFrî   rê   r÷   )rä   TrL  )rC  rS   r˜   r<   r'  rÞ   Ú_init_global_attributesr&  rI   rR  r®   r%  r  r  Úwherer'   r\  r¢   rê   ré   rä   r@   rÀ   rÆ   rš   )rÁ   rš   rÂ   rF  rÃ   rG  r¯   r<   Únew_stmtÚnew_critr¹   rî   rê   rD   rD   rF   r]  ¹  sj    ü
ÿ
ÿÿ


ÿþûz#BulkORMUpdate._setup_for_orm_updatec                   s‚   t tj|ƒ}|j}|d |d  ‰ }| ¡ }ˆ |_tj| ||fi |¤Ž | jrXt	 
d¡‚| jrx‡ fdd„| j ¡ D ƒ| _|| _dS )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_mapperzšbulk 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 ˆ u r||“qS rD   rN  rO  ©Zemit_update_tablerD   rF   r„   8  s   
þz8BulkORMUpdate._setup_for_bulk_update.<locals>.<dictcomp>N)r   r   ZUpdater˜   rR  rS   r'   r\  r%  rú   rû   rS  rp   rš   )rÁ   rš   rÂ   rF  rU  Ú_rD   rc  rF   r[    s"    þÿ
þz$BulkORMUpdate._setup_for_bulk_updater0   z
dml.Updater5   r+   r.   r3   r<  r=  c              	     s  |  d| j¡}|jr<|  dtj¡}|ddi7 }| d|i¡}|jdvrPt d¡‚|jdkrì|j	 }	|j
dkspJ ‚|j	rŠ|j
d	krŠt d
¡‚|j}
|
d usœJ ‚|jd usªJ ‚t|
tdt|tƒrÂ|gn|ƒ|jdd||	d�}|  ||||||¡S tƒ  ||||||¡S d S )Nrë   rÇ   rÝ   T)rô   rÔ   rc   ró   zOValid strategies for ORM UPDATE strategy are 'orm', 'auto', 'bulk', 'core_only'rc   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.r>  F)r?   r}   rz   r{   )r¢   râ   rÝ   r   rË   r‡   rÕ   rú   rü   r  rÖ   rû   rÜ   r?  r   r   r–   rI   r
  rB  rA  )r™   ri   rš   r\   r9   rÌ   r]   r  rÍ   r{   r<   r   rH  rD   rF   rA  ?  sp    ÿÿÿ
ÿ
ÿþÿþöú	úz#BulkORMUpdate.orm_execute_statementFrã   r   r|   r:   rè   c                C  sL   |j o|jj}|sdS |r |jS |r*|jS |rH|jsHt d|j› d�¡‚dS )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)Zupdate_returningr®   Úimplicit_returningZupdate_executemany_returningZupdate_returning_multifromrú   rT  r§   ©r™   ré   r<   rä   rå   ræ   rç   Znormal_answerrD   rD   rF   rê   •  s    ÿ
ÿzBulkORMUpdate.can_use_returningc                   sÞ   |sd S |j }dd„ |jD ƒ}|j}|D ]°‰ | ‡ fdd„|D ƒ|j¡}| |¡}	|	sXq(tˆ ƒ |¡}
|	j}|	j	 
|
¡}|D ]}||v r|ˆ | ||< q||	jj |	d |¡ |	 |t|ƒ¡ |
 
|¡ |¡}|r(|	 ||¡ q(d S )Nc                 S  s   g | ]
}|j ‘qS rD   rW   )rK   ÚproprD   rD   rF   rM   Â  rN   zDBulkORMUpdate._do_post_synchronize_bulk_evaluate.<locals>.<listcomp>c                 3  s   | ]}ˆ | V  qd S rC   rD   rg   ©ÚparamrD   rF   r`   È  rN   zCBulkORMUpdate._do_post_synchronize_bulk_evaluate.<locals>.<genexpr>)rÜ   rt   Úidentity_mapÚidentity_key_from_primary_keyrá   Zfast_get_staterŒ   Ú
differencerI   Ú
unmodifiedrŽ   ÚmanagerÚdispatchÚrefreshÚ_commitrm   Ú_expire_attributes)r™   ri   r\   r   r  r<   r  rk  Úidentity_keyrL   Úevaluated_keysrO   Úto_evaluaterX   Ú	to_expirerD   ri  rF   r	  º  s4    þ

ÿz0BulkORMUpdate._do_post_synchronize_bulk_evaluatec              
   C  sF   |   ||j ¡ ¡}|  ||||jjd dd„ |D ƒ| ¡ | ¡ ¡ d S )Nr   c                 S  s   g | ]\}}}}|||f‘qS rD   rD   )rK   r  rL   rO   rd  rD   rD   rF   rM   ó  rN   z?BulkORMUpdate._do_post_synchronize_evaluate.<locals>.<listcomp>)r  rk  Ú
all_statesÚ#_apply_update_set_values_to_objectsr   Úcompiled_parametersÚprefetch_colsÚpostfetch_cols)r™   ri   rš   r   r  Úmatched_objectsrD   rD   rF   r  å  s    þ
ùz+BulkORMUpdate._do_post_synchronize_evaluatec           	   
     s    ˆj ‰|j}|r2|  |ˆ|¡}‡fdd„|D ƒ}nˆj}‡ fdd„‡‡fdd„dd„ |D ƒD ƒD ƒ}|sld S |  ˆ ˆ||jjd dd„ |D ƒ| ¡ | ¡ ¡ d S )Nc                   s   g | ]}t |ƒˆ jf ‘qS rD   ©ru   rá   r  ©r  rD   rF   rM     s   ÿz<BulkORMUpdate._do_post_synchronize_fetch.<locals>.<listcomp>c                   s    g | ]}|ˆ j v rˆ j | ‘qS rD   )rk  )rK   rt  )ri   rD   rF   rM   
  s   
ôc                   s6   g | ].\}}ˆj d u s |ˆj krˆ jt|ƒ|d�‘qS )Nr  )rá   rl  rm   )rK   rÀ   rí   )Útarget_mapperr  rD   rF   rM     s   

øþc                 S  s    g | ]}|d d… |d f‘qS )r   éÿÿÿÿrD   r  rD   rD   rF   rM     s   r   c                 S  s"   g | ]}|t  |¡t  |¡f‘qS rD   )r   Úinstance_stateÚinstance_dict)rK   r  rD   rD   rF   rM   "  s
   üý)	rÜ   Úreturned_defaults_rowsr  rà   ry  r   rz  r{  r|  )	r™   ri   rš   r   r  r„  Úpk_rowsr3  ÚobjsrD   )ri   r€  r  rF   r  ø  s<    ÿ
þ
ÿûþ
úòz(BulkORMUpdate._do_post_synchronize_fetchc              	     sš  |j ‰ˆj}t |¡}	|  ˆ|¡}
|  ˆ|
¡}i }|D ]>\}}z|	 t t	j
|¡¡}W n tjyj   Y q60 |||< q6t| ¡ ƒ‰dd„ |D ƒ}tƒ }‡ ‡‡fdd„|D ƒ}‡fdd„|D ƒ ˆ¡}‡fdd„|D ƒ}|D ]°\}}}| ‡ fdd„|D ƒ¡ | |j|¡ |j ˆ¡}|D ] }||v �r|| |ƒ||< �q|jj |d	|¡ | |t|ƒ¡ | |¡ |¡}|�r€| ||¡ | |¡ qÚ| |¡ d	S )
zeapply values to objects derived from an update statement, e.g.
        UPDATE..SET <values>

        c                 S  s   h | ]\}}|’qS rD   rD   r€   rD   rD   rF   Ú	<setcomp>Q  rN   zDBulkORMUpdate._apply_update_set_values_to_objects.<locals>.<setcomp>c                   s.   h | ]&}|j ˆ v r|ˆjv r|j ˆvr|’qS rD   )rX   r(  r·   ©Úeffective_paramsru  r<   rD   rF   r‡  U  s
   


üc                   s"   h | ]}|ˆ j v rˆ j | j’qS rD   ©r(  rX   r·   rU   rD   rF   r‡  \  s   
þc                   s   g | ]}ˆ j | j|jf‘qS rD   rŠ  r·   rU   rD   rF   rM   b  s   zEBulkORMUpdate._apply_update_set_values_to_objects.<locals>.<listcomp>c                   s   i | ]\}}|ˆ | “qS rD   rD   )rK   Zcol_to_propZc_key)r‰  rD   rF   r„   i  s   ÿzEBulkORMUpdate._apply_update_set_values_to_objects.<locals>.<dictcomp>N)rÜ   r¬   r   r  r'  r,  r  r   r•   r   r—   r#  rm   r�   rŒ   rm  rW  rs  rI   rn  rŽ   ro  rp  rq  rr  ÚaddZ_register_altered)r™   ri   r  rš   r‰  r}  r{  r|  r  r   r*  Zresolved_keys_as_propnamesZvalue_evaluatorsrX   ÚvalueZ
_evaluatorÚattribrv   Zto_prefetchrw  Zprefetch_transferr  rL   rO   rv  Zformerly_modifiedrD   rˆ  rF   ry  .  sd    
ÿÿ
þ
þü
ÿ
þÿ

ÿz1BulkORMUpdate._apply_update_set_values_to_objects)r­   rÏ   rÐ   rÒ   r¾   r]  r[  rA  rê   r	  r  r  ry  rV  rD   rD   rH  rF   rX     s(   
b$ Uø $
*

5rX  Údeletec                
      s€   e Zd Zedd„ ƒZeddddddd	d
œ‡ fdd„ƒZedddddœddddddddœdd„ƒZedd„ ƒZedd„ ƒZ‡  Z	S )ÚBulkORMDeletec                 K  sp  |   | ¡}|j dd¡}|dks4|dkrNd|jjvrNtj|||fi |¤Ž |S |j }|}|jjd }|j |_}	|j||||d� | 	¡ }
|
jjd |	u r¤|	j
|
_|  |j|	¡}|rÀ|
j|Ž }
tj||
|fi |¤Ž d}|säd }n|j dd ¡}|j dd ¡}|du�r4|d	k�o2|j|j|	|j|j d
d¡d�}|�rLd}|
j|
jjŽ }
|�rf|j|||
|	|d�}
|
|_|S )Nrï   rY  ró   r¦   r^  Frî   rê   r÷   ræ   )rä   ræ   TrL  )rZ  r˜   r¢   rS   r%   r\  rC  r<   r_  rR  r®   r  r  r`  rê   ré   rä   r@   rÀ   rÆ   rš   )r™   rš   rÂ   rF  rÁ   rï   rG  rÃ   r¯   r<   ra  rb  r¹   rî   rê   rD   rD   rF   r¾   ‹  s€    
ÿÿþ
ýüÿ
ÿÿ

ÿüþûz"BulkORMDelete.create_for_statementr0   z
dml.Deleter5   r+   r.   r3   r<  r=  c                   sL   |  d| j¡}|jdkr"t d¡‚|jdvr6t d¡‚tƒ  ||||||¡S )Nrë   rc   zˆBulk ORM DELETE not supported right now. Statement may be invoked at the Core level using session.connection().execute(stmt, parameters))rô   rÔ   ró   zGValid strategies for ORM DELETE strategy are 'orm', 'auto', 'core_only')r¢   râ   rÕ   rú   rû   rü   rB  rA  )r™   ri   rš   r\   r9   rÌ   r]   r  rH  rD   rF   rA  ç  s    
ÿ
ÿ
ÿÿz#BulkORMDelete.orm_execute_statementFrã   r   r|   r:   rè   c                C  sB   |j o|jj}|sdS |r |jS |r>|js>t d|j› d�¡‚dS )NFre  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)Zdelete_returningr®   rf  Zdelete_returning_multifromrú   rT  r§   rg  rD   rD   rF   rê     s    ÿ
ÿzBulkORMDelete.can_use_returningc                 C  sZ   |   ||j ¡ ¡}g }|D ],\}}}	}
|
r<| |	|jj¡ q| |¡ q|rV| |¡ d S rC   )r  rk  rx  Z_expireZ	_modifiedr  Ú_remove_newly_deleted)r™   ri   rš   r   r  r}  Z	to_deleterd  rL   rO   Zis_partially_expiredrD   rD   rF   r  0  s    þz+BulkORMDelete._do_post_synchronize_evaluatec                   sŽ   ˆ j }|j}|r2|  |||¡}‡ fdd„|D ƒ}nˆ j}|D ]L}	|	dd… }
|	d }|jt|
ƒ|d�}||jv r<| t 	|j| ¡g¡ q<d S )Nc                   s   g | ]}t |ƒˆ jf ‘qS rD   r~  r  r  rD   rF   rM   Q  s   ÿz<BulkORMDelete._do_post_synchronize_fetch.<locals>.<listcomp>r   r�  r  )
rÜ   r„  r  rà   rl  rm   rk  r�  r   r‚  )r™   ri   rš   r   r  r€  r„  r…  r3  r  rÀ   rí   rt  rD   r  rF   r  D  s0    ÿ
þþ
ÿÿÿz(BulkORMDelete._do_post_synchronize_fetch)
r­   rÏ   rÐ   rÒ   r¾   rA  rê   r  r  rV  rD   rD   rH  rF   r�  ‰  s   
[ ø (
r�  )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   Zenginer   r   r‰   Zsqlr   r   r   r   r    r!   Zsql.baser"   r#   r$   Zsql.dmlr%   r&   r'   r(   Zutil.typingr)   Ú_typingr*   r+   r,   r<   r-   ri   r.   r/   r0   r1   rL   r2   r3   r4   Zengine.interfacesr5   Úobjectr6   rG   r   rn   r�   rÓ   Z
plugin_forr5  rX  r�  rD   rD   rD   rF   Ú<module>
   sÀ   	÷$	÷$÷" ø"ø"ø \      
  
   k
