/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm
Edit: /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyc (52730B)
4]c @ s d Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m
Z
d d l m Z d d l m
Z
d d
l m Z d d l m Z d d l m Z d d
l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d e e f d YZ d e f d YZ d e f d YZ e e! d Z" e" j# d Z" e d Z$ e$ j# d Z$ e 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, j& d* Z- e d+ Z. e. j# d, Z. e d- Z/ e/ j# d. Z/ e e0 d/ Z1 e1 j# d0 Z1 e d1 Z2 e2 j# d2 Z2 e d3 Z3 e3 j# d4 Z3 e d5 Z4 e4 j# d6 Z4 e d7 Z5 e5 j# d8 Z5 e d9 Z6 e6 j# d: Z6 e d; Z7 e7 j# d< Z7 d= S(> s
i ( t util( t QueryableAttribute( t _class_to_mapper( t _is_aliased_class( t _is_mapped_class( t InspectionAttr( t MapperOption( t PropComparator( t _DEFAULT_TOKEN( t _WILDCARD_TOKEN( t PathRegistry( t
TokenRegistry( t _orm_full_deannotatei ( t exc( t inspect( t
expression( t _generative( t
Generativet Loadc B s e Z d Z d Z e d Z d Z d Z e Z e Z
d Z e Z
d Z d Z d Z e d Z d Z d
Z d Z e d Z e e d
Z e d e d Z e d Z e d Z e e d Z d Z d Z d Z d Z RS( sq Represents loader options which modify the state of a
:class:`.Query` in order to affect how various mapped attributes are
loaded.
The :class:`.Load` object is in most cases used implicitly behind the
scenes when one makes use of a query option like :func:`.joinedload`,
:func:`.defer`, or similar. However, the :class:`.Load` object
can also be used directly, and in some cases can be useful.
To use :class:`.Load` directly, instantiate it with the target mapped
class as the argument. This style of usage is
useful when dealing with a :class:`.Query` that has multiple entities::
myopt = Load(MyClass).joinedload("widgets")
The above ``myopt`` can now be used with :meth:`.Query.options`, where it
will only take effect for the ``MyClass`` entity::
session.query(MyClass, MyOtherClass).options(myopt)
One case where :class:`.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 C sF t | } | j | _ t j | _ i | _ d | _ t | _
d S( N( R t _path_registryt pathR t OrderedDictt contextt
local_optst Nonet _of_typet Falset is_class_strategy( t selft entityt insp( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt __init__H s c C s7 | j | } | | _ i | _ i | _ d | _ | S( N( t __new__R R R R R ( t clsR t load( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt for_existing_pathR s c C s | j d j r t Sg } x| j j D]\ \ } } } | d k rN q* n xt | j j | D] \ } } | | k rd Pqd qd W| j p | j j d } | j | | } | d k s* | r | j r q* n g }
xx | D]p } t | t
j r|
j | q | j rt S| j
r0|
j | j q | j s?t |
j | j q W|
sj| |
d k r| j r|
j | j q| j rt Sn | j t |
| j pd | j rt g t | j D] } | | j | f ^ q n d q* W| sd St | Sd S( Ni t loaderi( ( ( R t is_aliased_classR R t itemst zipR t
_chop_pathR t
isinstanceR t string_typest appendt is_propertyt keyt is_mappert AssertionErrort class_t tuplet strategyR t sorted( R R t
serializedR- t loader_patht objt
local_elemt obj_elemt endpointt choppedt serialized_patht token( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt _generate_cache_key[ sL " "
> c C s" t t | j } i | _ | S( N( t superR t _generateR ( R t cloned( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR? s c C s | j | t d S( N( t _processt True( R t query( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt
process_query s c C s | j | t d S( N( RA R ( R RC ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt process_query_conditionally s c C s | j } | rl xm | j j D]F \ \ } } } | j | | } | d k r | | j | | f
| rt j d | | j f qd Sq>nf| j }
} t j | j | d sq| rjt j d | | j t | d k rZ| j j rZ| j j rZd | d
| j j f n d f qqd Sn t | d d r4| j } t | } }
| j |
j | j! d
} | j st j" | j# j$ | j# d t% d t% d | } t | } n | j |
j& | j! d
| | |
| } |
| _ n
| |
} | d k rZ| j' | n | j ro| j } n | | _ | S( Ns3 Wildcard token cannot be followed by another entitys7 Mapped attribute '%s' does not refer to a mapped entitys %s:%ss3 Can't find property named "%s" on %s in this Query.is. Attribute '%s' does not link from element '%s's1 Attribute "%s" does not link from element "%s".%si s% Did you mean to use %s.of_type(%s)?it R t path_with_polymorphict aliasedt _use_mapper_patht _existing_alias(( R R t
has_entityR) R t sa_exct
ArgumentErrort propR R* t endswithR R R t propagate_to_loadersR% t parentR< R R R t getattrR0 t AttributeErrort propertyR t orm_utilt$ _entity_corresponds_to_use_path_implt lenR. t __name__t entity_patht getR t with_polymorphict mappert base_mapperRB t sett
_get_strategy( R R t attrt for_strategyt wildcard_keyRI t existing_of_typet
default_tokent entt found_propertyRU t act ext_infot of_type_infot existing( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt _generate_path s
&
c C s d | j f S( Ns Load(strategy=%r)( R2 ( R ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt __str__> s c C s+ | d k r' t t | j } n | S( N( R R1 R3 R& ( R R2 ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt
_coerce_stratA s c C s t d d S( NsH Only 'unbound' loader options may be used with the Load.options() method( t NotImplementedError( R RX t appliedt bound( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt _apply_to_parentF s c G sS i } t | t } | r+ t d n x! | D] } | j | | | q2 Wd S( sm Apply a series of options as sub-options to this :class:`.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:`.Load` objects) which should be applied to the path
specified by this :class:`.Load` object.
.. versionadded:: 1.3.6
.. seealso::
:func:`.defaultload`
:ref:`relationship_loader_options`
:ref:`deferred_loading_w_multiple`
sM The options() method is currently only supported for 'unbound' loader optionsN( R) t _UnboundLoadRu Rx ( R t optst apply_cacheRw t opt( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt optionsL s
c C s` | j | } t | _ | | _ | j | j | | d | | _ | d k r\ | j n d S( Nt relationship( Rt R R RW Rr R R2 R t _set_path_strategy( R Rg R2 RW ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt set_relationship_strategyv s c C s | j | } t | _ xz | D]r } | j } | | _ | j | j | | d t | _ | ru | j j
| n | r t | _ n | j q Wt | _ d S( Nt column(
Rt R R R? R2 Rr R RB RW R RH t is_opts_onlyR ( R t attrsR2 Rz t opts_onlyRg R@ ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt set_column_strategy s
c C sp | j | } xZ | D]R } | j | j | | d } | j } | | _ | | _ t | _ | j q Wd S( N( Rt Rr R R R? R2 RB RW R ( R R R2 Rg R R@ ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt set_generic_strategy s
c C sx | j | } | j } t | _ | j | j d | d } | | _ | | _ t | _ | j | j
j | d S( N( Rt R? RB R Rr R R R2 RW R R RH ( R R2 Rz R@ R ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt set_class_strategy s
c C s | s
| r] | j | j d } | rG | rZ | j j | j qZ q | j | d | nM | j | j d } | j | d | | r | j r | j j | j n d S( NR$ ( Ra R R RH Re R ( R R R t replacet
merge_optsRq ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt
_set_for_path s
c C s | j r% | j j r% | j j } n | j } | j rs x[ | j D]( } | j | j | d t d | j qD Wn" | j | j | d t d | j d S( NR R (
R R RR RX t is_tokent generate_for_superclassesR R RB R ( R t effective_pathR ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR s c C s& | j j } | j j | d <| S( NR ( t __dict__t copyR t serialize( R t d( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt __getstate__ s c C s) | j j | t j | j | _ d S( N( R RH R
t deserializeR ( R t state( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt __setstate__ s c C s d } x t t | | j D] \ } \ } } t | t j r | d k rf | j d t rf | S| d t f k r | | j k r d Sn | | k r q q t | t r | j r | j r | j
| r q q d Sq W| | d S( Nii t :s relationship:%si ( t enumerateR' R R) R R* RV R R R- R R R. t isa( R t to_chopR t it c_tokent p_token( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR( s" + N(! R_ t
__module__t __doc__R t classmethodR# R= R? R R R R R2 RW RD RE RA RB Rr Rs Rt Rx R R} R R R R R R R R R( ( ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR s8 &
F * Ry c B s e Z d Z d Z e Z d Z d Z d Z d Z d Z
d Z d Z e
d Z d
Z e d Z d Z d
Z d Z RS( s2 Represent a loader option that isn't tied to a root entity.
The loader option will produce an entity-linked :class:`.Load`
object when it is passed :meth:`.Query.options`.
This provides compatibility with the traditional system
of freestanding options, e.g. ``joinedload('x.y.z')``.
c C s d | _ g | _ i | _ d S( N( ( R t _to_bindR ( R ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR s c C s d } x | j D] } x t | j | j D] \ } } | | k r, Pq, q, W| j | j d g d d t } | r | j | } | t k r t S| r | | 7} q q q W| s d S| Sd S( Ni ( ( R R' R t _bind_loaderR R R= ( R R R4 t valR7 t val_elemR| t c_key( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR=
s " " c C s | j j | d S( N( R R+ ( R ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR s c sR | k r | S| j } | | <| j | _ | j r | j d } t | t j r | j t r | j d d d t } n | j
j | j d d !| | j d n | j | j k s t
| j | j k s t
| j | j k s t
f d | j D } j | _ | j j | | j j | j | S( NiR i c s% h | ] } | j q S( ( Rx ( t .0t elem( Rv Rw RX ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pys : s ( R? R2 R R) R R* RV R t splitR Rr R RW R/ R R R t extendR RH ( R RX Rv Rw R@ Rg t new_to_bind( ( Rv Rw RX sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRx s*
'
c C s | rU t | t j rU | t t f k rU | t k rB t | _ n d | | f } n | r t | d r | j r | d d !} n | r | | f } n | | _ | S( Ns %s:%sii (
R) R R* R R R RW R R R ( R R Rg Rh Ri ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRr C s c C s/ | j j } | j | j d t | d <| S( Nt filter_aliased_classR ( R R t _serialize_pathR RB ( R R ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR S s c C s g } x | d D] } t | t r t | d k rM | \ } } d } n | \ } } } t | | } | r | j | } n | j | q | j | q Wt | | d <| | _ d S( NR i ( R) R1 R^ R RY t of_typeR+ R ( R R t retR- R! t propkeyR RU ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR X s c C sv | j d } xb | j D]W } | | k r | j | | j g | j D] } | j ^ qF | j | j | q q Wd S( Nt _unbound_load_dedupes( RG R t addR t _mapper_entitiest entity_zeroRF ( R RC RI t dedupesR Rl ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRA k s
c
C s t } d } g | D] } | | D] } | ^ q) q } xH | d d !D]9 } | rm | | | | } n | j | } t | _ qL W| | | d | } t | _ | S( Nc S s] t | t j rR | t k r% t f S| j d t rE | d } n | j d S| f Sd S( Nt .i ( R) R R* R R t
startswithR ( R- ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt
_split_key{ s
i i( Ry t defaultloadRB t _is_chain_linkR (
R! t metht keyst chainedt kwR| R R- R< t
all_tokens( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt
_from_keysw s ,
c C s d } x t t | | j D] \ } \ } \ } } t | t j r | d k ro | j d t ro | S| d t f k r | | j k r d Sq" t | t r" | j | k s | j
| k r | j
j s | j
j | r d Sq" q" W| d 7} | | S( Nii R s relationship:%si ( R R' t pairsR) R R* RV R R R- R R R[ t
_parententityR. R ( R R R R R t p_entityt p_prop( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR( s" .
c C s g } x | D] } t | t r | re | j re t | j j re | j | j j | j d f q | j | j j | j | j f q
t | t
r | j | j j | j d f q
| j | q
W| S( N( R) R R R R% R+ t
_parentmapperR0 R- R R ( R R R R R< ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR s
" "c C s | j } | j r, | r, | | d f 7} n | rG | j | | } n | sQ d S| d } t | t j r | j | | | } n~ t | t r | j } | j
| | | j | } nH | j r t | r t
| } | | k rd } qn t j d | s
d S| } t | }
| d k r7| |
_ n |
j } | j |
_ | j |
_ | j |
_ |
j } |
j sx^ t | D]M \ } } |
j |
j | | t | d k r| j n d d | sd SqWn |
j j | j |
j r|
j j r|
j j }
n |
j }
|
j r^x] |
j D]) } |
j | | d | j d | j q.Wn# |
j | |
d | j d | j |
S( s] 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))
i s6 mapper option expects string key or list of attributesNi R R ( R R R( R R) R R* t _find_entity_basestringR R[ t _find_entity_prop_comparatorR R R RS RT R R R2 R R Rr R^ R RH RR RX R R R R ( R t entitiesRJ R RI RK R< R RU t path_elementR$ R t idxR ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR sr $
"
c C s t | r | } n t | } x | D] } t j | | r( | Sq( W| r t | s t j d t j t | | f q t j d | d j
d | D f n d Sd S( NsG Query has only expression-based entities, which do not apply to %s "%s"s Mapped attribute "%s" does not apply to any of the root entities in this query, e.g. %s. Please specify the full path from one of the root entities to the target attribute. s , c s s | ] } t | Vq d S( N( t str( R t x( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pys ^ s ( R R R\ t _entity_corresponds_tot listRS RT R t clsname_as_plain_namet typet joinR ( R R RU Rc RI t searchforRl ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR G s
"&c C s | j d t ry t t | d k r | rv t j d d j d | D d j d | D f qv q n | j t r t } n x2 | D] } | SW| r t j d | f n d Sd S( NR i s Can't apply wildcard ('*') or load_only() loader option to multiple entities %s. Specify loader options for each entity individually, such as %s.s , c s s | ] } t | Vq d S( N( R ( R Rl ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pys m s c s s | ] } d | Vq d S( s Load(%s).some_option('*')N( ( R Rl ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pys o s sJ Query has only expression-based entities - can't find property named "%s".(
RV R R^ R RS RT R R R R ( R R R< RI Rl ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR c s$
( R_ R R R R R R= R Rx Rr R R RA R R R( R R R R ( ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRy s # t
loader_optionc B s, e Z d Z d Z d Z d Z RS( c C s d S( N( ( R ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR s c C sO | j | _ } | | _ t t | r; t d | n t t | | | S( Ns# Load class already has a %s method.( R_ t namet fnt hasattrR t TypeErrort setattr( R R R ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt __call__ s c C s< | | _ | j j } d i | j d 6| j _ | | _ | S( Ns Produce a new :class:`.Load` object with the
:func:`.orm.%(name)s` option applied.
See :func:`.orm.%(name)s` for usage examples.
R ( t _unbound_fnR R R ( R R t fn_doc( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt _add_unbound_fn s c C sP d i | j d 6| _ t j d d i | j d 6d t | } | | _ | S( Nsu Produce a standalone "all" option for :func:`.orm.%(name)s`.
.. deprecated:: 0.9
The :func:`.%(name)s_all` function is deprecated, and will be removed
in a future release. Please use method chaining with :func:`.%(name)s`
instead, as in::
session.query(MyClass).options(
%(name)s("someattribute").%(name)s("anotherattribute")
)
R s 0.9s The :func:`.%(name)s_all` function is deprecated, and will be removed in a future release. Please use method chaining with :func:`.%(name)s` insteadt add_deprecation_to_docstring( R R R t
deprecatedR t _unbound_all_fn( R R ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt _add_unbound_all_fn s
( R_ R R R R R ( ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR s c C s | d k r6 t | t sc t | } | j } qc n- t | d d rc t | j } | j } n | j | i d d 6d t } | | j d <| S( sn Indicate that the given attribute should be eagerly loaded from
columns stated manually in the query.
This function is part of the :class:`.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.
:func:`.contains_eager` also accepts an `alias` argument, which is the
string name of an alias, an :func:`~sqlalchemy.sql.expression.alias`
construct, or an :func:`~sqlalchemy.orm.aliased` construct. Use this when
the eagerly-loaded rows are to come from an aliased table::
user_alias = aliased(User)
sess.query(Order).\
join((user_alias, Order.user)).\
options(contains_eager(Order.user, alias=user_alias))
When using :func:`.contains_eager` in conjunction with inherited
subclasses, the :meth:`.RelationshipProperty.of_type` modifier should
also be used in order to set up the pathing properly::
sess.query(Company).\
outerjoin(Company.employees.of_type(Manager)).\
options(
contains_eager(
Company.employees.of_type(Manager),
alias=Manager)
)
.. seealso::
:ref:`loading_toplevel`
:ref:`contains_eager`
R t joinedt lazyRW t eager_from_aliasN(
R R) R R t
selectableRY R R R R ( t loadoptRg t aliast infot otR@ ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt contains_eager s 0
c O s t j t j | t | S( N( Ry R R RB ( R R ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR s c G sL | j | i t d 6t d 6 } | j d i t d 6t d 6i t d 6 | S( s 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:`.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` that has multiple entities, the lead entity can be
specifically referred to using the :class:`.Load` constructor::
session.query(User, Address).join(User.addresses).options(
Load(User).load_only("name", "fullname"),
Load(Address).load_only("email_addres")
)
.. versionadded:: 0.9.0
t deferredt
instrumentt *t undefer_pks( R R RB ( R R R@ ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt load_only s
""c G s t j | S( N( Ry R ( R ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR 0 s c C s9 | j | i d d 6 } | d k r5 | | j d s R- R ( R RB R1 R3 t id( R t classes( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt selectin_polymorphicr s
$c C s5 t } t | _ t | f | _ | j | | S( N( Ry RB R R R R ( t base_clsR t ul( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR s
N(8 R RM R R\ t
attributesR t baseR R R R t
interfacesR R t
path_registryR R R
R R R
RS R t sqlR R t sql.baseR R R Ry t objectR R R R R R R R R R R R R R R R R R R R R R R R ( ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt sz 8?+[!"$%?
1
$"