File: //proc/self/root/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyo
�
��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 x�t | j j | � D] \ } } | | k rd Pqd qd W| j p� | j j d } | j | | � } | d k s* | r� | j r� q* n g }
xi | D]a } t | t
j � r|
j | � q� | j rt S| j
r0|
j | j � q� |
j | j � q� W|
s[| |
d k r�| j rw|
j | j � q�| j r�t Sn | j t |
� | j p�d | j r�t g t | j � D] } | | j | f ^ q�� n d � q* W| s�d 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 class_t is_mappert 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[ sJ " "
> 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( R@ R ( R RB ( ( 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 <q q Wn | j j | j � d S( N( t
_current_pathR R& R( R t _attributest update( R RB t raiseerrt current_pathR; t
start_pathR$ t chopped_start_path( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR@ � s " c C s| | j } d | _ | r_ | j r_ t | t � rC t j d � � q_ t j d | j f � � n t | t j � r�| j
t � } | j
t � s� | r� | r� t
| _ n | r� d | | f } n | r� | j r� | j | } n | j | � } | | _ | S| rt | � } n | j } y t | j | � } Wn7 t k
ri| rbt j d | | f � � qwd Sn X| j } } | | } n�t | � r�t j | j | d � s>| r�t j d | | j f � � q�d 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 s�t 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.i����s. 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)?i����t 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 getattrR. t AttributeErrort propertyR t orm_utilt$ _entity_corresponds_to_use_path_implt lenR/ t __name__t entity_patht getR t with_polymorphict mappert base_mapperRA t sett
_get_strategy( R R t attrt for_strategyt wildcard_keyRH t existing_of_typet
default_tokent entt found_propertyRT 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)( R1 ( 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 R0 R2 R& ( R R1 ( ( 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 RW 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 _UnboundLoadRt Rw ( R t optst apply_cacheRv 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( Rs R R RV Rq R R1 R t _set_path_strategy( R Rf R1 RV ( ( 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(
Rs R R R> R1 Rq R RA RV R RG t is_opts_onlyR~ ( R t attrsR1 Ry t opts_onlyRf 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( Rs Rq R R R> R1 RA RV R~ ( R R� R1 Rf 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( Rs R> RA R Rq R R R1 RV R~ R RG ( R R1 Ry 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$ ( R` R R RG Rd R� ( R R R t replacet
merge_optsRp ( ( 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 RQ RW t is_tokent generate_for_superclassesR� R RA 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� RG 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( Ni����i t :s relationship:%si ( t enumerateR' R R) R R* RU 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 R1 RV RC RD R@ RA Rq Rr Rs Rw 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 � * Rx 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 R3 t valR6 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 s
| � 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 � � � f d � | j D� } � j | _ | j j
| � | j j | j � | S( Ni����R� i c s% h | ] } | j � � � � � q S( ( Rw ( t .0t elem( Ru Rv RW ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pys <setcomp>: s ( R> R1 R R) R R* RU R t splitR Rq R R� t extendR RG ( R RW Ru Rv R? Rf t new_to_bind( ( Ru Rv RW sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRw 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:%si����i (
R) R R* R R R RV R R R ( R R Rf Rg Rh ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRq C s c C s/ | j j � } | j | j d t �| d <| S( Nt filter_aliased_classR ( R� R� t _serialize_pathR RA ( 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) R0 R] R RX t of_typeR+ R� ( R R� t retR- R! t propkeyR� RT ( ( 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( RF R� t addR� t _mapper_entitiest entity_zeroRE ( R RB RH t dedupesR� Rk ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR@ 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����( Rx t defaultloadRA 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( Ni����i R� s relationship:%si ( R� R' t pairsR) R R* RU R R R- R R RZ 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
_parentmapperR. 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 s�x^ t | � D]M \ } } |
j |
j | | t | � d k r�| j n d d | � s�d Sq�Wn |
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 RZ t _find_entity_prop_comparatorR� R R RR RS R R R1 R� R� Rq R] R RG RQ RW R� R� R� R� ( R t entitiesRI R RH RJ R; R RT 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 <genexpr>^ s ( R R R[ t _entity_corresponds_tot listRR RS R t clsname_as_plain_namet typet joinR ( R R� RT Rb RH t searchforRk ( ( 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� Rk ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pys <genexpr>m s c s s | ] } d | Vq d S( s Load(%s).some_option('*')N( ( R� Rk ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pys <genexpr>o s sJ Query has only expression-based entities - can't find property named "%s".(
RU R R] R� RR RS R� R R R ( R R� R; RH Rk ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR� c s$
( R^ R� R� R R R� R< R~ Rw Rq R� R� R@ R� R� R( R� R� R� R� ( ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRx � 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 lazyRV t eager_from_aliasN(
R R) R� R t
selectableRX R R R R ( t loadoptRf 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( Rx R� R� RA ( 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 RA ( 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( Rx 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 <n | S( s
Indicate that the given attribute should be loaded using joined
eager loading.
This function is part of the :class:`.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:`.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` 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.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� t innerjoinN( R R R ( R� Rf R� R$ ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt
joinedload5 s V c O s t j t j | t | � S( N( Rx R� R� R ( R� R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR� � s c O s t j t j | t | � S( N( Rx R� R� RA ( R� R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt joinedload_all� s c C s | j | i d d 6� S( s Indicate that the given attribute should be loaded using
subquery eager loading.
This function is part of the :class:`.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`
t subqueryR� ( R ( R� Rf ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt subqueryload� s c G s t j t j | t i � S( N( Rx R� R� R ( R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR� � s c G s t j t j | t i � S( N( Rx R� R� RA ( R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt subqueryload_all� s c C s | j | i d d 6� S( s5 Indicate that the given attribute should be loaded using
SELECT IN eager loading.
This function is part of the :class:`.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))
.. versionadded:: 1.2
.. seealso::
:ref:`loading_toplevel`
:ref:`selectin_eager_loading`
t selectinR� ( R ( R� Rf ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt selectinload� s c G s t j t j | t i � S( N( Rx R� R� R ( R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR� � s c G s t j t j | t i � S( N( Rx R� R� RA ( R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt selectinload_all� s c C s | j | i d d 6� S( s Indicate that the given attribute should be loaded using "lazy"
loading.
This function is part of the :class:`.Load` interface and supports
both method-chained and standalone operation.
.. seealso::
:ref:`loading_toplevel`
:ref:`lazy_loading`
t selectR� ( R ( R� Rf ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt lazyload� s c G s t j t j | t i � S( N( Rx R� R� R ( R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR� s c G s t j t j | t i � S( N( Rx R� R� RA ( R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt lazyload_all s c C s | j | i d d 6� } | S( s 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:`.Load` interface and supports
both method-chained and standalone operation.
.. seealso::
:ref:`loading_toplevel`
:ref:`selectin_eager_loading`
t immediateR� ( R ( R� Rf R$ ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt
immediateload s c G s t j t j | t i � S( N( Rx R� R� R ( R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR� % s c C s | j | i d d 6� S( sx Indicate that the given relationship attribute should remain unloaded.
This function is part of the :class:`.Load` interface and supports
both method-chained and standalone operation.
:func:`.orm.noload` applies to :func:`.relationship` attributes; for
column-based attributes, see :func:`.orm.defer`.
.. seealso::
:ref:`loading_toplevel`
t noloadR� ( R ( R� Rf ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR� * s c G s t j t j | t i � S( N( Rx R� R� R ( R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR� = s c C s# | j | i | r d n d d 6� S( s� 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:`.Load` interface and supports
both method-chained and standalone operation.
:func:`.orm.raiseload` applies to :func:`.relationship` attributes only.
.. versionadded:: 1.1
.. seealso::
:ref:`loading_toplevel`
:ref:`prevent_lazy_with_raiseload`
t raise_on_sqlt raiseR� ( R ( R� Rf t sql_only( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt raiseloadB s c O s t j t j | t | � S( N( Rx R� R� R ( R� R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR� g s c C s | j | d � S( s6 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:`.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`
N( R R ( R� Rf ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR� l s "c G s t j t j | t i � S( N( Rx R� R� R ( R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR� � s c C s! | j | f i t d 6t d 6� S( st Indicate that the given column-oriented attribute should be deferred,
e.g. not loaded until accessed.
This function is part of the :class:`.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:`.Load` object that is present on a certain path can have
:meth:`.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`
R� R� ( R� RA ( R� R- ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt defer� s :c G s6 | r t j d � n t j t j | f | t i � S( Ns} The *addl_attrs on orm.defer is deprecated. Please use method chaining in conjunction with defaultload() to indicate a path.( R t warn_deprecatedRx R� R� R ( R- t
addl_attrs( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR� � s
c C s! | j | f i t d 6t d 6� S( sc 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:`.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`
R� R� ( R� R RA ( R� R- ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt undefer� s ,c G s6 | r t j d � n t j t j | f | t i � S( Ns The *addl_attrs on orm.undefer is deprecated. Please use method chaining in conjunction with defaultload() to indicate a path.( R R Rx R� R R ( R- R ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR s
c C s$ | j d d i t d | 6d t �S( s 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`
R� s undefer_group_%sR� N( R� R RA ( R� R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt
undefer_group s c C s t � j | � S( N( Rx R ( R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR D s c C s< t j t | � � } | j | f i t d 6d i | d 6�S( sY 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.
.. seealso::
:ref:`mapper_query_expression`
t query_expressionRy R ( t sql_exprt _labeledR R� RA ( R� R- R ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt with_expressionI s c C s# t j t j | f t i | d 6� S( NR ( Rx R� R R ( R- R ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR k s c C sA | j i t d 6d i t t d � | D� d t �� d 6�| S( s� 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:`inheritance_polymorphic_load`
t selectinload_polymorphicRy c s s | ] } t | � Vq d S( N( R ( R� R! ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pys <genexpr>� s R- R� ( R� RA R0 R2 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( Rx RA 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� RL R R[ t
attributesR t baseR R R R t
interfacesR R t
path_registryR R R
R R R
RR R t sqlR R t sql.baseR R R Rx 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 <module> sz � �� �8?+[!"$%?
1
$"