관리-도구
편집 파일: strategy_options.cpython-38.pyc
U -?�f]M � @ s< U d Z ddlmZ ddlZddlmZ ddlmZ ddlmZ ddlmZ ddlmZ dd lm Z dd lm Z dd lm Z dd lm Z dd lm Z ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ 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 lm&Z& dd!lm'Z' d"d#lm(Z) d"d$lm*Z* d"dlmZ 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*l+m1Z1 d"d+l2m3Z3 d"d,l4m5Z5 d"d-l4m6Z6 d"d.l4m7Z7 d/Z8d0e9d1< d2Z:d3e9d4< ed5d6d7�Z;ej<�r�dd8lm=Z= dd9lm>Z> dd:l?m@Z@ dd;l?mAZA dd<l?mBZB dd=l mCZC dd>l mDZD dd?l mEZE dd@lFmGZG ddAl mHZH d"dBlImJZJ d"dClImKZK d"dDlLmMZM d"dElLmNZN ee6dF dGf ZOe6dH ZPeeQef ZReeQef ZSe eOdIf ZTG dJdK� dKe0jUe �ZVG dLdM� dMeV�ZWG dNdO� dOeV�ZXG dPdQ� dQe-jYe0jZe1j[�Z\G dRdS� dSe\�Z]G dTdU� dUe\�Z^G dVdW� dWe\�Z_dXdYdZd[dKd\�d]d^�Z`d_d`da�dbdc�Zad5d5dd�dedf�Zbebd_d[dKdg�dhdi��Zcebdjdk�d_dZdKdl�dmdn��Zdebd_d[dKdg�dodp��Zeebd_dKdq�drds��Zfebddt�d_dudKdv�dwdx��Zgebd_dKdq�dydz��Zhebddt�d_dudKdv�d{d|��Ziebd_dKdq�d}d~��Zjebd_d[dKdg�dd���Zkebd_dKdq�d�d���Zlebdjdk�d_d_dZdKd��d�d���Zmebd_d_dKd��d�d���Znebd�dKd��d�d���Zoebd_d�dKd��d�d���Zpebd�d�dKd��d�d���Zqd�d�� ZrdS )�z � )� annotationsN)�Any)�Callable)�cast)�Dict)�Iterable)�Optional)�overload)�Sequence)�Tuple)�Type)�TypeVar)�Union� )�util)�insp_is_aliased_class)�insp_is_attribute)�insp_is_mapper)�insp_is_mapper_property)�QueryableAttribute)�InspectionAttr)� LoaderOption)�_DEFAULT_TOKEN)� _StrPathToken)�_WILDCARD_TOKEN)�AbstractEntityRegistry)�path_is_property)� PathRegistry)� TokenRegistry)�_orm_full_deannotate)� AliasedInsp� )�exc��inspect)�and_)� cache_key)� coercions)�roles)� traversals)�visitors)� _generative)�Final)�Literal)�Self� relationshipz Final[Literal['relationship']]�_RELATIONSHIP_TOKEN�columnzFinal[Literal['column']]� _COLUMN_TOKEN�_FNzCallable[..., Any])�bound)� _EntityType)�_InternalEntityType)� _MapperEntity)�ORMCompileState)� QueryContext)� _StrategyKey)�MapperProperty)� ORMOption)�Mapper)�_PathRepresentation)�_ColumnExpressionArgument)�_FromClauseArgument)�_CacheKeyTraversalType)�CacheKey�*zQueryableAttribute[Any])r/ r1 .c @ sf e Zd ZU dZdZded< drddddd d �d d �Zdd �ddd d�dd�Zdsddd d�dd�Zdd d�dd�Z dtddd d�dd�Z dd d�d d �Z duddd d�d d �Z dd d�d d!�Z dvddd d"�d#d$�Zdd d�d%d&�Zdwddd d'�d(d)�Zdd d*�d+d,�Zd-d d.�d/d0�Zdd1d d2�d3d4�Zd5d d6�d7d8�Zed9d:d;�d<d=��Zed>d?d;�d@d=��ZdAdBd;�dCd=�ZedxddAddDdd dE�dFdG��ZedydHdAdDdId dJ�dKdL��ZedzdHd9dd dM�dNdO��Zed9dPd dQ�dRdS��ZdTd?dU�dVdW�Z d d dX�dYdZ�Z d{d[dBd\dDd]dddId d^� d_d`�Z dadbd?dc�ddde�Z dad?df�dgdh�Z dadbdd?di�djdk�Z!e"d|dldmddndo�dpdq��Z#dS )}� _AbstractLoad)�propagate_to_loadersT�boolrE NF� _AttrTypez Optional[_FromClauseArgument]r. )�attr�alias� _is_chain�_propagate_to_loaders�returnc C s� |dk r6t |t�s"t�tj|�}qrtjddd� |}n<t|dd�rnt |t �sPt �t |j �}|dk sft �|j }nd}| j|ddi|d|i|r�d ndd �}|S ) a, Indicate that the given attribute should be eagerly loaded from columns stated manually in the query. This function is part of the :class:`_orm.Load` interface and supports both method-chained and standalone operation. The option is used in conjunction with an explicit join that loads the desired rows, i.e.:: sess.query(Order).join(Order.user).options( contains_eager(Order.user) ) The above query would join from the ``Order`` entity to its related ``User`` entity, and the returned ``Order`` objects would have the ``Order.user`` attribute pre-populated. It may also be used for customizing the entries in an eagerly loaded collection; queries will normally want to use the :ref:`orm_queryguide_populate_existing` execution option assuming the primary collection of parent objects may already have been loaded:: sess.query(User).join(User.addresses).filter( Address.email_address.like("%@aol.com") ).options(contains_eager(User.addresses)).populate_existing() See the section :ref:`contains_eager` for complete usage details. .. seealso:: :ref:`loading_toplevel` :ref:`contains_eager` Nz�Passing a string name for the 'alias' argument to 'contains_eager()` is deprecated, and will not work in a future release. Please use a sqlalchemy.alias() or sqlalchemy.orm.aliased() construct.�1.4��version�_of_type�lazy�joinedZeager_from_aliasT)rE �opts�_reconcile_to_other)� isinstance�strr' �expectr( ZFromClauseRoler �warn_deprecated�getattrr �AssertionErrorr$ rP Z selectable�_set_relationship_strategy)�selfrH rI rJ rK Z coerced_aliasZot�cloned� r^ �O/opt/hc_python/lib64/python3.8/site-packages/sqlalchemy/orm/strategy_options.py�contains_eager` s, * � �z _AbstractLoad.contains_eager�� raiseload��attrsrb rL c G s8 | � |ddd��}ddd�}|r(d|d< |� d|�}|S )a� Indicate that for a particular entity, only the given list of column-based attribute names should be loaded; all others will be deferred. This function is part of the :class:`_orm.Load` interface and supports both method-chained and standalone operation. Example - given a class ``User``, load only the ``name`` and ``fullname`` attributes:: session.query(User).options(load_only(User.name, User.fullname)) Example - given a relationship ``User.addresses -> Address``, specify subquery loading for the ``User.addresses`` collection, but on each ``Address`` object load only the ``email_address`` attribute:: session.query(User).options( subqueryload(User.addresses).load_only(Address.email_address) ) For a statement that has multiple entities, the lead entity can be specifically referred to using the :class:`_orm.Load` constructor:: stmt = ( select(User, Address) .join(User.addresses) .options( Load(User).load_only(User.name, User.fullname), Load(Address).load_only(Address.email_address), ) ) When used together with the :ref:`populate_existing <orm_queryguide_populate_existing>` execution option only the attributes listed will be refreshed. :param \*attrs: Attributes to be loaded, all others will be deferred. :param raiseload: raise :class:`.InvalidRequestError` rather than lazy loading a value when a deferred attribute is accessed. Used to prevent unwanted SQL from being emitted. .. versionadded:: 2.0 .. seealso:: :ref:`orm_queryguide_column_deferral` - in the :ref:`queryguide_toplevel` :param \*attrs: Attributes to be loaded, all others will be deferred. :param raiseload: raise :class:`.InvalidRequestError` rather than lazy loading a value when a deferred attribute is accessed. Used to prevent unwanted SQL from being emitted. .. versionadded:: 2.0 FT��deferredZ instrumentrb )rC ��_set_column_strategy)r\ rb rd r] Zwildcard_strategyr^ r^ r_ � load_only� s <� �z_AbstractLoad.load_only�Optional[bool])rH � innerjoinrL c C s* | j |ddi|dk r d|intjd�}|S )a; Indicate that the given attribute should be loaded using joined eager loading. This function is part of the :class:`_orm.Load` interface and supports both method-chained and standalone operation. examples:: # joined-load the "orders" collection on "User" select(User).options(joinedload(User.orders)) # joined-load Order.items and then Item.keywords select(Order).options( joinedload(Order.items).joinedload(Item.keywords) ) # lazily load Order.items, but when Items are loaded, # joined-load the keywords collection select(Order).options( lazyload(Order.items).joinedload(Item.keywords) ) :param innerjoin: if ``True``, indicates that the joined eager load should use an inner join instead of the default of left outer join:: select(Order).options(joinedload(Order.user, innerjoin=True)) In order to chain multiple eager joins together where some may be OUTER and others INNER, right-nested joins are used to link them:: select(A).options( joinedload(A.bs, innerjoin=False).joinedload( B.cs, innerjoin=True ) ) The above query, linking A.bs via "outer" join and B.cs via "inner" join would render the joins as "a LEFT OUTER JOIN (b JOIN c)". When using older versions of SQLite (< 3.7.16), this form of JOIN is translated to use full subqueries as this syntax is otherwise not directly supported. The ``innerjoin`` flag can also be stated with the term ``"unnested"``. This indicates that an INNER JOIN should be used, *unless* the join is linked to a LEFT OUTER JOIN to the left, in which case it will render as LEFT OUTER JOIN. For example, supposing ``A.bs`` is an outerjoin:: select(A).options( joinedload(A.bs).joinedload(B.cs, innerjoin="unnested") ) The above join will render as "a LEFT OUTER JOIN b LEFT OUTER JOIN c", rather than as "a LEFT OUTER JOIN (b JOIN c)". .. note:: The "unnested" flag does **not** affect the JOIN rendered from a many-to-many association table, e.g. a table configured as :paramref:`_orm.relationship.secondary`, to the target table; for correctness of results, these joins are always INNER and are therefore right-nested if linked to an OUTER join. .. note:: The joins produced by :func:`_orm.joinedload` are **anonymously aliased**. The criteria by which the join proceeds cannot be modified, nor can the ORM-enabled :class:`_sql.Select` or legacy :class:`_query.Query` refer to these joins in any way, including ordering. See :ref:`zen_of_eager_loading` for further detail. To produce a specific SQL JOIN which is explicitly available, use :meth:`_sql.Select.join` and :meth:`_query.Query.join`. To combine explicit JOINs with eager loading of collections, use :func:`_orm.contains_eager`; see :ref:`contains_eager`. .. seealso:: :ref:`loading_toplevel` :ref:`joined_eager_loading` rQ rR Nrk �rS )r[ r � EMPTY_DICT)r\ rH rk �loaderr^ r^ r_ � joinedload� s W� � z_AbstractLoad.joinedload�rH rL c C s | � |ddi�S )a Indicate that the given attribute should be loaded using subquery eager loading. This function is part of the :class:`_orm.Load` interface and supports both method-chained and standalone operation. examples:: # subquery-load the "orders" collection on "User" select(User).options(subqueryload(User.orders)) # subquery-load Order.items and then Item.keywords select(Order).options( subqueryload(Order.items).subqueryload(Item.keywords) ) # lazily load Order.items, but when Items are loaded, # subquery-load the keywords collection select(Order).options( lazyload(Order.items).subqueryload(Item.keywords) ) .. seealso:: :ref:`loading_toplevel` :ref:`subquery_eager_loading` rQ Zsubquery�r[ �r\ rH r^ r^ r_ � subqueryloadU s z_AbstractLoad.subqueryload� Optional[int])rH �recursion_depthrL c C s | j |ddid|id�S )a� Indicate that the given attribute should be loaded using SELECT IN eager loading. This function is part of the :class:`_orm.Load` interface and supports both method-chained and standalone operation. examples:: # selectin-load the "orders" collection on "User" select(User).options(selectinload(User.orders)) # selectin-load Order.items and then Item.keywords select(Order).options( selectinload(Order.items).selectinload(Item.keywords) ) # lazily load Order.items, but when Items are loaded, # selectin-load the keywords collection select(Order).options( lazyload(Order.items).selectinload(Item.keywords) ) :param recursion_depth: optional int; when set to a positive integer in conjunction with a self-referential relationship, indicates "selectin" loading will continue that many levels deep automatically until no items are found. .. note:: The :paramref:`_orm.selectinload.recursion_depth` option currently supports only self-referential relationships. There is not yet an option to automatically traverse recursive structures with more than one relationship involved. Additionally, the :paramref:`_orm.selectinload.recursion_depth` parameter is new and experimental and should be treated as "alpha" status for the 2.0 series. .. versionadded:: 2.0 added :paramref:`_orm.selectinload.recursion_depth` .. seealso:: :ref:`loading_toplevel` :ref:`selectin_eager_loading` rQ Zselectinru rl rq )r\ rH ru r^ r^ r_ � selectinloadv s 4�z_AbstractLoad.selectinloadc C s | � |ddi�S )a< Indicate that the given attribute should be loaded using "lazy" loading. This function is part of the :class:`_orm.Load` interface and supports both method-chained and standalone operation. .. seealso:: :ref:`loading_toplevel` :ref:`lazy_loading` rQ �selectrq rr r^ r^ r_ �lazyload� s z_AbstractLoad.lazyloadc C s | j |ddid|id�}|S )a� Indicate that the given attribute should be loaded using an immediate load with a per-attribute SELECT statement. The load is achieved using the "lazyloader" strategy and does not fire off any additional eager loaders. The :func:`.immediateload` option is superseded in general by the :func:`.selectinload` option, which performs the same task more efficiently by emitting a SELECT for all loaded objects. This function is part of the :class:`_orm.Load` interface and supports both method-chained and standalone operation. :param recursion_depth: optional int; when set to a positive integer in conjunction with a self-referential relationship, indicates "selectin" loading will continue that many levels deep automatically until no items are found. .. note:: The :paramref:`_orm.immediateload.recursion_depth` option currently supports only self-referential relationships. There is not yet an option to automatically traverse recursive structures with more than one relationship involved. .. warning:: This parameter is new and experimental and should be treated as "alpha" status .. versionadded:: 2.0 added :paramref:`_orm.immediateload.recursion_depth` .. seealso:: :ref:`loading_toplevel` :ref:`selectin_eager_loading` rQ Z immediateru rl rq )r\ rH ru rn r^ r^ r_ � immediateload� s *�z_AbstractLoad.immediateloadc C s | � |ddi�S )a Indicate that the given relationship attribute should remain unloaded. The relationship attribute will return ``None`` when accessed without producing any loading effect. This function is part of the :class:`_orm.Load` interface and supports both method-chained and standalone operation. :func:`_orm.noload` applies to :func:`_orm.relationship` attributes only. .. legacy:: The :func:`_orm.noload` option is **legacy**. As it forces collections to be empty, which invariably leads to non-intuitive and difficult to predict results. There are no legitimate uses for this option in modern SQLAlchemy. .. seealso:: :ref:`loading_toplevel` rQ �noloadrq rr r^ r^ r_ rz � s z_AbstractLoad.noload)rH �sql_onlyrL c C s | � |d|rdndi�S )a� Indicate that the given attribute should raise an error if accessed. A relationship attribute configured with :func:`_orm.raiseload` will raise an :exc:`~sqlalchemy.exc.InvalidRequestError` upon access. The typical way this is useful is when an application is attempting to ensure that all relationship attributes that are accessed in a particular context would have been already loaded via eager loading. Instead of having to read through SQL logs to ensure lazy loads aren't occurring, this strategy will cause them to raise immediately. :func:`_orm.raiseload` applies to :func:`_orm.relationship` attributes only. In order to apply raise-on-SQL behavior to a column-based attribute, use the :paramref:`.orm.defer.raiseload` parameter on the :func:`.defer` loader option. :param sql_only: if True, raise only if the lazy load would emit SQL, but not if it is only checking the identity map, or determining that the related value should just be None due to missing keys. When False, the strategy will raise for all varieties of relationship loading. This function is part of the :class:`_orm.Load` interface and supports both method-chained and standalone operation. .. seealso:: :ref:`loading_toplevel` :ref:`prevent_lazy_with_raiseload` :ref:`orm_queryguide_deferred_raiseload` rQ Z raise_on_sql�raiserq )r\ rH r{ r^ r^ r_ rb s " �z_AbstractLoad.raiseloadc C s | � |d�S )a Indicate an attribute should load using its predefined loader style. The behavior of this loading option is to not change the current loading style of the attribute, meaning that the previously configured one is used or, if no previous style was selected, the default loading will be used. This method is used to link to other loader options further into a chain of attributes without altering the loader style of the links along the chain. For example, to set joined eager loading for an element of an element:: session.query(MyClass).options( defaultload(MyClass.someattribute).joinedload( MyOtherClass.someotherattribute ) ) :func:`.defaultload` is also useful for setting column-level options on a related class, namely that of :func:`.defer` and :func:`.undefer`:: session.scalars( select(MyClass).options( defaultload(MyClass.someattribute) .defer("some_column") .undefer("some_other_column") ) ) .. seealso:: :ref:`orm_queryguide_relationship_sub_options` :meth:`_orm.Load.options` Nrq rr r^ r^ r_ � defaultload1 s %z_AbstractLoad.defaultload)�keyrb rL c C s$ ddd�}|rd|d< | � |f|�S )a� Indicate that the given column-oriented attribute should be deferred, e.g. not loaded until accessed. This function is part of the :class:`_orm.Load` interface and supports both method-chained and standalone operation. e.g.:: from sqlalchemy.orm import defer session.query(MyClass).options( defer(MyClass.attribute_one), defer(MyClass.attribute_two) ) To specify a deferred load of an attribute on a related class, the path can be specified one token at a time, specifying the loading style for each link along the chain. To leave the loading style for a link unchanged, use :func:`_orm.defaultload`:: session.query(MyClass).options( defaultload(MyClass.someattr).defer(RelatedClass.some_column) ) Multiple deferral options related to a relationship can be bundled at once using :meth:`_orm.Load.options`:: select(MyClass).options( defaultload(MyClass.someattr).options( defer(RelatedClass.some_column), defer(RelatedClass.some_other_column), defer(RelatedClass.another_column) ) ) :param key: Attribute to be deferred. :param raiseload: raise :class:`.InvalidRequestError` rather than lazy loading a value when the deferred attribute is accessed. Used to prevent unwanted SQL from being emitted. .. versionadded:: 1.4 .. seealso:: :ref:`orm_queryguide_column_deferral` - in the :ref:`queryguide_toplevel` :func:`_orm.load_only` :func:`_orm.undefer` Tre rb rg )r\ r~ rb �strategyr^ r^ r_ �deferX s 7 z_AbstractLoad.defer)r~ rL c C s | � |fddd��S )a� Indicate that the given column-oriented attribute should be undeferred, e.g. specified within the SELECT statement of the entity as a whole. The column being undeferred is typically set up on the mapping as a :func:`.deferred` attribute. This function is part of the :class:`_orm.Load` interface and supports both method-chained and standalone operation. Examples:: # undefer two columns session.query(MyClass).options( undefer(MyClass.col1), undefer(MyClass.col2) ) # undefer all columns specific to a single class using Load + * session.query(MyClass, MyOtherClass).options( Load(MyClass).undefer("*") ) # undefer a column on a related object select(MyClass).options( defaultload(MyClass.items).undefer(MyClass.text) ) :param key: Attribute to be undeferred. .. seealso:: :ref:`orm_queryguide_column_deferral` - in the :ref:`queryguide_toplevel` :func:`_orm.defer` :func:`_orm.undefer_group` FTre rg )r\ r~ r^ r^ r_ �undefer� s ( �z_AbstractLoad.undeferrV ��namerL c C s | � tfdd|� �di�S )a$ Indicate that columns within the given deferred group name should be undeferred. The columns being undeferred are set up on the mapping as :func:`.deferred` attributes and include a "group" name. E.g:: session.query(MyClass).options(undefer_group("large_attrs")) To undefer a group of attributes on a related entity, the path can be spelled out using relationship loader options, such as :func:`_orm.defaultload`:: select(MyClass).options( defaultload("someattr").undefer_group("large_attrs") ) .. seealso:: :ref:`orm_queryguide_column_deferral` - in the :ref:`queryguide_toplevel` :func:`_orm.defer` :func:`_orm.undefer` NZundefer_group_T)rh r )r\ r� r^ r^ r_ � undefer_group� s �z_AbstractLoad.undefer_group� _ColumnExpressionArgument[Any]�r~ � expressionrL c C s* t t�tj|��}| j|fddi|fd�S )a� Apply an ad-hoc SQL expression to a "deferred expression" attribute. This option is used in conjunction with the :func:`_orm.query_expression` mapper-level construct that indicates an attribute which should be the target of an ad-hoc SQL expression. E.g.:: stmt = select(SomeClass).options( with_expression(SomeClass.x_y_expr, SomeClass.x + SomeClass.y) ) .. versionadded:: 1.2 :param key: Attribute to be populated :param expr: SQL expression to be applied to the attribute. .. seealso:: :ref:`orm_queryguide_with_expression` - background and usage examples Zquery_expressionT)�extra_criteria)r r' rW r( ZLabeledColumnExprRolerh )r\ r~ r� r^ r^ r_ �with_expression� s � �z _AbstractLoad.with_expression�Iterable[Type[Any]])�classesrL c C s0 | j ddidttdd� |D �td��id�} | S )a� Indicate an eager load should take place for all attributes specific to a subclass. This uses an additional SELECT with IN against all matched primary key values, and is the per-query analogue to the ``"selectin"`` setting on the :paramref:`.mapper.polymorphic_load` parameter. .. versionadded:: 1.2 .. seealso:: :ref:`polymorphic_selectin` Zselectinload_polymorphicT�entitiesc s s | ]}t |�V qd S �Nr# )�.0�clsr^ r^ r_ � <genexpr> s z5_AbstractLoad.selectin_polymorphic.<locals>.<genexpr>)r~ rl )�_set_class_strategy�tuple�sorted�id)r\ r� r^ r^ r_ �selectin_polymorphic s ���z"_AbstractLoad.selectin_polymorphic� _StrategySpecr: )r rL c C s d S r� r^ �r\ r r^ r^ r_ � _coerce_strat! s z_AbstractLoad._coerce_stratz Literal[None]�Nonec C s d S r� r^ r� r^ r^ r_ r� $ s zOptional[_StrategySpec]�Optional[_StrategyKey]c C s" |d k rt t|�� ��}nd }|S r� )r� r� �items)r\ r � strategy_keyr^ r^ r_ r� ' s �Optional[_OptsType])rH r rE rS rT rL c C s& | � |�}| j|f|t|||d� | S )N)rS rE �reconcile_to_other)r� �_clone_for_bind_strategyr0 )r\ rH r rE rS rT r� r^ r^ r_ r[ 0 s �z(_AbstractLoad._set_relationship_strategy�Tuple[_AttrType, ...]�Optional[Tuple[Any, ...]])rd r rS r� rL c C s$ | � |�}| j||t|||d� | S )N)rS � attr_groupr� )r� r� r2 )r\ rd r rS r� r� r^ r^ r_ rh E s �z"_AbstractLoad._set_column_strategy)rd r rT rL c C s" | � |�}| j||d d|d� | S )NT)rE r� �r� r� )r\ rd r rT r� r^ r^ r_ �_set_generic_strategyY s �z#_AbstractLoad._set_generic_strategy� _OptsType)r rS rL c C s | � |�}| jd |d |d� | S )Nrl r� )r\ r rS r� r^ r^ r_ r� j s z!_AbstractLoad._set_class_strategy�Load��parentrL c C s t � �dS )z�apply this :class:`_orm._AbstractLoad` object as a sub-option o a :class:`_orm.Load` object. Implementation is provided by subclasses. N��NotImplementedError�r\ r� r^ r^ r_ �_apply_to_parents s z _AbstractLoad._apply_to_parent�rS rL c G s t � �dS )z�Apply a series of options as sub-options to this :class:`_orm._AbstractLoad` object. Implementation is provided by subclasses. Nr� �r\ rS r^ r^ r_ �options| s z_AbstractLoad.options� Optional[Tuple[_AttrType, ...]]�Optional[_WildcardKeyType]�Optional[_AttrGroupType]� rd r � wildcard_keyrS r� rE r� r� rL c C s t � �d S r� r� ) r\ rd r r� rS r� rE r� r� r^ r^ r_ r� � s z&_AbstractLoad._clone_for_bind_strategyr8 �Sequence[_MapperEntity])� compile_state�mapper_entitiesrL c C s& |j js d S | �||t|j� � d S r� )�compile_options�_enable_eagerloads�_processrF � current_path)r\ r� r� r^ r^ r_ �'process_compile_state_replaced_entities� s �z5_AbstractLoad.process_compile_state_replaced_entities)r� rL c C s2 |j js d S | �||jt|j� o*|j j � d S r� )r� r� r� Z_lead_mapper_entitiesrF r� �_for_refresh_state)r\ r� r^ r^ r_ �process_compile_state� s �z#_AbstractLoad.process_compile_state�r� r� �raiseerrrL c C s t � �dS )zimplemented by subclassesNr� )r\ r� r� r� r^ r^ r_ r� � s z_AbstractLoad._processr> r z Optional[_PathRepresentation])�to_chop�path�debugrL c C s� d}t t||j��D ]�\}\}}t|t�r||dkrZ|�dt� ��sR|�dt� ��rZ| S |t� dt� �kr|||j kr| d S ||kr�qqt|t �r�t |�r�t |�r�|� |�r�qq d S q||d d � S )N���r �:r ) � enumerate�zip� natural_pathrU rV �endswithr r r0 r~ r r Zisa)r� r� r� r� �iZc_tokenZp_tokenr^ r^ r_ � _chop_path� s: � ��������z_AbstractLoad._chop_path)NFF)N)N)N)F)F)TNN)NN)N)NNTNN)F)$�__name__� __module__� __qualname__� __slots__Z_is_strategy_option�__annotations__r` ri ro rs rv rx ry rz rb r} r� r� r� r� r� r r� r+ r[ rh r� r� r� r� r� r� r� r� � classmethodr� r^ r^ r^ r_ rD Z sr �HN �b$ �: �1&'<,!' � � � � �rD c @ s0 e Zd ZU dZdZdejjfdejj fdejj fdejj fgZ dZ de d< d e d< d e d< d d �d d�Zdd�dd�Zedd d�dd��Zdddd�dd�Zdd d�d d �Zdd d �d d �Zd!d"� Zd#d$d%d&d'�d(d)�Zd d&d*�d+d,�Zed-d.d/�d0d1��ZdAd3d4d5d6d7d%d8d9d.d:� d;d<�Zd=d>� Zd?d@� Z dS )Br� a� Represents loader options which modify the state of a ORM-enabled :class:`_sql.Select` or a legacy :class:`_query.Query` in order to affect how various mapped attributes are loaded. The :class:`_orm.Load` object is in most cases used implicitly behind the scenes when one makes use of a query option like :func:`_orm.joinedload`, :func:`_orm.defer`, or similar. It typically is not instantiated directly except for in some very specific cases. .. seealso:: :ref:`orm_queryguide_relationship_per_entity_wildcard` - illustrates an example where direct use of :class:`_orm.Load` may be useful )r� �context�additional_source_entitiesr� r� rE r� Nr zTuple[_LoadElement, ...]z$Tuple[_InternalEntityType[Any], ...]�_EntityType[Any])�entityc C s2 t dt|��}|j |j| _d| _d| _d| _d S )Nz$Union[Mapper[Any], AliasedInsp[Any]]r^ F)r r$ Z _post_inspect�_path_registryr� r� rE r� )r\ r� �inspr^ r^ r_ �__init__ s z Load.__init__rV �rL c C s d| j d � d�S )N�Load(r �)�r� �r\ r^ r^ r_ �__str__ s z Load.__str__r �r� rL c C s& | � | �}||_d|_d|_d|_|S )Nr^ F)�__new__r� r� rE r� )r� r� �loadr^ r^ r_ � _construct_for_existing_path s z!Load._construct_for_existing_pathr9 r< )r� � uncached_optrL c C s || kr | S | � |�S r� )�_adjust_for_extra_criteria)r\ r� r� r^ r^ r_ �'_adapt_cached_option_to_uncached_option s z,Load._adapt_cached_option_to_uncached_optionc s& | � � }t� fdd�| jD ��|_|S )Nc 3 s | ]}|� � �V qd S r� )� _prepend_path)r� �elementr� r^ r_ r� ' s z%Load._prepend_path.<locals>.<genexpr>)�_cloner� r� �r\ r� r] r^ r� r_ r� % s � zLoad._prepend_path)r� rL c s� | j D ]}|jr qq| S |j�� ��dkr0| S |jj}|�� � � dk sLt�ddddd�dd��| �� }t� ��fdd�| j D ��|_ |S ) z�Apply the current bound parameters in a QueryContext to all occurrences "extra_criteria" stored within this ``Load`` object, returning a new instance of this ``Load`` object. N� _LoadElementrB )�opt�replacement_cache_key�orig_cache_keyrL c s( | � � }t� �fdd�|jD ��|_|S )Nc 3 s | ]}�� � |�V qd S r� )�_apply_params_to_element)r� �crit�r� r� r^ r_ r� L s � �zCLoad._adjust_for_extra_criteria.<locals>.process.<locals>.<genexpr>)r� r� �_extra_criteria)r� r� r� Z cloned_optr^ r� r_ �processE s � z0Load._adjust_for_extra_criteria.<locals>.processc 3 s$ | ] }|j r�|�� �n|V qd S r� )r� �r� �value�r� r� r� r^ r_ r� V s ��z2Load._adjust_for_extra_criteria.<locals>.<genexpr>) r� r� �query�_generate_cache_keyr� �select_statementrZ r� r� )r\ r� r� � orig_queryr] r^ r� r_ r� , s � z Load._adjust_for_extra_criteriac C s@ | j }d}|D ],}|j}|rt�|td|d ��r| S qdS )zocalled at process time to allow adjustment of the root entity inside of _LoadElement objects. Nz_InternalEntityType[Any]r )r� � entity_zero�orm_util�_entity_corresponds_tor )r\ r� r� r� �ezero�entr^ r^ r_ �!_reconcile_query_entities_with_us` s � z&Load._reconcile_query_entities_with_usr8 r� rF r� r� c C sF | � ||�}t|jj�}| jD ]"}|r.|js.q |�| ||||� q d S r� )r� rF r� Z _current_pathr� rE r� )r\ r� r� r� �reconciled_lead_entityZhas_current_pathrn r^ r^ r_ r� t s � �z Load._processr� c s� | � � � � j| jkst�t� fdd��j�d�f�j D ��s�t� j�dkrb� jd }� jd }n� jd }� jd }t�j||� t � �jdd� � jdd� �� _| j r�t �fdd�| j D ��� _ � j r� j � j 7 _ � j� j7 _dS )z�apply this :class:`_orm.Load` object as a sub-option of another :class:`_orm.Load` object. This method is used by the :meth:`_orm.Load.options` method. c 3 s" | ]}t �|� j�d ��V qdS �r N�r� �$_entity_corresponds_to_use_path_implr� � odd_element�r� �elem)r] r^ r_ r� � s � �z(Load._apply_to_parent.<locals>.<genexpr>r� r r Nc 3 s | ]}|� � �V qd S r� )�_prepend_path_fromr� )r� r^ r_ r� � s ) Z _generaterE rZ �anyr� r r� �len�_raise_for_does_not_linkr �coercer� r� )r\ r� �attrname� parent_entityr^ )r] r� r_ r� � s. �� $ � �zLoad._apply_to_parentrD r. r� c G sb |D ]X}z|� | � W q tk rZ } z&t|t�sHt�d|� d��|�n� W 5 d}~X Y qX q| S )ac Apply a series of options as sub-options to this :class:`_orm.Load` object. E.g.:: query = session.query(Author) query = query.options( joinedload(Author.book).options( load_only(Book.summary, Book.excerpt), joinedload(Book.citations).options( joinedload(Citation.author) ) ) ) :param \*opts: A series of loader option objects (ultimately :class:`_orm.Load` objects) which should be applied to the path specified by this :class:`_orm.Load` object. .. versionadded:: 1.3.6 .. seealso:: :func:`.defaultload` :ref:`orm_queryguide_relationship_sub_options` zLoader option z2 is not compatible with the Load.options() method.N)r� �AttributeErrorrU rD �sa_exc� ArgumentError)r\ rS r� Zaer^ r^ r_ r� � s ��z Load.optionsTr� r� r� r� r� rj r� r� c C s^ |r d| _ | jjr t�d��n>t| j�r\|rF| jj�| jj|d � nt�d| jj� d���|d kr�tj | jd |||||||d� } | r�| j | f7 _ |d k s�t �| j t d|d �7 _ n�|D ]�} t| t�r�tj | j| |||||||d� } n tj | j| |||||||d� } | r�|tk�r"| j| _| j | f7 _ | j�d d �r�| �� } | j | f7 _ q�| S ) NT�3Wildcard token cannot be followed by another entityr zMapped attribute 'z#' does not refer to a mapped entity)r� r� r� z Tuple[_InternalEntityType[Any]]r� ru F)rE r� �is_tokenr r r �propZ_strategy_lookup�_ClassStrategyLoad�creater� rZ r� r rU rV �_TokenStrategyLoad�_AttributeStrategyLoadr0 � local_opts�get�_recurse) r\ rd r r� rS r� rE r� r� � load_elementrH �r1r^ r^ r_ r� � s~ � �� � � � z Load._clone_for_bind_strategyc C s | � � }| j�� |d< |S �Nr� ��_shallow_to_dictr� � serialize�r\ �dr^ r^ r_ � __getstate__G s zLoad.__getstate__c C s t �|d �|d< | �|� d S r �r � deserialize�_shallow_from_dict�r\ �stater^ r^ r_ � __setstate__L s zLoad.__setstate__)NNTNN) r� r� r� �__doc__r� r* �ExtendedInternalTraversal�dp_has_cache_key�InternalTraversalZdp_has_cache_key_listZ dp_boolean�_traverse_internals�_cache_key_traversalr� r� r� r� r� r� r� r� r� r� r� r+ r� r� r# r) r^ r^ r^ r_ r� � sF � �� 4 '0 � `r� c @ s� e Zd ZU dZdZdejjfdejjfdejjfgZ dZ de d< d e d< d e d< d e d< d Z d d�dd�Z d,dd�Zddd�dd�Zdd d�dd �Zd d � Zd d d!d"d#�d$d%�Zd&d�d'd(�Zd&d d)�d*d+�ZdS )-� _WildcardLoadz)represent a standalone '*' load operation)r r� r r r� r NrA �cache_key_traversalr� r� z Union[Tuple[()], Tuple[str]]Fr� r� c C s d| _ d | _tj| _d S )Nr^ )r� r r rm r r� r^ r^ r_ r� e s z_WildcardLoad.__init__Tc C sn |d k s t �|d } |r.t| t�r.| ttfks2t �|� d| � �} || _| f| _|r^t�|�| _ |d ksjt �d S )Nr r� ) rZ rU rV r r r r� r � immutabledictr ) r\ rd r r� rS r� rE r� r� rH r^ r^ r_ r� j s �� � z&_WildcardLoad._clone_for_bind_strategyrD r. r� c G s t d��d S )Nz(Star option does not support sub-optionsr� r� r^ r^ r_ r� � s z_WildcardLoad.optionsr� r� c C s� | j s t�| j d }|�t�r6|�d�d � dt� �}tt|j ��|�}|j sRt�t � |d| j d| j | j�}| j|f7 _dS )aP apply this :class:`_orm._WildcardLoad` object as a sub-option of a :class:`_orm.Load` object. This method is used by the :meth:`_orm.Load.options` method. Note that :class:`_orm.WildcardLoad` itself can't have sub-options, but it may be used as the sub-option of a :class:`_orm.Load` object. r r� N)r� rZ r� r �splitr r r �tokenr r r r r rE r� )r\ r� rH �effective_pathrn r^ r^ r_ r� � s � z _WildcardLoad._apply_to_parentc C s� |j j}|r| jsd S dd� |D �}|j}| j}|rX| �||�}|d krLd S ||ksXt�|rht|�dkslt�|d } t| t �s�t�| � || |�} | s�d S | } t| t �s�t�t j | j | | jd | j| j|d�} | s�d S | jjs�t�| �| ||d |� | S )Nc S s g | ] }|j �qS r^ )r� �r� r� r^ r^ r_ � <listcomp>� s z*_WildcardLoad._process.<locals>.<listcomp>r r )r� )r� r� rE r� r� r� rZ r rU rV �_find_entity_basestringr r r� r r r r� ) r\ r� r� r� � is_refreshr� r� � start_path�new_pathr4 r� Z path_elementrn r^ r^ r_ r� � sN � �z_WildcardLoad._processz"Iterable[_InternalEntityType[Any]]rV rF z"Optional[_InternalEntityType[Any]])r� r4 r� rL c C s� |� dt� ��r^tt|��dkrl|rlt�dd�dd� |D ��� dd�dd� |D ��� d ���n|� t�rld }|D ] }| S |r�t�d |� d ���nd S d S ) Nr� r zMCan't apply wildcard ('*') or load_only() loader option to multiple entities �, c s s | ]}t |�V qd S r� )rV r6 r^ r^ r_ r� � s z8_WildcardLoad._find_entity_basestring.<locals>.<genexpr>z?. Specify loader options for each entity individually, such as c s s | ]}d |� d�V qdS )r� z).some_option('*')Nr^ r6 r^ r^ r_ r� � s ��.FzFQuery has only expression-based entities - can't find property named "�".)r� r r �listr r �joinr )r\ r� r4 r� r� r^ r^ r_ r8 � s& ��� �z%_WildcardLoad._find_entity_basestring�Dict[str, Any]c C s | � � }|S r� )r r! r^ r^ r_ r# s z_WildcardLoad.__getstate__�r( rL c C s | � |� d S r� )r& r' r^ r^ r_ r) s z_WildcardLoad.__setstate__)NNTNN)r� r� r� r* r� r* r+ � dp_plain_obj�dp_string_multi_dictr. r1 r� rE r� r� r� r� r� r8 r# r) r^ r^ r^ r_ r0 Q s4 �� � =&r0 c @ s� e Zd ZU dZdZdZdejjfdejj fdejj fdej j fdej j fd ej j fgZ d Zd ed< d ed < d ed< ded< ded< ded< ded< ded< dd�dd�Zdd� Zedd�dd��Zdd d �d d �Zdd d �d d �Zd!d�d"d#�Zd!d$d%�d&d'�Zd(d)� Zddd*d+�d,d-�Zd.d/� Zd0d1� Zd2d3� Z e dKdd5d d6d7ddd8d d9d d:� d;d<��Z d$d�d=d>�Z d d�d?d@�Z dAd dB�dCdD�Z!dd dE�dFdG�Z"e#d d d dH�dIdJ��Z$d S )Lr� aA represents strategy information to select for a LoaderStrategy and pass options to it. :class:`._LoadElement` objects provide the inner datastructure stored by a :class:`_orm.Load` object and are also the object passed to methods like :meth:`.LoaderStrategy.setup_query`. .. versionadded:: 2.0 )r� r rE r r� rT r r� r r r� rE rT NzTuple[Any, ...]rj r� r rF z util.immutabledict[str, Any]�is_token_strategy�is_class_strategy�intr� c C s t | �S r� )r� r� r^ r^ r_ �__hash__B s z_LoadElement.__hash__c C s t �| |�S r� )r) �compare)r\ �otherr^ r^ r_ �__eq__E s z_LoadElement.__eq__c C s t | jo| jd k�S r� )rF r r r� r^ r^ r_ � is_opts_onlyH s z_LoadElement.is_opts_onlyr )�kwrL c K s | j }|�|�}| �|� |S r� )� __class__r� Z_shallow_copy_to)r\ rM r� �sr^ r^ r_ r� L s z_LoadElement._clonec K s | � � }|j�|�|_|S r� )r� r �union)r\ rM �newr^ r^ r_ � _update_optsS s z_LoadElement._update_optsrA c C s | � � }| j�� |d< |S r r r! r^ r^ r_ r# X s z_LoadElement.__getstate__r� rB c C s t �|d �|d< | �|� d S r r$ r' r^ r^ r_ r) ] s z_LoadElement.__setstate__c C sr |j }d}|D ]}|j}|rd} q&q|sBt�d|d � d���n,t�d|d � dd�d d � |D ��� d ���d S ) NFTzGQuery has only expression-based entities; attribute loader options for r z can't be applied here.z Mapped class z@ does not apply to any of the root entities in this query, e.g. r< c s s | ]}|j rt|j �V qd S r� )r� rV )r� �xr^ r^ r_ r� t s �z3_LoadElement._raise_for_no_match.<locals>.<genexpr>zV. Please specify the full path from one of the root entities to the target attribute. )r� r� r r r@ )r\ � parent_loaderr� r� Zfound_entitiesr� r� r^ r^ r_ �_raise_for_no_matcha s$ � ���z _LoadElement._raise_for_no_match�Optional[PathRegistry])r5 r� rL c C sL t �|j|�}|sdS t|�t|� }| j| }t�|f|dd� �}|S )a� receives the 'current_path' entry from an :class:`.ORMCompileState` instance, which is set during lazy loads and secondary loader strategy loads, and adjusts the given path to be relative to the current_path. E.g. given a loader path and current path:: lp: User -> orders -> Order -> items -> Item -> keywords -> Keyword cp: User -> orders -> Order -> items The adjusted path would be:: Item -> keywords -> Keyword Nr )r� r� r� r r� r r )r\ r5 r� Zchopped_start_pathZ tokens_removed_from_start_pathZloader_lead_path_elementr^ r^ r_ �'_adjust_effective_path_for_current_path s �� �z4_LoadElement._adjust_effective_path_for_current_pathc C s t � �dS )z�Apply ORM attributes and/or wildcard to an existing path, producing a new path. This method is used within the :meth:`.create` method to initialize a :class:`._LoadElement` object. Nr� �r\ r� rH r� r� r� r� r^ r^ r_ � _init_path� s z_LoadElement._init_pathc C s t � �dS )zimplemented by subclasses.Nr� )r\ rT r� r� r r� r^ r^ r_ �_prepare_for_compile_state� s z'_LoadElement._prepare_for_compile_statec C sN | � |||||�}|D ]2}||jkr>t�| |j| �|j|< q| |j|< qdS )z^populate ORMCompileState.attributes with loader state for this _LoadElement. N)rZ � attributesr� � _reconcile)r\ rT r� r� r r� �keysr~ r^ r^ r_ r� � s � � z"_LoadElement.process_compile_stateTz%Union[_AttrType, _StrPathToken, None]r� r� r� r� ) r� rH r r� r rE r� r� r� r� rL c C s� | � | �} || _|| _|| _|r*t�|�ntj| _d| _| dk rH| | _ n|dkr\|s\d| _ nd| _ | � |||||| �}|s~dS | j |j ks�t �|| _| S )z+Create a new :class:`._LoadElement` object.r^ NT)r� r� r rE r r2 rm r r� rT rY rE r rZ ) r� r� rH r r� r rE r� r� r� r� r� r^ r^ r_ r � s2 � �z_LoadElement.createc C s t � �d S r� r� r� r^ r^ r_ r� s z_LoadElement.__init__c C s0 | � � }t�| jd d � | jdd � �|_|S )N���)r� r r r� )r\ r] r^ r^ r_ r s $z_LoadElement._recurser� r� c sV t � fdd�|j�d�f|j D ��sJt�d� jd � d|jd � d���� �|j�S )a% adjust the path of this :class:`._LoadElement` to be a subpath of that of the given parent :class:`_orm.Load` object's path. This is used by the :meth:`_orm.Load._apply_to_parent` method, which is in turn part of the :meth:`_orm.Load.options` method. c 3 s" | ]}t �|� j�d ��V qdS r r r r� r^ r_ r� s � �z2_LoadElement._prepend_path_from.<locals>.<genexpr>r� z Attribute "r z " does not link from element "r> )r r� r r� r r r� r� r^ r� r_ r s �� �z _LoadElement._prepend_path_fromr� c C s^ | � � }|j| jkst�|j| jks(t�|j| jks8t�t�|dd� |jd d � �|_|S )Nr r� )r� r rZ r rF r r r� r� r^ r^ r_ r� % s "z_LoadElement._prepend_path)� replacement�existingrL c C s� | j r |S | j dkr| S |j r"| S |j dkr0|S || kr<| S |j| jkrX|j| jkrX| S | jr�|�� }|j�| j�|_| j| j7 _|S |jr�| �� } | j�|j�| _| j|j7 _| S | jjr�| S t � d| j� d���dS )a define behavior for when two Load objects are to be put into the context.attributes under the same key. :param replacement: ``_LoadElement`` that seeks to replace the existing one :param existing: ``_LoadElement`` that is already present. FzLoader strategies for z conflictN) rT r r rL r� rP r� r� r r ZInvalidRequestError)r_ r` r^ r^ r_ r\ 0 sD � ��� �z_LoadElement._reconcile)TNNN)%r� r� r� r* r� �__visit_name__r* r+ r, rC rD r- Zdp_clauseelement_listr. r/ r� rH rK �propertyrL r� rR r# r) rU rW rY rZ r� r� r r� r r r� � staticmethodr\ r^ r^ r^ r_ r� s\ � � & �&+ r� c s� e Zd ZU dZdZdZejdej j fdej j fg Zde d< de d< dZ dZd d � Zd d � Zd d� Zdd� Z� fdd�Z� fdd�Z� ZS )r z�Loader strategies against specific relationship or column paths. e.g.:: joinedload(User.addresses) defer(Order.name) selectinload(User.orders).lazyload(Order.items) )rP �_path_with_polymorphic_pathZ attribute_strategy_load_elementrP rd z*Union[Mapper[Any], AliasedInsp[Any], None]rV Fc C s |d k s t �d | _d | _t|�\}}} |jrH|} || }|jrD|j}|S |jsVdsVt �t� |d |j �s�|r�|r�||d k r�t � d��q�t |t|�|j � nd S |r�|jr�t �|| _n|j| _t|dd �r�|j} t| �} | | _|j| | _|| | }n|| }|j�r|j}|S )NFr� r z�Can't apply wildcard ('*') or load_only() loader option to multiple entities in the same option. Use separate options per entity.rP )rZ rP rd �_parse_attr_argumentZ is_property� has_entityZ entity_pathZ is_attributer� r r� r r r rV r� rY r$ ) r\ r� rH r� r� r� r� r� �_r �acZext_infor^ r^ r_ rY � sJ �� z!_AttributeStrategyLoad._init_pathc C s> | j std��|jj}|j}|�� }|�� }|�|t| j � �S )a� Apply the current bound parameters in a QueryContext to the immediate "extra_criteria" stored with this Load object. Load objects are typically pulled from the cached version of the statement from a QueryContext. The statement currently being executed will have new values (and keys) for bound parameters in the extra criteria which need to be applied by loader strategies when they handle this criteria for a result set. z8this should only be called if _extra_criteria is present)r� rZ r� r� r� r� r� r% )r\ r� r� Z current_queryZk1Zk2r^ r^ r_ �_generate_extra_criteria� s ��z/_AttributeStrategyLoad._generate_extra_criteriac C s� | j s t�| j}|st�|js>ttjj|jj |jfddd��}| j }|rd| � ||�}|d kr`d S |}d|j f}||kr�|| }|}|� |�} | ||< n|||< d S )NT)�aliasedZ_use_mapper_pathZpath_with_polymorphic) rd rZ rP �is_aliased_classr$ r� r Z_with_polymorphic_factory�mapperZ base_mapperrW r� Z _merge_with) r\ r� r� Zpwpir: r; r~ Zexisting_aliased_inspZthis_aliased_inspZnew_aliased_inspr^ r^ r_ �_set_of_type_info� s< �� � � z(_AttributeStrategyLoad._set_of_type_infoc C s� |j }|jj}| jjrt�|r(| js(g S | jr<| �|j |� | j sL| j sLg S |r`|s`| � ||� | jj rr| jj}n| j}|r�|d k s�t�| �||�}|d kr�g S dtt|�jfgS �Nrn )r� r� r� r� r rZ rE rP rm r[ r r rU rf r� rW r r r� ) r\ rT r� r� r r� r� r9 r5 r^ r^ r_ rZ s. �z1_AttributeStrategyLoad._prepare_for_compile_statec sd t � �� }d|d< | jr&| j�� |d< | jr`| jjr>d |d< n"| jjrT| jj|d< n ds`td��|S )Nr^ r� rd rP Fz unexpected object for _of_type) �superr# rd r rP rk Z is_mapper�class_rZ r! �rN r^ r_ r# A s � z#_AttributeStrategyLoad.__getstate__c sV t � �|� |�dd �r*t�|d �| _nd | _|�dd �rLt|d �| _nd | _d S )Nrd rP )ro r) r r r% rd r$ rP r' rq r^ r_ r) Y s � z#_AttributeStrategyLoad.__setstate__)r� r� r� r* r� ra r� r. r* r+ Zdp_multir, r� rF rE rY ri rm rZ r# r) � __classcell__r^ r^ rq r_ r j s& ��G%", r c @ s0 e Zd ZdZdZdZdZdZdd� Zdd� Z d S ) r a Loader strategies against wildcard attributes e.g.:: raiseload('*') Load(User).lazyload('*') defer('*') load_only(User.name, User.email) # will create a defer('*') joinedload(User.addresses).raiseload('*') Ztoken_strategy_load_elementTFc C sN |d k rJ|� t�}|� t�s |r@|r2|� d|� �}|�|�}|S t�d��|S )Nr� �kStrings are not accepted for attribute names in loader options; please use class-bound attributes directly.)r� r r r4 r r )r\ r� rH r� r� r� r� Z default_tokenr^ r^ r_ rY | s �z _TokenStrategyLoad._init_pathc C s� |j }|jj}| jjst�|r(| js(g S | js8| js8g S | j}|r\t � |f|jdd � �}|r|| � ||�} | d krxg S | }dd� t t |��� D �S )Nr c S s g | ] }d |f�qS )rn r^ )r� r� r^ r^ r_ r7 � s �zA_TokenStrategyLoad._prepare_for_compile_state.<locals>.<listcomp>)r� r� r� r� r rZ rE r r r r rW r r Z"_generate_natural_for_superclasses� r\ rT r� r� r r� r� r9 r5 Znew_effective_pathr^ r^ r_ rZ � s4 � � ��z-_TokenStrategyLoad._prepare_for_compile_stateN) r� r� r� r* ra � inherit_cacherF rE rY rZ r^ r^ r^ r_ r i s r c @ s0 e Zd ZdZdZdZdZdZdd� Zdd� Z d S ) r z�Loader strategies that deals with a class as a target, not an attribute path e.g.:: q = s.query(Person).options( selectin_polymorphic(Person, [Engineer, Manager]) ) TFZclass_strategy_load_elementc C s |S r� r^ rX r^ r^ r_ rY � s z _ClassStrategyLoad._init_pathc C s^ |j }|jj}|r | js g S | js,| js,g S | j}|rR| �||�} | d krNg S | }d|jfgS rn ) r� r� r� rE r r r� rW r� rt r^ r^ r_ rZ � s �z-_ClassStrategyLoad._prepare_for_compile_stateN) r� r� r� r* ru rF rE ra rY rZ r^ r^ r^ r_ r � s r z Callable[..., _AbstractLoad]r� rF r )�methr] �chainedrM rL c C s d }d|dd� fd|dd � ffD ]�\}}|D ]�}t |t�r�|�dt �rftjddd� |d d � }|tkr�|r|t�d ��|d kr�t� }| |t f|�}q�t�d ��q0|d kr�t |�\}} }t | �}|r�|s�|� |�}q�| ||fd di|��}q0| ||f|�}q0q$|�s t �|S ) NTr r� Fr= z�The undocumented `.{WILDCARD}` format is deprecated and will be removed in a future version as it is believed to be unused. If you have been using this functionality, please comment on Issue #4390 on the SQLAlchemy project tracker.rM rN r r rs rJ )rU rV � startswithr r rX r r r0 r re r� r} rZ ) rv r] rw rM � lead_element� is_defaultZ_keysrH rg � lead_entityr^ r^ r_ �_generate_from_keys� sL ( � �� ��� r| rG zDTuple[InspectionAttr, _InternalEntityType[Any], MapperProperty[Any]]rp c C s| z t | �}W n0 tjk r< } zt�d�|�W 5 d}~X Y nX t|�rR|j}|}n t|�rh|j}|j}n t�d��|||fS )a parse an attribute or wildcard argument to produce an :class:`._AbstractLoad` instance. This is used by the standalone loader strategy functions like ``joinedload()``, ``defer()``, etc. to produce :class:`_orm.Load` or :class:`._WildcardLoad` objects. z:expected ORM mapped attribute for loader strategy argumentN)r$ r ZNoInspectionAvailabler r r� r r )rH r� �errr{ r r^ r^ r_ re : s$ ���re )�fnrL c C s4 t t| j�}|j}d| j� d| j� d�|_|| _| S )z�decorator that applies docstrings between standalone loader functions and the loader methods on :class:`._AbstractLoad`. z=Produce a new :class:`_orm.Load` object with the :func:`_orm.z#` option applied. See :func:`_orm.z` for usage examples. )rY rD r� r* )r~ Zbound_fnZfn_docr^ r^ r_ �loader_unbound_fn_ s �� r )r] rM rL c O s t tj| d|�S )NT)r| r� r` �r] rM r^ r^ r_ r` u s r` Fra rc c G s& t |d �\}}}t|�j|d| i�S )Nr rb )re r� ri )rb rd rg ry r^ r^ r_ ri z s ri c O s t tj| d|�S �NF)r| r� ro r� r^ r^ r_ ro � s ro )r] rL c G s t tj| di �S r� )r| r� rs �r] r^ r^ r_ rs � s rs )ru rt )r] ru rL c G s t tj|dd| i�S �NFru )r| r� rv �ru r] r^ r^ r_ rv � s �rv c G s t tj| di �S r� )r| r� rx r� r^ r^ r_ rx � s rx c G s t tj|dd| i�S r� )r| r� ry r� r^ r^ r_ ry � s �ry c G s t tj| di �S r� )r| r� rz r� r^ r^ r_ rz � s rz c O s t tj| d|�S r� )r| r� rb r� r^ r^ r_ rb � s rb c G s t tj| di �S r� )r| r� r} r� r^ r^ r_ r} � s r} )r~ � addl_attrsrb rL c G s: |rt jddd� |r d|i}ni }ttj| f| d|�S )Nz}The *addl_attrs on orm.defer is deprecated. Please use method chaining in conjunction with defaultload() to indicate a path.�1.3rN rb F)r rX r| r� r� )r~ rb r� rM r^ r^ r_ r� � s � r� )r~ r� rL c G s( |rt jddd� ttj| f| di �S )NzThe *addl_attrs on orm.undefer is deprecated. Please use method chaining in conjunction with defaultload() to indicate a path.r� rN F)r rX r| r� r� )r~ r� r^ r^ r_ r� � s �r� rV r� c C s t � }|�| �S r� )r0 r� )r� r� r^ r^ r_ r� � s r� r� r� c C s t tj| fdd|i�S )NFr� )r| r� r� )r~ r� r^ r^ r_ r� � s �r� r� r� )�base_clsr� rL c C s t | �}|�|�S r� )r� r� )r� r� Zulr^ r^ r_ r� � s r� c C s� t | �dkr�| d j| d jjk }t|�r4t|�}n|jj}t�d|� d| d � d�|rhd| d � d�nd |s�| d j s�t � | jt |�j�r�d | d � d|� d | d jjj� d |� d � nd f ��n t�d|� d| d � d���d S )Nr r� r^ z ORM mapped entity or attribute "z#" does not link from relationship "z%s".%sz .of_type(r� � z Did you mean to use "z,)" or "loadopt.options(selectin_polymorphic(z, [z ]), ...)" ?zORM mapped attribute "z " does not link mapped class "�") r r� rl rp r rV r� r r rk r� r� r$ )r� r r Zpath_is_of_typeZparent_entity_strr^ r^ r_ r � s0 �� ��. ����r )sr* � __future__r �typingr r r r r r r r r r r r r� r r� Z_typingr r r r r[ r �baser Z interfacesr Z path_registryr r r r r r r r r r" r r$ �sqlr% r& r' r( r) r* Zsql.baser+ Z util.typingr, r- r. r0 r� r2 r3 � TYPE_CHECKINGr5 r6 r� r7 r8 r9 r: r; r< rl r= r> Z sql._typingr? r@ Z sql.cache_keyrA rB rG Z_WildcardKeyTyperV r� r� Z_AttrGroupTypeZGenerativeOnTraversalrD r� r0 Z HasCacheKeyZHasShallowCopyZ Traversibler� r r r r| re r r` ri ro rs rv rx ry rz rb r} r� r� r� r� r� r r^ r^ r^ r_ �<module> s u A � [ Y8@%���