U
|
¸ý°d ã @ s> d Z ddlmZ ddlmZ ddlmZ ddlZddlZddl Z ddl m
|
Z
|
ddl m Z ddl m Z dd l m Z dd
|
l mZ dd l mZ dd l mZ dd l mZ ddl mZ ddl mZ ddl mZ ddl mZ ddl mZ ddl mZ ddl mZ ddl mZ ddlmZ ddlm Z ddl m Z ddl m Z ddl m!Z! dd l m"Z" dd l m#Z# errd d l$m%Z% d d l&m'Z' e jse sd d!l(m)Z) d d"l(m*Z+ ndd!l,m)Z) dd"l,m*Z+ d#d$d%d&d'd(d)d*d+g Z-G d,d- d-e"Z.G d.d( d(Z/G d/d* d*eZ0eee1e0f Z2G d0d1 d1Z3G d2d3 d3e"Z4G d4d5 d5Z5e0Z6d6d7d8d9Z7e5j8Z8e7 G d:d; d;e3e/Z9ed<e9d=Z:ed>d?d=Z;e e:gdf Z<G d@dA dAe"Z=G dBdC dCe"e: Z>edDd)d=Z?G dEd) d)e j@ZAG dFdG dGeAZBG dHdI dIeBZCe/ZDeAZEeBZFeCZGe jHfdJdKdLdMdNd#ZIedOdPdQd6dRdSd$ZJedOd;dQd;dRdTd$ZJdOdJdQdJdRdUd$ZJedPdKdQd6dVdWd%ZKed;dKdQd;dVdXd%ZKdJdKdQdJdVdYd%ZKedPdKdQd6dVdZd&ZLed<dKdQd<dVd[d&ZLdJdKdQdJdVd\d&ZLedPdKd]d6d^d_d'ZMed>dKd]d>d^d`d'ZMed;dKd]d;d^dad'ZMdJdKd]dJd^dbd'ZMdS )cz5Visitor/traversal interface and library functions.
|
|
|
é )Ú annotations)Údeque)ÚEnumN)ÚAny)ÚCallable)Úcast)ÚClassVar)ÚDict)ÚIterable)ÚIterator)ÚList)ÚMapping)ÚOptional)Úoverload)ÚTuple)ÚType)Ú TYPE_CHECKING)ÚTypeVar)ÚUnioné )Úexc)Úutil)Ú langhelpers)ÚHAS_CYEXTENSION)ÚLiteral)ÚProtocol)ÚSelfé )Ú_AnnotationDict)Ú ColumnElement)Úprefix_anon_map)Úcache_anon_mapÚiterateÚtraverse_usingÚtraverseÚcloned_traverseÚreplacement_traverseÚ VisitableÚExternalTraversalÚInternalTraversalÚanon_mapc @ s e Zd ZdddddddZdS )Ú_CompilerDispatchTyper' r ©ÚselfÚvisitorÚkwÚreturnc K s d S ©N© )Ú_selfr- r. r/ r2 r2 úNd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/sql/visitors.pyÚ__call__K s z _CompilerDispatchType.__call__N©Ú__name__Ú
|
__module__Ú __qualname__r5 r2 r2 r2 r4 r+ J s r+ c sv e Zd ZU dZdZded< ded< ejr:ddddd d
|
Zd d fd d Z e
|
d d ddZ dddddZ Z S )r' a, Base class for visitable objects.
|
|
:class:`.Visitable` is used to implement the SQL compiler dispatch
|
functions. Other forms of traversal such as for cache key generation
|
are implemented separately using the :class:`.HasTraverseInternals`
|
interface.
|
|
.. versionchanged:: 2.0 The :class:`.Visitable` class was named
|
:class:`.Traversible` in the 1.4 series; the name is changed back
|
to :class:`.Visitable` in 2.0 which is what it was prior to 1.4.
|
|
Both names remain importable in both 1.4 and 2.0 versions.
|
|
r2 ÚstrÚ__visit_name__r+ Ú_original_compiler_dispatchr )r. r/ r0 c K s d S r1 r2 )r- r. r/ r2 r2 r4 Ú_compiler_dispatchg s z Visitable._compiler_dispatchÚNone©r0 c s d| j kr| ¡ t ¡ d S )Nr; )Ú__dict__Ú_generate_compiler_dispatchÚsuperÚ__init_subclass__)Úcls©Ú __class__r2 r4 rC j s
|
zVisitable.__init_subclass__c st | j }d| jkr | j| _d S t|ts:t d| j d¡d| }t
|
|¡ ddddd fd d
|
}| | _| _d S ) Nr= z__visit_name__ on class z$ must be a string at the class levelúvisit_%sr' r r: r, c
|
sT z |}W n6 t k
|
rB } z|j| |f| W Y ¢S d}~X Y nX || f|S dS )zLook for an attribute named "visit_<visit_name>" on the
|
visitor, and call it with the same kw params.
|
|
N)ÚAttributeErrorZ visit_unsupported_compilation)r- r. r/ ÚmethÚerr©Úgetterr2 r4 r= s
|
&zAVisitable._generate_compiler_dispatch.<locals>._compiler_dispatch) r; r@ r= r< Ú
|
isinstancer: r ZInvalidRequestErrorr7 ÚoperatorÚ
|
attrgetter)rD Ú
|
visit_nameÚnamer= r2 rK r4 rA o s
|
|
ÿ
|
þÿz%Visitable._generate_compiler_dispatch)Úkeyr0 c C s | S r1 r2 )rD rR r2 r2 r4 Ú__class_getitem__ s zVisitable.__class_getitem__)r7 r8 r9 Ú__doc__Ú __slots__Ú__annotations__Útypingr r= rC Ú classmethodrA rS Ú __classcell__r2 r2 rE r4 r' O s
|
%c @ s¬ e Zd ZdZdZdZdZdZdZdZ dZ
|
d Z d
|
Z d Z d Zd ZdZdZdZdZdZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Z!d Z"d!Z#d"Z$d#Z%d$Z&d%Z'd&Z(d'Z)d(Z*d)S )*r) a¯ Defines visitor symbols used for internal traversal.
|
|
The :class:`.InternalTraversal` class is used in two ways. One is that
|
it can serve as the superclass for an object that implements the
|
various visit methods of the class. The other is that the symbols
|
themselves of :class:`.InternalTraversal` are used within
|
the ``_traverse_internals`` collection. Such as, the :class:`.Case`
|
object defines ``_traverse_internals`` as ::
|
|
_traverse_internals = [
|
("value", InternalTraversal.dp_clauseelement),
|
("whens", InternalTraversal.dp_clauseelement_tuples),
|
("else_", InternalTraversal.dp_clauseelement),
|
]
|
|
Above, the :class:`.Case` class indicates its internal state as the
|
attributes named ``value``, ``whens``, and ``else_``. They each
|
link to an :class:`.InternalTraversal` method which indicates the type
|
of datastructure referred towards.
|
|
Using the ``_traverse_internals`` structure, objects of type
|
:class:`.InternalTraversible` will have the following methods automatically
|
implemented:
|
|
* :meth:`.HasTraverseInternals.get_children`
|
|
* :meth:`.HasTraverseInternals._copy_internals`
|
|
* :meth:`.HasCacheKey._gen_cache_key`
|
|
Subclasses can also implement these methods directly, particularly for the
|
:meth:`.HasTraverseInternals._copy_internals` method, when special steps
|
are needed.
|
|
.. versionadded:: 1.4
|
|
ZHCZHLZCEZFCZCTSZCLZCTZEOZWCZCOÚSZSLÚANÚBÚOÚTZPDZDOZCDZMDZAKZPOZDDZPSZTHZSJZMEZSHZUKZDML_OVZDML_VZDML_MVZPAZIGZISÚMZMTZHTZILN)+r7 r8 r9 rT Zdp_has_cache_keyZdp_has_cache_key_listZdp_clauseelementZ)dp_fromclause_canonical_column_collectionZdp_clauseelement_tuplesZdp_clauseelement_listZdp_clauseelement_tupleZdp_executable_optionsZdp_with_context_optionsZdp_fromclause_ordered_setZ dp_stringZdp_string_listZ dp_anon_nameZ
|
dp_booleanZ dp_operatorZdp_typeZ dp_plain_dictZdp_dialect_optionsZ dp_string_clauseelement_dictZdp_string_multi_dictZdp_annotations_keyZ dp_plain_objZdp_named_ddl_elementZdp_prefix_sequenceZdp_table_hint_listZdp_setup_join_tupleZdp_memoized_select_entitiesZdp_statement_hint_listZdp_unknown_structureZdp_dml_ordered_valuesZ dp_dml_valuesZdp_dml_multi_valuesZdp_propagate_attrsZ dp_ignoreZdp_inspectableZdp_multiZ dp_multi_listZdp_has_cache_key_tuplesZdp_inspectable_listr2 r2 r2 r4 r) sR &
|
c @ sL e Zd ZU dZdZded< dZded< e d¡dd d
|
d d d ddZ dS )ÚHasTraverseInternalsaÀ base for classes that have a "traverse internals" element,
|
which defines all kinds of ways of traversing the elements of an object.
|
|
Compared to :class:`.Visitable`, which relies upon an external visitor to
|
define how the object is travered (i.e. the :class:`.SQLCompiler`), the
|
:class:`.HasTraverseInternals` interface allows classes to define their own
|
traversal, that is, what attributes are accessed and in what order.
|
|
r2 Ú_TraverseInternalsTypeÚ_traverse_internalsFÚboolÚ _is_immutablezsqlalchemy.sql.traversals©Ú
|
omit_attrsúTuple[str, ...]r z Iterable[HasTraverseInternals]©rf r/ r0 c sX t jj}z
|
| j}W n tk
|
r* g Y S X |jj}tj fdd|| |dD ¡S )aä Return immediate child :class:`.visitors.HasTraverseInternals`
|
elements of this :class:`.visitors.HasTraverseInternals`.
|
|
This is used for visit traversal.
|
|
\**kw may contain flags that change the collection that is
|
returned, for example to return a subset of items in order to
|
cut down on larger traversals, or to return child items from a
|
different context (such as schema-level collections instead of
|
clause-level).
|
|
c 3 s0 | ](\}}}|kr|d k r||f V qd S r1 r2 )Ú.0ÚattrnameÚobjrI ©r/ rf r2 r4 Ú <genexpr>å s üz4HasTraverseInternals.get_children.<locals>.<genexpr>Z!_generated_get_children_traversal)
|
r Z preloadedZsql_traversalsrb rH Z _get_childrenÚrun_generated_dispatchÚ itertoolsÚchainÚ from_iterable)r- rf r/ Z
|
traversalsZtraverse_internalsÚdispatchr2 rl r4 Ú get_childrenË s
|
|
ÿþz!HasTraverseInternals.get_childrenN)
|
r7 r8 r9 rT rU rV rd r Zpreload_modulers r2 r2 r2 r4 r` º s
|
|
ÿr` c @ s e Zd ZddddddZdS )Ú _InternalTraversalDispatchTypeÚobjectÚHasTraversalDispatchr ©r- r. r0 c C s d S r1 r2 )Úsr- r. r2 r2 r4 r5 ï s z'_InternalTraversalDispatchType.__call__Nr6 r2 r2 r2 r4 rt î s rt c @ sl e Zd ZU dZdZi Zded< ddddd Zd
|
d d d dddZdd d ddddZ d d ddddZ
|
dS )rv zcDefine infrastructure for classes that perform internal traversals
|
|
.. versionadded:: 2.0
|
|
r2 z2ClassVar[Dict[Union[InternalTraversal, str], str]]Ú_dispatch_lookupr) zCallable[..., Any])Ú visit_symbolr0 c C s t | }t| |dS )ztGiven a method from :class:`.HasTraversalDispatch`, return the
|
corresponding method on a subclass.
|
|
N)ry Úgetattr)r- rz rQ r2 r2 r4 rr þ s z HasTraversalDispatch.dispatchru ra r: r )ÚtargetÚinternal_dispatchÚgenerate_dispatcher_namer0 c C s@ z|j j| }W n$ tk
|
r4 | |j ||¡}Y nX ||| S r1 )rF r@ ÚKeyErrorÚgenerate_dispatch)r- r| r} r~ Ú
|
dispatcherr2 r2 r4 rn s ÿ
|
z+HasTraversalDispatch.run_generated_dispatchz Type[object]rt )Ú
|
target_clsr} r~ r0 c C s | ||¡}t||| |S r1 )Ú_generate_dispatcherÚsetattr)r- r r} r~ r r2 r2 r4 r s ÿ z&HasTraversalDispatch.generate_dispatch)r} Ú method_namer0 c
|
C sz g }|D ]0\}}| |¡}|d k rt| }| ||f¡ qdd dd |D ¡ d }d| | d } ttt | i |¡S )Nz return [
|
z,
|
c s s | ]\}}d |||f V qdS )z! (%r, self.%s, visitor.%s)Nr2 )ri rj rP r2 r2 r4 rm 3 s þÿz<HasTraversalDispatch._generate_dispatcher.<locals>.<genexpr>z
|
]
|
zdef %s(self, visitor):
|
Ú
|
)rr ry ÚappendÚjoinr rt r Z_exec_code_in_env)
|
r- r} r
Únamesrj Z visit_symrI rP ÚcodeZ meth_textr2 r2 r4 r & s&
|
|
ýþøÿ þz)HasTraversalDispatch._generate_dispatcherN) r7 r8 r9 rT rU ry rV rr rn r r r2 r2 r2 r4 rv ó s
|
rv r> r? c C sT t } tD ]F}|j}| d¡r| dd¡}|j}|| ks>t|| | |< | |< qd S )NZdp_Úvisit_)ry r) rQ Ú
|
startswithÚreplaceÚvalueÚAssertionError)ÚlookupÚsymrR Z visit_keyZsym_namer2 r2 r4 Ú _generate_traversal_dispatchE s
|
r c @ sv e Zd ZU dZejZded< ej rJdddddZ
|
dd d
|
d d d ddZ d ddddZ dd d
|
d dd ddZ dS )ÚExternallyTraversibler2 zMapping[Any, Any]Ú _annotationsr r )Úvaluesr0 c C s d S r1 r2 )r- r r2 r2 r4 Ú _annotate\ s z ExternallyTraversible._annotatere rg r ú Iterable[ExternallyTraversible]rh c K s d S r1 r2 ©r- rf r/ r2 r2 r4 rs _ s z"ExternallyTraversible.get_children)r/ r0 c K s
|
t dS )zclone this elementN©ÚNotImplementedError)r- r/ r2 r2 r4 Ú_cloned s z ExternallyTraversible._cloner> c K s
|
t dS )at Reassign internal elements to be clones of themselves.
|
|
Called during a copy-and-traverse operation on newly
|
shallow-copied elements to create a deep copy.
|
|
The given clone function should be used, which may be applying
|
additional transformations to the element (i.e. replacement
|
traversal, cloned traversal, annotations).
|
|
Nr r r2 r2 r4 Ú_copy_internalsh s z%ExternallyTraversible._copy_internalsN)r7 r8 r9 rU r Ú
|
EMPTY_DICTr rV rW r r rs r r r2 r2 r2 r4 r U s
|
ÿÿr Ú_ET)ÚboundÚ_CEzColumnElement[Any]c @ s e Zd ZddddddZdS )Ú_CloneCallableTyper r ©Úelementr/ r0 c K s d S r1 r2 ©r- r£ r/ r2 r2 r4 r5 s z_CloneCallableType.__call__Nr6 r2 r2 r2 r4 r¡ s r¡ c @ s e Zd ZddddddZdS )Ú _TraverseTransformCallableTyper r z Optional[_ET]r¢ c K s d S r1 r2 r¤ r2 r2 r4 r5
s z'_TraverseTransformCallableType.__call__Nr6 r2 r2 r2 r4 r¥ s r¥ Ú_ExtTc @ s¶ e Zd ZU dZdZi Zded< ded< dddd d
|
d Zd d dddZe dddddZ
|
e dddddZ
|
d d dddZ
|
ddddZ e d dd d Z d d d d d!d"Zd#S )$r( zÌBase class for visitor objects which can traverse externally using
|
the :func:`.visitors.traverse` function.
|
|
Direct usage of the :func:`.visitors.traverse` function is usually
|
preferred.
|
|
)Ú _visitor_dictÚ_nextzDict[str, Any]Ú__traverse_options__zOptional[ExternalTraversal]r¨ r' r )rk r/ r0 c K s6 | j D ]*}t|d|j d }|r||f| S qd S )NrG )Úvisitor_iteratorr{ r; )r- rk r/ ÚvrI r2 r2 r4 Útraverse_single s
|
z!ExternalTraversal.traverse_singleú Optional[ExternallyTraversible]ú Iterator[ExternallyTraversible]©rk r0 c C s t || jS )zaTraverse the given expression structure, returning an iterator
|
of all elements.
|
|
)r" r© ©r- rk r2 r2 r4 r" s zExternalTraversal.iterateú Literal[None]r> c C s d S r1 r2 r° r2 r2 r4 r$ © s zExternalTraversal.traverser c C s d S r1 r2 r° r2 r2 r4 r$ s c C s t || j| jS ©ú2Traverse and visit the given expression structure.)r$ r© r§ r° r2 r2 r4 r$ ± s z%Dict[str, _TraverseCallableType[Any]]r? c C s6 i }t | D ]$}| d¡r t| |||dd
< q |S )Nr é )Údirr r{ )r- ÚvisitorsrQ r2 r2 r4 Ú _memoized_attr__visitor_dict¸ s
|
|
z.ExternalTraversal._memoized_attr__visitor_dictzIterator[ExternalTraversal]c c s | }|r |V t |dd}qdS )z8Iterate through this visitor and each 'chained' visitor.r¨ N)r{ )r- r« r2 r2 r4 rª Â s z"ExternalTraversal.visitor_iteratorr¦ rw c C s t | jd }||_| S )z'Chain' an additional ExternalTraversal onto this ExternalTraversal
|
|
The chained visitor will receive all visit events after this one.
|
|
éÿÿÿÿ)Úlistrª r¨ )r- r. Útailr2 r2 r4 rp Ë s zExternalTraversal.chainN)r7 r8 r9 rT rU r© rV r¬ r" r r$ r· Úpropertyrª rp r2 r2 r2 r4 r( s
|
|
c @ s\ e Zd ZdZdZdddddZeddd d
|
d Zed d d d d Zddd dd ZdS )ÚCloningExternalTraversalzÐBase class for visitor objects which can traverse using
|
the :func:`.visitors.cloned_traverse` function.
|
|
Direct usage of the :func:`.visitors.cloned_traverse` function is usually
|
preferred.
|
|
|
r2 zList[ExternallyTraversible])Úlist_r0 c s fdd|D S )z`Apply cloned traversal to the given list of elements, and return
|
the new list.
|
|
c s g | ]} |¡qS r2 )r$ ©ri Úx©r- r2 r4 Ú
|
<listcomp>é s z=CloningExternalTraversal.copy_and_process.<locals>.<listcomp>r2 )r- r½ r2 rÀ r4 Úcopy_and_processâ s z)CloningExternalTraversal.copy_and_processr± r> r¯ c C s d S r1 r2 r° r2 r2 r4 r$ ë s z!CloningExternalTraversal.traverser c C s d S r1 r2 r° r2 r2 r4 r$ ï s r c C s t || j| jS r² )r% r© r§ r° r2 r2 r4 r$ ó s
|
ÿN)r7 r8 r9 rT rU r r r$ r2 r2 r2 r4 r¼ Ö s r¼ c @ s\ e Zd ZdZdZdddddZedd d
|
d d Zeddd
|
d d Zddd
|
dd ZdS )ÚReplacingExternalTraversalzÙBase class for visitor objects which can traverse using
|
the :func:`.visitors.replacement_traverse` function.
|
|
Direct usage of the :func:`.visitors.replacement_traverse` function is
|
usually preferred.
|
|
r2 r r )Úelemr0 c C s dS )a Receive pre-copied elements during a cloning traversal.
|
|
If the method returns a new element, the element is used
|
instead of creating a simple copy of the element. Traversal
|
will halt on the newly returned element if it is re-encountered.
|
Nr2 )r- rÄ r2 r2 r4 r s z"ReplacingExternalTraversal.replacer± r> r¯ c C s d S r1 r2 r° r2 r2 r4 r$ s z#ReplacingExternalTraversal.traversec C s d S r1 r2 r° r2 r2 r4 r$ s c s$ dddd fdd }t | j|S )r³ r r r r¢ c s0 j D ]$}tt| | ¡}|d k r| S qd S r1 )rª r rà r )r£ r/ r« ÚerÀ r2 r4 r s
|
|
|
z4ReplacingExternalTraversal.traverse.<locals>.replace)r& r© )r- rk r r2 rÀ r4 r$ s N)r7 r8 r9 rT rU r r r$ r2 r2 r2 r4 rà ý s rà r zMapping[str, Any]r® )rk Úoptsr0 c c sd | dkr dS | V | j f |}|s&dS t|g}|r`| ¡ }|D ] }|V | |j f |¡ q@q0dS )aH Traverse the given expression structure, returning an iterator.
|
|
Traversal is configured to be breadth-first.
|
|
The central API feature used by the :func:`.visitors.iterate`
|
function is the
|
:meth:`_expression.ClauseElement.get_children` method of
|
:class:`_expression.ClauseElement` objects. This method should return all
|
the :class:`_expression.ClauseElement` objects which are associated with a
|
particular :class:`_expression.ClauseElement` object. For example, a
|
:class:`.Case` structure will refer to a series of
|
:class:`_expression.ColumnElement` objects within its "whens" and "else\_"
|
member variables.
|
|
:param obj: :class:`_expression.ClauseElement` structure to be traversed
|
|
:param opts: dictionary of iteration options. This dictionary is usually
|
empty in modern usage.
|
|
N)rs r Úpopleftr )rk rÆ ÚchildrenÚstackZ
|
t_iteratorÚtr2 r2 r4 r" 6 s
|
r r± z(Mapping[str, _TraverseCallableType[Any]])Úiteratorrk r¶ r0 c C s d S r1 r2 ©rË rk r¶ r2 r2 r4 r# _ s c C s d S r1 r2 rÌ r2 r2 r4 r# h s c C s( | D ] }| |jd¡}|r|| q|S )aÅ Visit the given expression structure using the given iterator of
|
objects.
|
|
:func:`.visitors.traverse_using` is usually called internally as the result
|
of the :func:`.visitors.traverse` function.
|
|
:param iterator: an iterable or sequence which will yield
|
:class:`_expression.ClauseElement`
|
structures; the iterator is assumed to be the
|
product of the :func:`.visitors.iterate` function.
|
|
:param obj: the :class:`_expression.ClauseElement`
|
that was used as the target of the
|
:func:`.iterate` function.
|
|
:param visitors: dictionary of visit functions. See :func:`.traverse`
|
for details on this dictionary.
|
|
.. seealso::
|
|
:func:`.traverse`
|
|
|
N)Úgetr; )rË rk r¶ r| rI r2 r2 r4 r# q s
|
|
)rk rÆ r¶ r0 c C s d S r1 r2 ©rk rÆ r¶ r2 r2 r4 r$ s c C s d S r1 r2 rÎ r2 r2 r4 r$ s c C s t t| || |S )a Traverse and visit the given expression structure using the default
|
iterator.
|
|
e.g.::
|
|
from sqlalchemy.sql import visitors
|
|
stmt = select(some_table).where(some_table.c.foo == 'bar')
|
|
def visit_bindparam(bind_param):
|
print("found bound value: %s" % bind_param.value)
|
|
visitors.traverse(stmt, {}, {"bindparam": visit_bindparam})
|
|
The iteration of objects uses the :func:`.visitors.iterate` function,
|
which does a breadth-first traversal using a stack.
|
|
:param obj: :class:`_expression.ClauseElement` structure to be traversed
|
|
:param opts: dictionary of iteration options. This dictionary is usually
|
empty in modern usage.
|
|
:param visitors: dictionary of visit functions. The dictionary should
|
have strings as keys, each of which would correspond to the
|
``__visit_name__`` of a particular kind of SQL expression object, and
|
callable functions as values, each of which represents a visitor function
|
for that kind of object.
|
|
)r# r" rÎ r2 r2 r4 r$ § s "c C s d S r1 r2 rÎ r2 r2 r4 r% Ì s c C s d S r1 r2 rÎ r2 r2 r4 r% Ù s c sj i t dg ¡dddfdd }dddd fdd | d
|
k rb | fd |i} d
|
| S ) a Clone the given expression structure, allowing modifications by
|
visitors for mutable objects.
|
|
Traversal usage is the same as that of :func:`.visitors.traverse`.
|
The visitor functions present in the ``visitors`` dictionary may also
|
modify the internals of the given structure as the traversal proceeds.
|
|
The :func:`.cloned_traverse` function does **not** provide objects that are
|
part of the :class:`.Immutable` interface to the visit methods (this
|
primarily includes :class:`.ColumnClause`, :class:`.Column`,
|
:class:`.TableClause` and :class:`.Table` objects). As this traversal is
|
only intended to allow in-place mutation of objects, :class:`.Immutable`
|
objects are skipped. The :meth:`.Immutable._clone` method is still called
|
on each object to allow for objects to replace themselves with a different
|
object based on a clone of their sub-internals (e.g. a
|
:class:`.ColumnClause` that clones its subquery to return a new
|
:class:`.ColumnClause`).
|
|
.. versionchanged:: 2.0 The :func:`.cloned_traverse` function omits
|
objects that are part of the :class:`.Immutable` interface.
|
|
The central API feature used by the :func:`.visitors.cloned_traverse`
|
and :func:`.visitors.replacement_traverse` functions, in addition to the
|
:meth:`_expression.ClauseElement.get_children`
|
function that is used to achieve
|
the iteration, is the :meth:`_expression.ClauseElement._copy_internals`
|
method.
|
For a :class:`_expression.ClauseElement`
|
structure to support cloning and replacement
|
traversals correctly, it needs to be able to pass a cloning function into
|
its internal members in order to make copies of them.
|
|
.. seealso::
|
|
:func:`.visitors.traverse`
|
|
:func:`.visitors.replacement_traverse`
|
|
Ústop_onr r¯ c s t | S r1 )r% ©rk )rÆ r¶ r2 r4 Údeferred_copy_internals s z0cloned_traverse.<locals>.deferred_copy_internalsr ©rÄ r/ r0 c s² | kr | S t | kr¢d|krNttt |d | }|d k rN|t | < |S | jf d i| t | < }|jf d i| | js¢ |jd ¡}|r¢|| t | S d S )Nr Úclone) Úidr r r r r rd rÍ r; )rÄ r/ ÚnewelemrI )rÓ ÚclonedrÏ r¶ r2 r4 rÓ s$
|
ÿ z cloned_traverse.<locals>.cloneNrÑ )ÚsetrÍ )rk rÆ r¶ rÑ r2 )rÓ rÖ rÆ rÏ r¶ r4 r% â s - ÿÿÿz#_TraverseTransformCallableType[Any])rk rÆ r r0 c C s d S r1 r2 ©rk rÆ r r2 r2 r4 r& > s c C s d S r1 r2 rØ r2 r2 r4 r& G s c C s d S r1 r2 rØ r2 r2 r4 r& P s c sp i dd dg ¡D dddfdd }dddd fd
|
d | d k rh | fd |i} d | S )a] Clone the given expression structure, allowing element
|
replacement by a given replacement function.
|
|
This function is very similar to the :func:`.visitors.cloned_traverse`
|
function, except instead of being passed a dictionary of visitors, all
|
elements are unconditionally passed into the given replace function.
|
The replace function then has the option to return an entirely new object
|
which will replace the one given. If it returns ``None``, then the object
|
is kept in place.
|
|
The difference in usage between :func:`.visitors.cloned_traverse` and
|
:func:`.visitors.replacement_traverse` is that in the former case, an
|
already-cloned object is passed to the visitor function, and the visitor
|
function can then manipulate the internal state of the object.
|
In the case of the latter, the visitor function should only return an
|
entirely different object, or do nothing.
|
|
The use case for :func:`.visitors.replacement_traverse` is that of
|
replacing a FROM clause inside of a SQL structure with a different one,
|
as is a common use case within the ORM.
|
|
c S s h | ] }t |qS r2 )rÔ r¾ r2 r2 r4 Ú <setcomp>v s z'replacement_traverse.<locals>.<setcomp>rÏ r r¯ c s t | S r1 )r& rÐ )rÆ r r2 r4 rÑ x s z5replacement_traverse.<locals>.deferred_copy_internalsr rÒ c s¨ t | ksd| jkr| S | }|d k r< t |¡ |S t | }|krd|krt|d | }|d k rt||< |S | jf | |< }|jf d i| | S d S )NZno_replacement_traverser rÓ )rÔ r Úaddr r )rÄ r/ rÕ Zid_elem)rÓ rÖ r rÏ r2 r4 rÓ } s&
|
ÿþ z#replacement_traverse.<locals>.cloneNrÑ )rÍ )rk rÆ r rÑ r2 )rÓ rÖ rÆ r rÏ r4 r& Y s ÿÿÿ)NrT Ú
|
__future__r Ú collectionsr Úenumr ro rN rW r r r r r r
|
r r r r r r r r r r Ú r r r Z util._has_cyr Z util.typingr r r Ú
|
annotationr Úelementsr Z_py_utilr r! r* Zsqlalchemy.cyextension.utilÚ__all__r+ r' r) r: ra r` rt rv ZExtendedInternalTraversalr ry r r r Z_TraverseCallableTyper¡ r¥ r¦ Z MemoizedSlotsr( r¼ rà Z TraversibleZ ClauseVisitorZCloningVisitorZReplacingCloningVisitorr r" r# r$ r% r& r2 r2 r2 r4 Ú<module> sÄ ÷ K 4O # J'2þ)$% \
|
