p})|e d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ddlm
Z
ddl m Z dd l m
Z
dd
l mZ dd lmZ dd lmZ dd
lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ddlm Z G d de e Z G d de Z G d de Z! e! d@d Z"e"j# d Z" e! d Z$e$j# d Z$ e! d@d! Z%e%j# d" Z%e%j& d# Z' e! d$ Z(e(j# d% Z(e(j& d& Z) e! d' Z*e*j# d( Z*e*j& d) Z+ e! d* Z,e,j# d+ Z,e,j& d, Z- e! d- Z.e.j# d. Z. e! d/ Z/e/j# d0 Z/ e! dAd2 Z0e0j# d3 Z0 e! d4 Z1e1j# d5 Z1 e! d6 Z2e2j# d7 Z2 e! d8 Z3e3j# d9 Z3 e! d: Z4e4j# d; Z4 e! d< Z5e5j# d= Z5 e! d> Z6e6j# d? Z6d S )Bz
)util)QueryableAttribute)_class_to_mapper)_is_aliased_class)_is_mapped_class)InspectionAttr) MapperOption)MapperProperty)PropComparator)_DEFAULT_TOKEN)_WILDCARD_TOKEN) PathRegistry)
TokenRegistry)_orm_full_deannotate )excinspect)
expression) _generative)
Generativec $ e Zd ZdZd Zed Zd Z fdZdZ dZ
dZ dZ dZ
d Zd Zd
Z dd Zd
Zd Zd Zed Ze dd Zed d Zed Zed Z d dZd dZ d Z d Z d Z d Z xZ!S ) Loada Represents loader options which modify the state of a
: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:`.defer`, or similar. However, the :class:`_orm.Load` object
can also be used directly, and in some cases can be useful.
To use :class:`_orm.Load` directly, instantiate it with the target mapped
class as the argument. This style of usage is
useful when dealing with a :class:`_query.Query`
that has multiple entities::
myopt = Load(MyClass).joinedload("widgets")
The above ``myopt`` can now be used with :meth:`_query.Query.options`,
where it
will only take effect for the ``MyClass`` entity::
session.query(MyClass, MyOtherClass).options(myopt)
One case where :class:`_orm.Load`
is useful as public API is when specifying
"wildcard" options that only take effect for a certain class::
session.query(Order).options(Load(Order).lazyload('*'))
Above, all relationships on ``Order`` will be lazy-loaded, but other
attributes on those descendant objects will load using their normal
loader strategy.
.. seealso::
:ref:`deferred_options`
:ref:`deferred_loading_w_multiple`
:ref:`relationship_loader_options`
c t | }|j | _ t j | _ i | _ d| _ d S NF)r _path_registrypathr OrderedDictcontext
local_optsis_class_strategy)selfentityinsps s/builddir/build/BUILD/cloudlinux-venv-1.0.10/venv/lib64/python3.11/site-packages/sqlalchemy/orm/strategy_options.py__init__z
Load.__init__L s> v' ')) !& c h | | }||_ i |_ i |_ d |_ |S N)__new__r r r _of_type)clsr loads r% for_existing_pathzLoad.for_existing_pathU s4 {{3
r' c
|j d j rdS g }| j D ]\ \ }} |dk rt | j j | D ] \ }}||ur na
j p j j d }| || }| |s j ssg } |D ]}
t |
t j r|
|
2|
j r dS |
j r|
|
j _|
j
sJ |
|
j | r || d k r,|j
r|
|j n
|j r dS |
t | j pdz j r-t fdt% j D ndz |sd S t | S )N Floader c . g | ]}|j | fS r3 )r ).0keyobjs r%
z,Load._generate_cache_key.. s5 !" !" !"(+ &)#.*=$>!" !" !"r' )r is_aliased_classr itemszipr+
_chop_path
isinstancer string_typesappend is_propertyr6 is_mapperclass_tuplestrategyr sorted) r" r
serializedr6 loader_path
local_elemobj_elemendpointchoppedserialized_pathtokenr7 s @r% _generate_cache_keyzLoad._generate_cache_key^ sl 9Q< ( 5
'+|'9'9';'; ; ; # S+h(+DINK(H(H 7
7
$
H X--E . <<38=+< //+t<<
L "$ $ = =E!%):;; ='..u5555 / = $uuu * ='..uy9999 $..'..u|<<<<& %(ob6I*I*I ) %'..x????!2 % $uu!! o.. <-2/ #~
$E!" !" !" !"/5cn/E/E!" !" !" "$ %4$$ $r' c d t t | }i |_ |S r) )superr _generater )r" cloned __class__s r% rQ zLoad._generate s+ tT"",,..
r' FNc 2 | |d d S NT_processr" querys r%
process_queryzLoad.process_query s
eT"""""r' c 2 | |d d S r rV rX s r% process_query_conditionallyz Load.process_query_conditionally s
eU#####r' c |j }|rH| j D ],\ \ }}}| || }| ||j ||f< -d S |j | j d S r) )
_current_pathr r: r< _attributesupdate)r" rY raiseerr current_pathrM
start_pathr1 chopped_start_paths r% rW z
Load._process s * 3/3|/A/A/C/C
L
L+#
V%)__Z %N%N"%1EKE%u.@&AB
L
L
$ $T\ 2 2 2 2 2r' Tc
| j }d | _ |rM|j sFt |t rt j d t j d|j d t |t j r~| t }|}| t s|rF|rd| _ |r|d|}|r|j
s
|j | }| | }|| _ |S |rt# | } n|j } t' | j | } |j x}}
n# t, $ r`} t |t. s@t j t j d|d| dt3 | d |
n Y d } ~ nWd } ~ ww xY w# t, $ rB} |r0t j t j d |d| d |
nY d } ~ d S Y d } ~ nd } ~ ww xY w|| }nt5 | rFt7 j |j |d
s$|r t j d|d|j d d S nv|j x}
}
t7 j |j |d
sj|rft j d|d|j dt; | dk r1|j j r%|j j
rd|d d|j j dnd d S t' |dd r|j }t# | x}}|j |
! | j" d }|j
sHt7 j# |j$ j% |j$ d d |t# | nd }t# | }|j |
& | j" d| ||
| }|| _ n||
}||
' | |j r|j }|| _ |S ) Nz3Wildcard token cannot be followed by another entityzMapped attribute 'z#' does not refer to a mapped entityF:zExpected attribute "z" on z' to be a mapped attribute; instead got z object.)replace_contextzCan't find property named "z in this Query.r2 z Attribute 'z ' does not link from element ''z Attribute "z " does not link from element "".r z Did you mean to use z .of_type(z)? r+ path_with_polymorphicT)aliased_use_mapper_path_existing_alias)(r+
has_entityr= r sa_exc
ArgumentErrorpropr r> endswithr r
propagate_to_loadersr9 parentrM r r r# getattrrB propertyAttributeErrorr
raise_typer orm_util$_entity_corresponds_to_use_path_impllenrA __name__ entity_pathgetr with_polymorphicmapper base_mapperset
_get_strategy)r" r attr for_strategy wildcard_keyra existing_of_type
default_token
attr_str_nameentfound_propertyaeerrrs acext_info of_type_infoexistings r% _generate_pathzLoad._generate_path s0 =
DO $
..
*I **26)))>
dD - . . @ " MM. 9 9M M}}_--
605D- :&2llDD9D $ 9,<,M 9 ;'78Dzz$''
" .//k
sz400 ,0M9D>>% %dN;; " 0 0 $1==###tDzzzz!C -/ "
K ,,3744 > ), 44444
8 :DD
d
#
# G " @ T"X
..48DD$+++G
4
%)M 1D>@ T"X
.. !DD KKK
$'t99q==$(K$9 $1$(K$@ $1= $(888T[-A-A-A!C !C &(
!(
$ 4tZ..
"]*1"++5< +D155L"9 0 +!2 3 $)-#/ )0(9(9(9 ! B 'r{{H &**L"92 Dz(+ ,
Dz # ( ( 6 6 6 ? $#D s1 F ' D1 1
F;AFF
G*(2G%%G*c d| j dS )NzLoad(strategy=))rD r" s r% __str__z Load.__str__X s &*mmm55r' c f |.t t | }|S r) )rC rE r: )r" rD s r%
_coerce_stratzLoad._coerce_strat[ s, VHNN$4$4 5 566Hr' c t d )NzHOnly 'unbound' loader options may be used with the Load.options() method)NotImplementedError)r" rv appliedbounds r% _apply_to_parentzLoad._apply_to_parent` s !
$
r' c i }t | t }|rt d |D ]}| | || dS )a 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("summary", "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:`relationship_loader_options`
:ref:`deferred_loading_w_multiple`
zMThe options() method is currently only supported for 'unbound' loader optionsN)r= _UnboundLoadr r )r" opts apply_cacher opts r% optionsz Load.optionsf sq B t\222 %/
; ;C {E : : : : ; ;r' c | | }|| _ | ||d }|j | _ |j | _ dx|_ | _ |j | _ d S )N relationshipF)r ru _clone_for_bind_strategyr r+ r! )r" r rD ru rR s r% set_relationship_strategyz Load.set_relationship_strategy si %%h//$8!..tX~NNK
' !Y -NN !YN " &@@BB
""L # 0 #
,
r' c | j }|d t j |d d |d< | j |d< |S )Nr )r1 r )__dict__copyr serialize_context_dictr serializer" ds r% __getstate__zLoad.__getstate__ s\ M Y< #'>) k AiL I''))& r' c | j | t j | j | _ | j t j | j | _ d S d S r) )r r` r deserializer r deserialize_context_dict)r" states r% __setstate__zLoad.__setstate__ sT
U### ,TY77 < #'@ NNDLLL $ #r' c d}t t ||j D ]\ }\ }}t |t j rC|dk r!| dt z r|c S |dt k r||j k r d S ||u rjt |t r$|j r |j r| | r d S ||dz d S Nr2 r0 rf z
relationship:r )
enumerater; r r= r r> rt r r
r6 r rA isa)r" to_chopr ic_tokenp_tokens r% r< zLoad._chop_path s %.s7DI/F/F%G%G !A!'4#455
66g . .s^/C D D6"NNNGOO EEE 7;.. 44'!!7N33
%
%
KK((
ttq1uww r' )Tr )FN)TF)"r
__module__ __qualname____doc__r& classmethodr. rN rQ r r! rD ru r+ rZ r\ rW r r r r r r r r r r r r r r r r<
__classcell__)rS s @r% r r ! s ( (T' ' ' [D% D% D%L
L H H# # #$ $ $3 3 3 @DW W W Wr6 6 6
(; (; [(;T 37
@
@
@ [
@ / / / [/ / / [/ ' ' [' CG .
<
<
<
< 4 O O O r' r c ~ e Zd ZdZd ZdZd Zd ZddZd Z d Z
d
Z d Z e
d Zd
ZddZd Zd Zd ZdS )r a< Represent a loader option that isn't tied to a root entity.
The loader option will produce an entity-linked :class:`_orm.Load`
object when it is passed :meth:`_query.Query.options`.
This provides compatibility with the traditional system
of freestanding options, e.g. ``joinedload('x.y.z')``.
c 0 d| _ g | _ i | _ d S )Nr3 )r _to_bindr r s r% r& z_UnboundLoad.__init__1 s
r' Fc d}| j D ]q}t | j |j D ] \ }}||ur nJ | |j d gd d d }|r#| | }|du r dS |r||z
}r|sd S |S )Nr3 r0 F)r r; r _bind_loaderrN )r" r rF valrH val_elemr c_keys r% rN z _UnboundLoad._generate_cache_key8 s
= , ,C(+DIsx(@(@
,
,$
H X--E . && ! ~tT5II , 3 3D 9 9E ~~ $uu ,"e+
4 r' c H | j | d | _ d S r) )r r? r s r% r z _UnboundLoad._set_path_strategyK s%
T"""
r' Nc | v r| S | j | }|| < | j |_ | j r| j d }t |t
j r@| t r&| d d dz t z }| j | j dd z || j d |j | j k sJ |j
| j
k sJ |j | j k sJ fdD }j |_ |j | |j | j |S )Nr2 rf r0 c @ h | ]}| S r3 )r )r5 elemr r rv to_binds r% z0_UnboundLoad._apply_to_parent..n s=
! !&'5' B B
r' )r rQ rD r r= r r> rt r splitr
r ru r! r extendr r` )r" rv r r r rR r new_to_binds ```` r% r z _UnboundLoad._apply_to_parentR s 7??4= ?mG !!
- 9 9R=D$ 122
Bt}} 8 8
B zz#q)C//A ! ! di"o-tT]D
*d.GGGGG'4+AAAAA"d&77777
!/ {+++ 111
r' c |rCt |t j r)|t t fv r|t k rd| _ |d|}|r&t
|d r| j s
|dd }|r||fz }|| _ |S )NFrf r2 r0 ) r= r r> r
r ru r r! r )r" r r r r s r% r z_UnboundLoad._generate_pathx s 24!233 2 .999~%%,1) *llDD1D $T"X.. t7M ":D "4'>D r' c v | j }| | j d |d< |S )NT)filter_aliased_classr )r r _serialize_pathr r s r% r z_UnboundLoad.__getstate__ s8 M (((NN& r' c b g }|d D ]}t |t r^t | dk r|\ }}d }n|\ }}}t || }|r| | }| | u| | t | |d< || _ d S )Nr r )r= rC r~ rw of_typer? r )r" r retr6 r, propkeyr rs s r% r z_UnboundLoad.__setstate__ s =
C#u%%
s88q==#&LC "GG,/)C' sG,, 1 <<00D
4
3 c
f
r' c |j d }| j D ]L}||vrF| | | d |j D |j |j | Md S )N_unbound_load_dedupesc g | ] }|j
S r3 ) entity_zeror5 r s r% r8 z)_UnboundLoad._process.. s GGGS_GGGr' )r_ r addr _mapper_entitiesr^ )r" rY ra dedupesr s r% rW z_UnboundLoad._process s #$;<= C'!! C GG0FGGG'% r' c t }d fd|D }|dd D ]+}d|_ |r |||fi |}| | }, |||d fi |}d|_ |S )Nc t | t j rO| t k rt fS | dt z r
| dd } | d S | fS )N.r )r= r r> r
r
startswithr r6 s r%
_split_keyz+_UnboundLoad._from_keys.._split_key sh #t 011
/)) *,,^^C/$9:: " abb'Cyy~~%v
r' c 0 g | ]} | D ]}|S r3 r3 )r5 r6 rM r s r% r8 z+_UnboundLoad._from_keys.. s. IIIC IIeIIIIr' r0 r2 TF)r _is_chain_link defaultload) r, methkeyschainedkwr
all_tokensrM r s @r%
_from_keysz_UnboundLoad._from_keys s nn
JIIItIII
"% - -E "&C
-d3,,,,ooe,,d3
2--"-- "
r' c d}t t || D ]\ }\ }\ }}t |t j rD|dk r!| dt z r|c S |dt k r||j k r d S it |t r;|j |us/|j |ur)|j j
r|j | s d S |dz
}||d S r )r r; pairsr= r r> rt r r
r6 r rx
_parententityrA r )r" r r r r p_entityp_props r% r< z_UnboundLoad._chop_path s# 09 & &1
1
,A,+(F '4#455
66g . .s^/C D D6"NNNGOO EEE 6:-- 44G^44
#611)99 # 1 ; : ' 4 8 8 B B : 44
FAqrr{r' c g }|D ]}t |t rw|rH|j rAt |j j r(| |j j |j d f a| |j j |j |j f t |t r(| |j j |j d f | | |S r) )
r= r r+ r r9 r?
_parentmapperrB r6 r )r" r r r rM s r% r z _UnboundLoad._serialize_path s " "E%!344
"( //@
JJ 3 :EIt LMMMMJJ ,3UYO E>22
"
E / 6 4HIIII
5!!!!
r' c | j }| j r|r ||d fz
}|r| || }|sdS |d }t |t j r| ||| }nzt |t r%|j }| |||j
| }n@| j r%t | rt | }||vrd}nt j d |sdS |} t | }
|||
_ n|
j }| j |
_ | j |
_ | j |
_ |
j } |
j sSt' | D ]C\ } }|
|
j || t+ | dz
k r| j ndd| s dS D|
j | j |
j s|
j j r
|
j j }
n|
j }
|
j r<|
D ]&} |
|| | j | j 'n$|
||
| j | j |
S )a] Convert from an _UnboundLoad() object into a Load() object.
The _UnboundLoad() uses an informal "path" and does not necessarily
refer to a lead entity as it may use string tokens. The Load()
OTOH refers to a complete path. This method reconciles from a
given Query into a Load.
Example::
query = session.query(User).options(
joinedload("orders").joinedload("items"))
The above options will be an _UnboundLoad object along the lines
of (note this is not the exact API of _UnboundLoad)::
_UnboundLoad(
_to_bind=[
_UnboundLoad(["orders"], {"lazy": "joined"}),
_UnboundLoad(["orders", "items"], {"lazy": "joined"}),
]
)
After this method, we get something more like this (again this is
not exact API)::
Load(
User,
(User, User.orders.property))
Load(
User,
(User, User.orders.property, Order, Order.items.property))
r0 Nz6mapper option expects string key or list of attributesr r ) r r! r< r= r r> _find_entity_basestringr rx _find_entity_prop_comparatorr r r rq rr r r rD r r r r~ r r` rp rv r r r r )r" entitiesrb r ra rc rM r# rs path_elementr1 r idxr s r% r z_UnboundLoad._bind_loader s H Y
! )l ) 8A;. (J
C \BBJ 4 1
eT . / / 11(E8LLFF
~
.
. >D66$ 3X FF
# (8(?(? U^^FX%% &K
F l## $FNN nG - " /#'#9 {' '
3 3
U ,,K%(C
OOa,?%?%?DMMT FF 111' )FK,B ) #[ /NN #[N " &@@BB
$$ $ 3 3 # 0 %
// ,
!
r' c t | r|}nt | }|D ]}t j || r|c S |rt | s:t j dt j t | d|d t j d|dd
d |D d d S ) Nz@Query has only expression-based entities, which do not apply to z ""zMapped attribute "zA" does not apply to any of the root entities in this query, e.g. , c 3 4 K | ]}t | V d S r) str)r5 xs r% z<_UnboundLoad._find_entity_prop_comparator.. s( *D*Da3q66*D*D*D*D*D*Dr' zV. Please specify the full path from one of the root entities to the target attribute. ) r r r| _entity_corresponds_tolistrq rr r clsname_as_plain_namer{ join)r" r rs r ra searchforr s r% r z)_UnboundLoad._find_entity_prop_comparator~ s V $ $ 1 II(00I C.sI>>
H~~ .. 5d4jjAAAA444I !.. 44*D*D8*D*D*D!D!D!D!D F tr' c | dt z rxt t | dk rW|rUt j dd d |D dd d |D d n | t rd }|D ]}|c S |rt j d
|d d S ) Nrf r zMCan't apply wildcard ('*') or load_only() loader option to multiple entities r c 3 4 K | ]}t | V d S r) r r s r% r z7_UnboundLoad._find_entity_basestring.. s( %C%C3c#hh%C%C%C%C%C%Cr' z?. Specify loader options for each entity individually, such as c 3 K | ] }d |z V
dS )zLoad(%s).some_option('*')Nr3 r s r% r z7_UnboundLoad._find_entity_basestring.. s; & & $' !>#/ 0 0 4>>""a''
.. !II%C%C(%C%C%C C C C C II & & +3& & &
^^N
+
+ H C JJJ
**:?%%B
tr' r) F)r r r r r& r rN r r r r r rW r r r< r r r r r3 r' r% r r & s
N & $ $ $ $L
&
[ > 6 (A A AF 8 r' r c & e Zd Zd Zd Zd Zd ZdS )
loader_optionc d S r) r3 r s r% r& zloader_option.__init__ s r' c |j x| _ }|| _ t t | rt d|z t
t || | S )Nz#Load class already has a %s method.)r namefnhasattrr TypeErrorsetattr)r" r- r, s r% __call__zloader_option.__call__ sU ;& D 4 L AT JKK KdB r' c f || _ | j j }dd| j iz | j _ ||_ | S )NzProduce a new :class:`_orm.Load` object with the
:func:`_orm.%(name)s` option applied.
See :func:`_orm.%(name)s` for usage examples.
r, ) _unbound_fnr- r r, )r" r- fn_docs r% _add_unbound_fnz loader_option._add_unbound_fn s?
DI
r' c dd| j iz |_ t j ddd| j iz d | }|| _ | S )Na} Produce a standalone "all" option for
:func:`_orm.%(name)s`.
.. deprecated:: 0.9
The :func:`_orm.%(name)s_all` function is deprecated, and will be removed
in a future release. Please use method chaining with
:func:`_orm.%(name)s` instead, as in::
session.query(MyClass).options(
%(name)s("someattribute").%(name)s("anotherattribute")
)
r, z0.9zThe :func:`.%(name)s_all` function is deprecated, and will be removed in a future release. Please use method chaining with :func:`.%(name)s` insteadF) add_deprecation_to_docstring)r, r r
deprecated_unbound_all_fn)r" r- s r% _add_unbound_all_fnz!loader_option._add_unbound_all_fn sr
DI
T_
(+149*=
> */
" r' N)r r r r& r1 r5 r: r3 r' r% r) r) sP
r' r) Nc |,t |t st | }|j }n,t |dd rt |j }|j }| |ddid }||j d< |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
:meth:`_query.Query.populate_existing` method 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`
Nr+ lazyjoinedF)ru eager_from_alias)r= r r
selectablerw r+ r r )loadoptr aliasinfootrR s r% contains_eagerrD s N
%%% $5>>DOE z4 ( (
T]
#
#
.
. vx u / F -2F() Mr' c ^ t t j | d| S rU )r r rD r r s r% rD rD - s* >> $ $#T4 r' c p | |ddd }| ddddddi |S )aQ 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("name", "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("addresses").load_only("email_address")
)
For a :class:`_query.Query` that has multiple entities,
the lead entity can be
specifically referred to using the :class:`_orm.Load` constructor::
session.query(User, Address).join(User.addresses).options(
Load(User).load_only("name", "fullname"),
Load(Address).load_only("email_address")
)
.. note:: This method will still load a :class:`_schema.Column` even
if the column property is defined with ``deferred=True``
for the :func:`.column_property` function.
.. versionadded:: 0.9.0
FTdeferred
instrument* undefer_pksr )r@ r rR s r% load_onlyrN 4 s\ L
(
(
E66 F $d
3
3mT5J Mr' c . t j | S r) )r rN )r s r% rN rN c s #<>> #U ++r' c N | |ddi }|
||j d< |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.
.. versionchanged:: 1.0.0 ``innerjoin=True`` now implies
``innerjoin="nested"``, whereas in 0.9 it implied
``innerjoin="unnested"``. In order to achieve the pre-1.0 "unnested"
inner join behavior, use the value ``innerjoin="unnested"``.
See :ref:`migration_3008`.
.. note::
The joins produced by :func:`_orm.joinedload` are **anonymously
aliased**. The criteria by which the join proceeds cannot be
modified, nor can the :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:`_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`
r< r= N innerjoin)r r )r@ r rQ r1 s r%
joinedloadrR h s7 p
.
.tfh5G
H
HF )2+& Mr' c P t t j | d| S r r r rR rF s r% rR rR s " "<#:D% L LLr' c P t t j | d| S rU rT rF s r% joinedload_allrV s " "<#:D$ K KKr' c 2 | |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"
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`
r< subqueryr r@ r s r% subqueryloadr[ s < , ,TFJ3G H HHr' c P t t j | di S r r r r[ r s r% r[ r[ " "<# , ,TFJ3G H HHr' c P t t j | di S r r r re r^ s r% re re r_ r' c P t t j | di S rU rg r^ s r% selectinload_allri " rb r' c 2 | |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`
r< selectrY rZ s r% lazyloadrl ' s , ,TFH3E F FFr' c P t t j | di S r r r rl r^ s r% rl rl 9 s " "<#8$r J JJr' c P t t j | di S rU rn r^ s r% lazyload_allrp > s " "<#8$b I IIr' c 6 | |ddi }|S )a Indicate that the given attribute should be loaded using
an immediate load with a per-attribute SELECT statement.
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.
.. seealso::
:ref:`loading_toplevel`
:ref:`selectin_eager_loading`
r< immediaterY )r@ r r1 s r%
immediateloadrs C s# &
.
.tfk5J
K
KF Mr' c P t t j | di S r )r r rs r^ s r% rs rs Z s " "<#=tUB O OOr' c 2 | |ddi S )a Indicate that the given relationship attribute should remain unloaded.
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; for
column-based attributes, see :func:`_orm.defer`.
.. seealso::
:ref:`loading_toplevel`
r< noloadrY rZ s r% rv rv _ s , ,TFH3E F FFr' c P t t j | di S r )r r rv r^ s r% rv rv r s " "<#6eR H HHr' Fc : | |d|rdndi S )a Indicate that the given relationship attribute should disallow lazy loads.
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.
: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 lazyload.
This function is part of the :class:`_orm.Load` interface and supports
both method-chained and standalone operation.
:func:`_orm.raiseload` applies to :func:`_orm.relationship`
attributes only.
.. versionadded:: 1.1
.. seealso::
:ref:`loading_toplevel`
:ref:`prevent_lazy_with_raiseload`
r< raise_on_sqlraiserY )r@ r sql_onlys r% raiseloadr| w s0 B , , v>~~w? r' c P t t j | d| S r )r r r| rF s r% r| r| s " "<#94 K KKr' c . | |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::
:meth:`_orm.Load.options` - allows for complex hierarchical
loader option structures with less verbosity than with individual
:func:`.defaultload` directives.
:ref:`relationship_loader_options`
:ref:`deferred_loading_w_multiple`
NrY rZ s r% r r s D , ,T4 8 88r' c P t t j | di S r )r r r r^ s r% r r s " "<#;T5" M MMr' c 6 | |fddd 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("attribute_one"),
defer("attribute_two"))
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("someattr").defer("some_column"))
A :class:`_orm.Load` object that is present on a certain path can have
:meth:`_orm.Load.defer` called multiple times,
each will operate on the same
parent entity::
session.query(MyClass).options(
defaultload("someattr").
defer("some_column").
defer("some_other_column").
defer("another_column")
)
:param key: Attribute to be deferred.
:param \*addl_attrs: This option supports the old 0.8 style
of specifying a path as a series of attributes, which is now superseded
by the method-chained style.
.. deprecated:: 0.9 The \*addl_attrs on :func:`_orm.defer` is
deprecated and will be removed in a future release. Please
use method chaining in conjunction with defaultload() to
indicate a path.
.. seealso::
:ref:`deferred`
:func:`_orm.undefer`
TrH rM r@ r6 s r% deferr s, v & & T66 r' c |rt j d t t j | f|z di S )Nz}The *addl_attrs on orm.defer is deprecated. Please use method chaining in conjunction with defaultload() to indicate a path.F)r warn_deprecatedr r r r6
addl_attrss r% r r sQ
" "SFZ / r' c 6 | |fddd S )ag 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("col1"), undefer("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('text'))
:param key: Attribute to be undeferred.
:param \*addl_attrs: This option supports the old 0.8 style
of specifying a path as a series of attributes, which is now superseded
by the method-chained style.
.. deprecated:: 0.9 The \*addl_attrs on :func:`_orm.undefer` is
deprecated and will be removed in a future release. Please
use method chaining in conjunction with defaultload() to
indicate a path.
.. seealso::
:ref:`deferred`
:func:`_orm.defer`
:func:`_orm.undefer_group`
FTrH rM r s r% undeferr s, X & & U$77 r' c |rt j d t t j | f|z di S )NzThe *addl_attrs on orm.undefer is deprecated. Please use method chaining in conjunction with defaultload() to indicate a path.F)r r r r r r s r% r r J sQ
" " sfz 15" r' c > | ddd|z did 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"))
.. versionchanged:: 0.9.0 :func:`_orm.undefer_group` is now specific to a
particular entity load path.
.. seealso::
:ref:`deferred`
:func:`_orm.defer`
:func:`_orm.undefer`
rK Nzundefer_group_%sT)r rM )r@ r, s r%
undefer_groupr W s5 > & & T&-t4 ' r' c D t | S r) )r r )r, s r% r r { s >> ' ' - --r' c ~ t j t | }| |fddid|i 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.::
sess.query(SomeClass).options(
with_expression(SomeClass.x_y_expr, SomeClass.x + SomeClass.y)
)
.. versionadded:: 1.2
:param key: Attribute to be undeferred.
:param expr: SQL expression to be applied to the attribute.
.. note:: the target attribute is populated only if the target object
is **not currently loaded** in the current :class:`_orm.Session`
unless the :meth:`_query.Query.populate_existing` method is used.
Please refer to :ref:`mapper_querytime_expression` for complete
usage details.
.. seealso::
:ref:`mapper_querytime_expression`
query_expressionTr r )sql_expr_labeledr r )r@ r6 r s r% with_expressionr sO B "#7
#C#CDDJ & & #T*,
1K ' r' c V t t j | fdd|i S )NFr )r r r )r6 r s r% r r s- " "$sfelJ5O r' c
| ddidt t d |D t i | 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`
selectinload_polymorphicTr c 3 4 K | ]}t | V d S r) r )r5 r, s r% r z'selectin_polymorphic.. s( 88 888888r' r r )r rC rE id)r@ classess r% selectin_polymorphicr sc #T* 88888bAAA
Nr' c t }d|_ t | f|_ | | |S rU )r r! r r r )base_clsr uls r% r r s> B Bx "BGG$$$
Ir' r) r' )7r rk r r|
attributesr baser r r r
interfacesr r
r
path_registryr r
r r r r rq r sqlr r sql.baser r r r objectr) rD r5 rN rR r: rV r[ ra re ri rl rp rs rv r| r r r r r r r3 r' r% r s * * * * * * " " " " " " # # # # # # " " " " " " $ $ $ $ $ $ & & & & & & & & & & & & ) ) ) ) ) ) * * * * * * ' ' ' ' ' ' ( ( ( ( ( ( & & & & & & ( ( ( ( ( ( " " " " " " ! ! ! ! ! !B B B B B :| B B B JT T T T T 4 T T T n 6 6 6 6 6F 6 6 6r 3 3 3 3l + + +\ , , , Z Z Z Zz M M M L L L I I I@ O O O !N N "!N I I IB O O O !N N "!N G G G"
K K K
J J J , P P P G G G$ I I I " " " "J L L L !9 !9 !9H
N N N < < <~ - - -` F . . . $ $ $N ! 4 % &% r'