U
|
¸ý°d¶H ã @ 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 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*m/Z/ d!d)l*m0Z0 d!d*l1m2Z2 d!d+l3m4Z4 d!d,l3m5Z5 d!d-l3m6Z6 d.Z7d/e8d0< d1Z9d2e8d3< ed4d5d6Z:ej;rÚdd7lm<Z< dd8lm=Z= dd9l>m?Z? dd:l>m@Z@ dd;l>mAZA dd<l mBZB dd=l mCZC dd>l mDZD dd?lEmFZF dd@l mGZG d!dAlHmIZI d!dBlHmJZJ d!dClKmLZL d!dDlKmMZM eeNdEf ZOe5dF ZPeeNef ZQeeNef ZRe eOdGf ZSG dHdI dIe/jTe ZUG dJdK dKeUZVG dLdM dMeUZWG dNdO dOe,jXe/jYe0jZZ[G dPdQ dQe[Z\G dRdS dSe[Z]G dTdU dUe[Z^dVdWdXdYdIdZd[d\Z_d]d^d_d`daZ`d4d4dbdcddZaead]dYdIdedfdgZbeadhdid]dXdIdjdkdlZcead]dYdIdedmdnZdead]dIdodpdqZeeaddrd]dsdIdtdudvZfead]dIdodwdxZgeaddrd]dsdIdtdydzZhead]dIdod{d|Ziead]dYdIded}d~Zjead]dIdoddZkeadhdid]d]dXdIdddZlead]d]dIdd
dZmeaddIdddZnead]ddIdddZoeadddIdddZpdd ZqdS )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)Ú_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)ÚCacheKeyzQueryableAttribute[Any])r. r0 .c
|
@ s` e Zd ZU dZdZded< dqdddd d
|
d d Zdd ddd dddZdrddd dddZdd dddZ dsddd dddZ
|
dd dd d Z dtddd dd d Z dd dd d!Z duddd d"d#d$Zdd dd%d&Zdvddd d'd(d)Zdd d*d+d,Zd-d d.d/d0Zdd1d d2d3d4Zd5d d6d7d8Zed9d:d;d<d=Zed>d?d;d@d=ZdAdBd;dCd=ZedwddAddDdd dEdFdGZedxdHdAdDd dIdJdKZedydHd9dd dLdMdNZed9dOd dPdQdRZdSd?dTdUdVZ d d dWdXdYZ dzdZdBd[dDd\ddd d]d^d_Z d`dad?dbdcddZ d`d?dedfdgZ d`dadd?dhdidjZ!e"d{dkdlddmdndodpZ#dS )|Ú _AbstractLoad)Úpropagate_to_loadersTÚboolrC NFÚ _AttrTypez Optional[_FromClauseArgument]r- )ÚattrÚaliasÚ _is_chainÚreturnc C s |dk r6t |ts"t tj|¡}qrtjddd |}n<t|ddrnt |t sPt
|
t |j }|dk sft
|
|j }nd}| j|ddidd |i|rd
|
ndd }|S ) ad 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ÚjoinedFZeager_from_aliasT)rC ÚoptsÚ_reconcile_to_other)Ú
|
isinstanceÚstrr& Úexpectr' ZFromClauseRoler Úwarn_deprecatedÚgetattrr ÚAssertionErrorr# rM Z
|
selectableÚ_set_relationship_strategy)ÚselfrF rG rH Z coerced_aliasZotÚcloned© r[ úVd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/orm/strategy_options.pyÚcontains_eager^ s, +
|
û
|
|
ûz _AbstractLoad.contains_eager©Ú raiseload©Úattrsr_ rI 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)
|
)
|
|
: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
|
instrumentr_ )Ú*©Ú_set_column_strategy)rY r_ ra rZ Zwildcard_strategyr[ r[ r\ Ú load_only§ s 4þ
|
þz_AbstractLoad.load_onlyúOptional[bool])rF Ú innerjoinrI 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"
|
query(User).options(joinedload(User.orders))
|
|
# joined-load Order.items and then Item.keywords
|
query(Order).options(
|
joinedload(Order.items).joinedload(Item.keywords))
|
|
# lazily load Order.items, but when Items are loaded,
|
# joined-load the keywords collection
|
query(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::
|
|
query(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::
|
|
query(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::
|
|
query(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`
|
|
rN rO Nri ©rP )rX r Ú
|
EMPTY_DICT)rY rF ri Úloaderr[ r[ r\ Ú
|
joinedloadê s Tÿ
|
ûz_AbstractLoad.joinedload©rF rI c C s | |ddi¡S )ab 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"
|
query(User).options(subqueryload(User.orders))
|
|
# subquery-load Order.items and then Item.keywords
|
query(Order).options(
|
subqueryload(Order.items).subqueryload(Item.keywords))
|
|
# lazily load Order.items, but when Items are loaded,
|
# subquery-load the keywords collection
|
query(Order).options(
|
lazyload(Order.items).subqueryload(Item.keywords))
|
|
|
.. seealso::
|
|
:ref:`loading_toplevel`
|
|
:ref:`subquery_eager_loading`
|
|
rN Zsubquery©rX ©rY rF r[ r[ r\ Ú subqueryloadG s z_AbstractLoad.subqueryloadú Optional[int])rF Úrecursion_depthrI c C s | j |ddid|idS )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"
|
query(User).options(selectinload(User.orders))
|
|
# selectin-load Order.items and then Item.keywords
|
query(Order).options(
|
selectinload(Order.items).selectinload(Item.keywords))
|
|
# lazily load Order.items, but when Items are loaded,
|
# selectin-load the keywords collection
|
query(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`
|
|
rN Zselectinrs rj ro )rY rF rs r[ r[ r\ Ú selectinloadf s
|
2ý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`
|
|
rN Úselectro rp 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`
|
|
rN Z immediaters rj ro )rY rF rs rl 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.
|
|
.. note:: Setting this loading strategy as the default strategy
|
for a relationship using the :paramref:`.orm.relationship.lazy`
|
parameter may cause issues with flushes, such if a delete operation
|
needs to load related objects and instead ``None`` was returned.
|
|
.. seealso::
|
|
:ref:`loading_toplevel`
|
|
rN Únoloadro rp r[ r[ r\ rx ß s z_AbstractLoad.noload)rF Úsql_onlyrI 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`
|
|
rN Z raise_on_sqlÚraisero )rY rF ry r[ r[ r\ r_ ù s " ÿz_AbstractLoad.raiseloadc C s | |d¡S )aÑ Indicate an attribute should load using its default loader style.
|
|
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.query(MyClass).options(
|
defaultload(MyClass.someattribute).
|
defer("some_column").
|
undefer("some_other_column")
|
)
|
|
.. seealso::
|
|
:ref:`orm_queryguide_relationship_sub_options`
|
|
:meth:`_orm.Load.options`
|
|
Nro rp r[ r[ r\ Ú defaultload s z_AbstractLoad.defaultload)Úkeyr_ rI 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`::
|
|
|
session.query(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`
|
|
Trb r_ re )rY r| r_ Ústrategyr[ r[ r\ Údefer> s 7
|
z_AbstractLoad.defer)r| rI 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
|
session.query(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`
|
|
FTrb re )rY r| r[ r[ r\ Úundeferz s & ÿz_AbstractLoad.undeferrS ©ÚnamerI 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`::
|
|
session.query(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)rf r )rY r r[ r[ r\ Ú undefer_group¤ s
|
ÿz_AbstractLoad.undefer_groupú _ColumnExpressionArgument[Any]©r| Ú
|
expressionrI c C s, t t tj|¡}| j|fddid|idS )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_expressionTr
rj )r r& rT r' ZLabeledColumnExprRolerf )rY r| r
r[ r[ r\ Úwith_expressionÄ s ÿ ÿz _AbstractLoad.with_expressionúIterable[Type[Any]])ÚclassesrI c C s0 | j ddidttdd |D tdid} | 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| rj )Ú_set_class_strategyÚtupleÚsortedÚid)rY r r[ r[ r\ Úselectin_polymorphicë s ÿÿþz"_AbstractLoad.selectin_polymorphicÚ _StrategySpecr9 )r} rI c C s d S r r[ ©rY 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)rY r} Ú strategy_keyr[ r[ r\ r s úOptional[_OptsType])rF r} rC rP rQ rI c C s& | |¡}| j|f|t|||d | S )N)rP rC Úreconcile_to_other)r Ú_clone_for_bind_strategyr/ )rY rF r} rC rP rQ r r[ r[ r\ rX s
|
úz(_AbstractLoad._set_relationship_strategyúTuple[_AttrType, ...])ra r} rP rI c C s" | |¡}| j||t||d | S )N)rP Ú
|
attr_group)r r r1 )rY ra r} rP r r[ r[ r\ rf * s
|
ûz"_AbstractLoad._set_column_strategy)ra r} rQ rI c C s" | |¡}| j||d d|d | S )NT)rC r ©r r )rY ra r} rQ r r[ r[ r\ Ú_set_generic_strategy< s
|
ûz#_AbstractLoad._set_generic_strategyÚ _OptsType)r} rP rI c C s | |¡}| jd |d |d | S )Nrj r )rY r} rP r r[ r[ r\ r M s
|
z!_AbstractLoad._set_class_strategyÚLoad©ÚparentrI 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)rY r¤ r[ r[ r\ Ú_apply_to_parentV s z _AbstractLoad._apply_to_parent©rP rI c G s
|
t dS )zApply a series of options as sub-options to this
|
:class:`_orm._AbstractLoad` object.
|
|
Implementation is provided by subclasses.
|
|
Nr¥ ©rY rP r[ r[ r\ Úoptions_ s z_AbstractLoad.optionsú Optional[Tuple[_AttrType, ...]]úOptional[_WildcardKeyType]úOptional[_AttrGroupType]©ra r} Ú wildcard_keyrP r rC r rI c C s
|
t d S r r¥ )rY ra r} r¯ rP r rC r r[ r[ r\ r h s
|
z&_AbstractLoad._clone_for_bind_strategyr7 úSequence[_MapperEntity])Ú compile_stateÚmapper_entitiesrI c C s& |j js d S | ||t|j ¡ d S r )Úcompile_optionsÚ_enable_eagerloadsÚ_processrD Ú current_path)rY r± r² r[ r[ r\ Ú'process_compile_state_replaced_entitiest s
|
ýz5_AbstractLoad.process_compile_state_replaced_entities)r± rI c C s2 |j js d S | ||jt|j o*|j j ¡ d S r )r³ r´ rµ Z_lead_mapper_entitiesrD r¶ Ú_for_refresh_state)rY r± r[ r[ r\ Úprocess_compile_state
s üz#_AbstractLoad.process_compile_state©r± r² ÚraiseerrrI c C s
|
t dS )zimplemented by subclassesNr¥ )rY r± r² r» r[ r[ r\ rµ s z_AbstractLoad._processr= r z Optional[_PathRepresentation])Úto_chopÚpathÚdebugrI c C s¸ d}t t||jD ]\}\}}t|trl|dkrJ| dt ¡rJ| S |t dt krl||j krl d S ||krxqqt|t
|
r t |r t |r | |¡r qq d S q||d d
S )Néÿÿÿÿr ú:r ) Ú enumerateÚzipÚ natural_pathrR rS Úendswithr r/ r r| r r Zisa)r r¼ r½ r¾ ÚiZc_tokenZp_tokenr[ r[ r\ Ú
|
_chop_path s2
|
ÿ
|
ÿþÿþýüz_AbstractLoad._chop_path)NF)N)N)N)F)F)TNN)N)N)NNTN)F)$Ú__name__Ú
|
__module__Ú __qualname__Ú __slots__Z_is_strategy_optionÚ__annotations__r] rg rm rq rt rv rw rx r_ r{ r~ r r r r r r r* rX rf r r r§ rª r r· r¹ rµ Ú classmethodrÆ r[ r[ r[ r\ rB X sl
|
üIF ý]" ý8 ý1& <* ' ú ü ü ø ürB c
|
@ s e Zd ZU dZdZdejjfdejj fdejj
|
fgZ dZ de d< de d< d d
|
d d Zd dddZedd dddZddddddZdd dddZd d Zd d d d!d"d#d$Zd d!d%d&d'Zed(d)d*d+d,Zd;d.d/d0d1d2d d3d)d4d5d6Zd7d8 Zd9d: ZdS )<r¢ 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½ Úcontextr½ rÍ rC Nr zTuple[_LoadElement, ...]ú_EntityType[Any])Úentityc C s, t dt|}|j |j| _d| _d| _d S )Nz$Union[Mapper[Any], AliasedInsp[Any]]r[ F)r r# Z _post_inspectÚ_path_registryr½ rÍ rC )rY rÏ Úinspr[ r[ r\ Ú__init__à s
|
z Load.__init__rS ©rI c C s d| j d dS )NúLoad(r ú))r½ ©rY r[ r[ r\ Ú__str__è s z Load.__str__)r½ rI c C s | | ¡}||_d|_d|_|S )Nr[ F)Ú__new__r½ rÍ rC )r r½ Úloadr[ r[ r\ Ú _construct_for_existing_pathë s
|
|
z!Load._construct_for_existing_pathr8 r; )rÍ Ú uncached_optrI c C s
|
| |¡S r )Ú_adjust_for_extra_criteria)rY rÍ rÛ r[ r[ r\ Ú'_adapt_cached_option_to_uncached_optionó s z,Load._adapt_cached_option_to_uncached_option)rÍ rI c sf j jdddddd fdd tfdd| jD }r^| ¡ }||_|S | S dS ) 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.
|
|
NFÚ _LoadElement)ÚoptrI c sh | j s
|
| S dd ks d krH ¡ j ¡ d k s<td k sHttfdd| j D | _ | S )NTc 3 s | ]} |¡V qd S r )Ú_apply_params_to_element)r Úcrit)Úorig_cache_keyÚreplacement_cache_keyr[ r\ r s
|
ý ÿzCLoad._adjust_for_extra_criteria.<locals>.process.<locals>.<genexpr>)Ú_extra_criteriaÚ_generate_cache_keyÚqueryrW r )rß )rÍ Ú
|
found_critrâ Ú
|
orig_queryrã r[ r\ Úprocess s
|
ü
|
z0Load._adjust_for_extra_criteria.<locals>.processc 3 s$ | ] }|j r | ¡ n|V qd S r )rä Ú_clone©r Úvalue)ré r[ r\ r s ÿz2Load._adjust_for_extra_criteria.<locals>.<genexpr>)r± Úselect_statementr rÍ rê )rY rÍ Z new_contextrZ r[ )rÍ rç râ rè 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.
|
|
Nú_InternalEntityType[Any]r )r½ Ú entity_zeroÚorm_utilÚ_entity_corresponds_tor )rY r² r» r½ ÚezeroÚentr[ r[ r\ Ú!_reconcile_query_entities_with_us* s ü
|
z&Load._reconcile_query_entities_with_usr7 r° rD r rº c C s. | ||¡}| jD ]}| | ||||¡ qd S r )rô rÍ r¹ )rY r± r² r» Úreconciled_lead_entityrl r[ r[ r\ rµ > s ÿ
|
ûz Load._processr£ c sà | ¡ }|j| jkstt td jd td|jd ¡st|jdkr`|jd }|jd }n|jd }|jd }t j|| t
|
jdd
|jdd
¡|_| j rÆt fdd| j D |_ |j rÜ j |j 7 _ 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.
|
|
rî r¿ r r Nc 3 s | ]}| ¡V qd S r )Ú_prepend_path_fromrë ©r¤ r[ r\ r l s z(Load._apply_to_parent.<locals>.<genexpr>) Z _generaterC rW rð Ú$_entity_corresponds_to_use_path_implr r½ ÚlenÚ_raise_for_does_not_linkr ÚcoercerÍ r )rY r¤ rZ ÚattrnameÚ parent_entityr[ r÷ r\ r§ R s& þ
|
|
|
$ ÿ
|
zLoad._apply_to_parentrB r- r¨ c G sb |D ]X}z| | ¡ W q tk
|
rZ } z&t|tsHt 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§ ÚAttributeErrorrR rB Úsa_excÚ ArgumentError)rY rP rß Zaer[ r[ r\ rª s s
|
|
ÿýz Load.optionsTr« r r¬ r r rh r® c C s2 |r
|
d| _ | jjr t d¡n>t| jr\|rF| jj | jj|d ¡ nt d| jj d¡|d krtj | jd ||||||d}|r| j
|
|f7 _
|
n|D ]} t | t rÆt j | j| ||||||d}n tj | j| ||||||d}|r|tkrö|j| _| j
|
|f7 _
|
|j dd¡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 rs F)rC r½ Úis_tokenrÿ r r ÚpropZ_strategy_lookupÚ_ClassStrategyLoadÚcreaterÍ rR rS Ú_TokenStrategyLoadÚ_AttributeStrategyLoadr/ Ú
|
local_optsÚgetÚ_recurse) rY ra r} r¯ rP r rC r Ú load_elementrF Zr1r[ r[ r\ r sn ÿ
|
ÿø
|
|
ø ø z Load._clone_for_bind_strategyc C s | ¡ }| j ¡ |d< |S ©Nr½ ©Ú_shallow_to_dictr½ Ú serialize©rY Údr[ r[ r\ Ú __getstate__÷ s zLoad.__getstate__c C s t |d ¡|d< | |¡ d S r ©r Ú deserializeÚ_shallow_from_dict©rY Ústater[ r[ r\ Ú __setstate__ü s zLoad.__setstate__)NNTN) 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¢ ½ s:
|
|
þ
|
ú2!0 ø Xr¢ c @ sÒ e Zd ZU dZdZdejjfdejjfdejjfgZ dZ
|
de d< d e d< d
|
e d< d e d< d Z d dddZ d,ddZdddddZdd ddd Zd d Zd d d!d"d#d$d%Zd&dd'd(Zd&d d)d*d+ZdS )-Ú _WildcardLoadz)represent a standalone '*' load operation)r} r½ r r} r½ r Nr@ Úcache_key_traversalzOptional[Tuple[Any, ...]]r¡ z Union[Tuple[()], Tuple[str]]Fr rÓ c C s d| _ d | _tj| _d S )Nr[ )r½ r} r rk r rÖ r[ r[ r\ rÒ s z_WildcardLoad.__init__Tc C sb |d k s t |d }|r.t|tr.|ttfks2t | d| }|| _|f| _|r^t |¡| _ d S )Nr rÀ )
|
rW rR rS r r r} r½ r Ú immutabledictr ) rY ra r} r¯ rP r rC r rF r[ r[ r\ r s
|
ÿþ
|
ýz&_WildcardLoad._clone_for_bind_strategyrB r- r¨ c G s t dd S )Nz(Star option does not support sub-optionsr¥ r© r[ r[ r\ rª 3 s z_WildcardLoad.optionsr¢ r£ c C s | j s
|
t| j d }| t¡r6| d¡d dt }tt|j |¡}|j sRtt
|
|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½ rW rÄ r Úsplitr r r Útokenr r r r} r rC rÍ )rY r¤ rF Úeffective_pathrl r[ r[ r\ r§ 6 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 st|
|
|| |¡}
|
|
|
sd S |
|
} t| t sªtt 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>Y s z*_WildcardLoad._process.<locals>.<listcomp>r r )r» )r³ r¸ rC r¶ r½ rÆ rW rù rR rS Ú_find_entity_basestringr r rÐ r} r r r¹ ) rY r± r² r» Ú
|
is_refreshr r¶ Ú
|
start_pathÚnew_pathr# rÏ Z path_elementrl r[ r[ r\ rµ S sN
|
ù ÿz_WildcardLoad._processz"Iterable[_InternalEntityType[Any]]rS rD z"Optional[_InternalEntityType[Any]])r r# r» rI c C s | dt ¡r^tt|dkrl|rlt dd dd |D ¡ dd dd |D ¡ d ¡n| t¡rld
|
}|D ]
|
}| S |rt 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 )rS r% 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 | dV qdS )rÔ z).some_option('*')Nr[ r% r[ r[ r\ r s ÿÚ.FzFQuery has only expression-based entities - can't find property named "ú".)rÄ r rù Úlistrÿ r Újoinr )rY r r# r» ró r[ r[ r\ r' 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 rI c C s | |¡ d S r )r r r[ r[ r\ r º s z_WildcardLoad.__setstate__)NNTN)rÇ rÈ rÉ r rÊ r) r Ú dp_plain_objÚdp_string_multi_dictr r rË rC rÒ r rª r§ rµ r' r r r[ r[ r[ r\ r s2
|
|
|
þý
|
ø
|
=&r 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< ddddZdd ZeddddZdd d d d Zdd d d d Zd!dd"d#Zd!d$d%d&d'Zd(d) Zddd*d+d,d-Zd.d/ Zd0d1 Zd2d3 Z e dGdd5d d6d7ddd8d d d9
|
d:d;Z d$dd<d=Z d dd>d?Z d@d dAdBdCZ!e"d d d dDdEdFZ#d
|
S )HrÞ 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} rC r rä rQ r r½ r} r rä rC rQ NzTuple[Any, ...]rh r r rD z util.immutabledict[str, Any]Úis_token_strategyÚis_class_strategyÚintrÓ c C s t | S r )r rÖ r[ r[ r\ Ú__hash__ï s z_LoadElement.__hash__c C s t | |¡S r )r( Úcompare)rY Úotherr[ r[ r\ Ú__eq__ò s z_LoadElement.__eq__c C s t | jo| jd kS r )rD r r} rÖ r[ r[ r\ Ú is_opts_onlyõ s z_LoadElement.is_opts_onlyr )ÚkwrI c K s | j }| |¡}| |¡ |S r )Ú __class__rØ Z_shallow_copy_to)rY r< r Úsr[ r[ r\ rê ù s
|
|
z_LoadElement._clonec K s | ¡ }|j |¡|_|S r )rê r Úunion)rY r< Únewr[ r[ r\ Ú _update_opts s z_LoadElement._update_optsr0 c C s | ¡ }| j ¡ |d< |S r r r r[ r[ r\ r s z_LoadElement.__getstate__r r1 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ï rS )r Úxr[ r[ r\ r ! 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/ )rY Ú parent_loaderr² r½ Zfound_entitiesró rò r[ r[ r\ Ú_raise_for_no_match s$ ÿ
|
ÿÿÿz _LoadElement._raise_for_no_matchúOptional[PathRegistry])r$ r¶ rI 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û )rY r$ 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¥ ©rY r½ rF r¯ r r» r[ r[ r\ Ú
|
_init_pathQ s z_LoadElement._init_pathc C s
|
t dS )zimplemented by subclasses.Nr¥ )rY rC 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)rI Ú
|
attributesrÞ Ú
|
_reconcile)rY rC r± r² rõ r» Úkeysr| r[ r[ r\ r¹ f s û
|
ÿ z"_LoadElement.process_compile_stateTzOptional[_AttrType]r¬ r r )
|
r½ rF r} r¯ r rC r» r r rI c
|
C s | | ¡}
|
||
|
_||
|
_||
|
_|r*t |¡ntj|
|
_d|
|
_| dk rH| |
|
_ n|dkr\|s\d|
|
_ nd|
|
_ |
|
|
|||||¡}|s|dS |
|
j |j kst ||
|
_|
|
S )z+Create a new :class:`._LoadElement` object.r[ NT)rØ r½ r} rC r r! rk r rä rQ rH r4 r rW ) r r½ rF r} r¯ r rC r» r r rß r[ r[ r\ r s$
|
ÿ 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½ )rY rZ r[ r[ r\ r
|
s $z_LoadElement._recursezUnion[Load, _LoadElement]r£ c C s¨ | ¡ }|j| jkst|j| jks(t|j| jks8tt td|jd td|jd ¡st
|
d|jd d|jd d¡t |jdd
|jdd
¡|_|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.
|
|
rî r¿ r z Attribute "r z " does not link from element "r- N) rê r} rW r r5 rð rø r r½ rÿ r r rû )rY r¤ rZ r[ r[ r\ rö ³ s þ ÿ$z _LoadElement._prepend_path_from)Ú replacementÚexistingrI 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) rQ r} r r; rê r? rä r½ r rÿ ZInvalidRequestError)rN rO r[ r[ r\ rK Ñ sD
|
|
|
ÿ
|
þÿÿ ÿz_LoadElement._reconcile)TNN)$rÇ rÈ rÉ r rÊ Ú__visit_name__r) r r r2 r3 r Zdp_clauseelement_listr r rË r7 r: Úpropertyr; rê rA r r rD rF rH rI r¹ rÌ r rÒ r
|
rö Ú staticmethodrK r[ r[ r[ r\ rÞ ¾ sX
|
|
|
þ
|
|
|
÷ &
|
ö$( rÞ c s e Zd ZU dZdZdZejdej j
|
fdej j fg Zde d< de d< dZ dZd d
|
Zd d Zd d Zdd Z fddZ fddZ 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)
|
|
)rM Ú_path_with_polymorphic_pathZ attribute_strategy_load_elementrM rS z*Union[Mapper[Any], AliasedInsp[Any], None]rE Fc C sú |d k s t d | _d | _t|\}}}|jrH|}|| }|jrD|j}|S |jsVdsVt t |d |j
|
¡s |r|r||d k rt d¡q t |t||j
|
nd S |j| _t|dd râ|j} t| }
|
|
|
| _|j| | _|| |
|
}n|| }|jrö|j}|S )NFr¿ r zCan't apply wildcard ('*') or load_only() loader option to multiple entities in the same option. Use separate options per entity.rM )rW rM rS Ú_parse_attr_argumentZ is_propertyÚ
|
has_entityZ entity_pathZ is_attributerð rø r¤ rÿ r rú rS rä rV r# ) rY r½ rF r¯ r r» rÑ Ú_r ÚacZext_infor[ r[ r\ rH ( sD ÿÿ
|
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ä rW r± rí ræ rå rà r$ )rY rÍ rè Z current_queryZk1Zk2r[ r[ r\ Ú_generate_extra_criteriai 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) rS rW rM Úis_aliased_classr# rð r Z_with_polymorphic_factoryÚmapperZ base_mapperrF rà Z _merge_with)
|
rY 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 st| ||¡}|d kr g S dtt|jfgS ©Nrl )r¶ r³ r¸ r½ r rW rC rM r\ rJ r} r rD rU r¤ rF r r rà ) rY rC r± r² rõ r» r¶ r( r$ r[ r[ r\ rI ± 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ä rS rM Fz unexpected object for _of_type) Úsuperr rS r rM rZ Z is_mapperÚclass_rW r ©r= r[ r\ r Ý s
|
þÿ
|
z#_AttributeStrategyLoad.__getstate__c sV t |¡ | dd ¡r*t |d ¡| _nd | _| dd ¡rLt|d | _nd | _d S )NrS rM )r^ r r r r rS r# rM r r` r[ r\ r õ s ÿ z#_AttributeStrategyLoad.__setstate__)rÇ rÈ rÉ r rÊ rP rÞ r r) r Zdp_multir rË r5 r4 rH rX r\ rI r r Ú __classcell__r[ r[ r` r\ r s&
|
|
|
þþA%#, 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 r# rÿ r )rY r½ rF r¯ r r» Z default_tokenr[ r[ r\ rH 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 |j fqS )rl )rà )r Ú_pathr[ r[ r\ r& R s ÿzA_TokenStrategyLoad._prepare_for_compile_state.<locals>.<listcomp>)r¶ r³ r¸ r½ r rW rC r} r r rû rF r r Zgenerate_for_superclasses©
|
rY rC r± r² rõ r» r¶ r( r$ Znew_effective_pathr[ r[ r\ rI ) s4
|
|
ÿ ÿ ÿþz-_TokenStrategyLoad._prepare_for_compile_stateN)
|
rÇ rÈ rÉ r rP Ú inherit_cacher5 r4 rH rI r[ r[ r[ r\ r 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[ rG r[ r[ r\ rH l s z _ClassStrategyLoad._init_pathc
|
C s^ |j }|jj}|r | js g S | js,| js,g S | j}|rR| ||¡} | d krNg S | }d|jfgS r] ) r¶ r³ r¸ rC r} r r½ rF rà rd r[ r[ r\ rI o s
|
|
ÿz-_ClassStrategyLoad._prepare_for_compile_stateN)
|
rÇ rÈ rÉ r re r5 r4 rP rH rI r[ r[ r[ r\ r Z s r z Callable[..., _AbstractLoad]r rD r )ÚmethrL Úchainedr< rI c
|
C s d }d|dd
fd|dd
ffD ]Ü\}}|D ]Î}t |tr¦| dt ¡rftjddd |d d
}|tkr|r|t d
|
¡|d krt }| |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.rJ rK r r rb rH )rR rS Ú
|
startswithr r rU rÿ r r r rT r¢ r{ rW )
|
rf rL rg r< Ú lead_elementZ
|
is_defaultÚ_keysrF rV Ú lead_entityr[ r[ r\ Ú_generate_from_keys sL (
|
ö ÿÿ ÿÿÿ
|
rl rE zDTuple[InspectionAttr, _InternalEntityType[Any], MapperProperty[Any]]rn 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 )rF rÑ Úerrrk r r[ r[ r\ rT Ð s$ ÿþÿrT )ÚfnrI c C s4 t t| j}|j}d| j d| j d|_|| _| S )zdecorator 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.
|
|
)rV rB rÇ r )rn Zbound_fnZfn_docr[ r[ r\ Úloader_unbound_fnõ s ÿÿ
|
ro )rL r< rI c O s t tj| d|S )NT)rl r¢ r] ©rL r< r[ r[ r\ r] s r] Fr^ r` c G s& t |d \}}}t|j|d| iS )Nr r_ )rT r¢ rg )r_ ra rV ri r[ r[ r\ rg s rg c O s t tj| d|S ©NF)rl r¢ rm rp r[ r[ r\ rm s rm )rL rI c G s t tj| di S rq )rl r¢ rq ©rL r[ r[ r\ rq s rq )rs rr )rL rs rI c G s t tj|dd| iS ©NFrs )rl r¢ rt ©rs rL r[ r[ r\ rt " s ÿrt c G s t tj| di S rq )rl r¢ rv rr r[ r[ r\ rv + s rv c G s t tj|dd| iS rs )rl r¢ rw rt r[ r[ r\ rw 0 s ÿrw c G s t tj| di S rq )rl r¢ rx rr r[ r[ r\ rx 9 s rx c O s t tj| d|S rq )rl r¢ r_ rp r[ r[ r\ r_ > s r_ c G s t tj| di S rq )rl r¢ r{ rr r[ r[ r\ r{ C s r{ )r| Ú
|
addl_attrsr_ rI 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.3rK r_ F)r rU rl r¢ r~ )r| r_ ru r< r[ r[ r\ r~ H s ü
|
r~ )r| ru rI 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.rv rK F)r rU rl r¢ r )r| ru r[ r[ r\ r \ s ür rS r c C s t }| | ¡S r )r r )r Úelementr[ r[ r\ r h s r r r c C s t tj| fdd|iS )NFr
)rl r¢ r )r| r
r[ r[ r\ r n s ÿr rÎ r )Úbase_clsr rI c C s t | }| |¡S r )r¢ r )rx r Úulr[ r[ r\ r w s r c C sÎ t | dkr®| d j| d jjk }t|r4t|}n|jj}t d| d| d d|rhd| d dnd |s¢| d j s¢t
|
| jt |j¡r¢d
|
| d d| d nd f ¡n t d | d | d d¡d S )Nr r¿ rM 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)"?zORM mapped attribute "z " does not link mapped class "ú") rù rÏ r[ r_ r rS rÇ rÿ r rZ rð rñ r# )r½ rü rý Zpath_is_of_typeZparent_entity_strr[ r[ r\ rú s0
|
ýü ÿûõþÿÿrú )rr Ú
|
__future__r Útypingr r r r r r r r
|
r r r r rz r rð Ú_typingr r r r rJ r Úbaser Z
|
interfacesr Z path_registryr r r r r r r r r! rÿ r# Zsqlr$ r% r& r' r( r) Zsql.baser* Z util.typingr+ r, r- r/ rË r1 r2 Ú TYPE_CHECKINGr4 r5 rÍ r6 r7 r8 r9 r: r; r[ r< r= Z sql._typingr> r? Z sql.cache_keyr@ rA rS rE Z_WildcardKeyTyper r¡ Z_AttrGroupTypeZGenerativeOnTraversalrB r¢ r Z HasCacheKeyZHasShallowCopyZ TraversiblerÞ r r r rl rT ro r] rg rm rq rt rv rw rx r_ r{ r~ r r r r rú r[ r[ r[ r\ Ú<module> sü k F >
|
ÿ O {U6@%ÿÿÿ
|
