�
���ec@s�dZd
dl
mZ
d
dlmZ
d
dlmZ
d
dlmZ
d
dlm	Z	
d
dlm
Z

d
dlmZ
d
d	lm
Z

d
d
lmZ
d
dlmZ
d
dlmZ
d
d
lmZ
d
dlmZ
d
dlmZ
ddl
mZ
ddl
mZ
ddl
mZ
ddlmZ
ddlmZ
ddlmZ
ddlmZ
ddlmZ
ddlmZ
ddlm Z 
de efd��YZ!de!f
d��YZ"de#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$�d&��
Z*e*j'd'��
Z*e$�d(��
Z+e+j'd)��
Z+e$�d*��
Z,e,j'd+��
Z,e$�d,��
Z-e-j'd-��
Z-e$�d.��
Z.e.j'd/��
Z.e$�e/d0�
�
Z0e0j'd1��
Z0e$�d2��
Z1e1j'd3��
Z1e$�e/d4�
�
Z2e2j'd5��
Z2e$�d6��
Z3e3j'd7��
Z3e$�d8��
Z4e4j'd9��
Z4e$�d:��
Z5e5j'd;��
Z5e$�d<��
Z6e6j'd=��
Z6d>S(?s

i
(
tutil(
tQueryableAttribute(
t_class_to_mapper(
t_is_aliased_class(
t_is_mapped_class(
tInspectionAttr(
tLoaderOption(
tMapperProperty(
tPropComparator(
t_DEFAULT_TOKEN(
t_WILDCARD_TOKEN(
tPathRegistry(
t
TokenRegistry(
t_orm_full_deannotatei(
texc(
tinspect(
tand_(
t	coercions(
troles(
t
traversals(
tvisitors(
t_generative(
t
GenerativetLoadcBs�
eZ
dZeZd
ejjfdejjfdejj	fdej
jfdejjfdejj
fgZd�Zed��
Zd	�Zd
�Zd�Zd�Zed
��
Zd�ZeZeZd!ZeZd!Zd"Z d�Z!d�Z"d�Z#ed!d�Z$d�Z%d�Z&d�Z'e(d��
Z)e(ed�
�
Z*e(d!ed��
Z+e(d��
Z,e(d��
Z-ed!d�Z.eed�Z/d�Z0d�Z1d�Z2d �Z3RS(#s�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`

    tpathtstrategyt_of_typet_extra_criteriat_context_cache_keyt
local_optscCsDt|
�
}|j

|j|_tj�|_i|_t|_	dS(
N(
Rt
_post_inspectt_path_registryRRtOrderedDicttcontextRtFalsetis_class_strategy(tselftentitytinsp((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt__init__bs


	
cCs@|j|�
}|
|_
i|_i|_d|_d
|_|S(N((t__new__RR!RtNoneRR(tclsRtload((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytfor_existing_pathms
	
	
	
	
	
cCs
|j|
�
S(
N(
t_adjust_for_extra_criteria(R$R!tuncached_opt((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt'_adapt_cached_option_to_uncached_optionws
cCs[|jst
d
�
�
|
jj}|
j}|j�}|j�}|j|t|j��S(s�
Apply the current bound parameters in a QueryContext to the
        immediate "extra_criteria" stored with this Load object.

        Load objects are typically pulled from the cached version of
        the statement from a QueryContext.  The statement currently being
        executed will have new values (and keys) for bound parameters in the
        extra criteria which need to be applied by loader strategies when
        they handle this criteria for a result set.

        s8this should only be called if _extra_criteria is present(RtAssertionErrort
compile_statetselect_statementtqueryt_generate_cache_keyt_apply_params_to_elementR(R$R!t
orig_queryt
current_querytk1tk2((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt_generate_extra_criteriazs

	
	
csC�
jj
�i}ddg���
�fd
�}|j||�S(s�Apply the current bound parameters in a QueryContext to all
        occurrences "extra_criteria" stored within al this Load object;
        copying in place.

        c

sq|js
dS�d
dkr<�j��jj�f�(n�\��
t��
fd�|jD�
�
|_dS(Nic
3s!|]}
�
j�|
�V
qdS(
N(
R5(t.0tcrit(R8R9(sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pys	<genexpr>�s
(RR)R4R3ttuple(
topt(tckR!R6(R8R9sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytprocess�s
	
	


N(R1R2R)t_deep_clone(R$R!tappliedR@((R?R!R6sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR-�s
cCs
||
kr|
|S|j�}||
|<|j
|_
|j|jksNt�
|j|jksft�
|j|jks~t�
|jr�tjg|jj	�D]9\}}|t
|t�r�|j|
|�n|f^q��
|_n|j
j|j
�

||�

|S(
N(t	_generateRtpropagate_to_loadersR0R#tis_opts_onlyR!RR titemst
isinstanceRRARtupdate(R$RBR@tclonedtkeytvalue((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRA�s




	
U
c
Csig}
|jdkrgSxI|jj�D]8\\}}}|d
krMq)n|
j||f
�

q)W|
S(Ntloader(R!R)RFtappend(R$t
serializedRJtloader_pathtobj((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR�s


"



c
Cs"tt
|�j�}
i|
_|
S(
N(tsuperRRCR(R$RI((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRC�s

	
cCs1|
jj
sdS|j|
|t|
j�
�
dS(
N(tcompile_optionst_enable_eagerloadst_processtbooltcurrent_path(R$R1tmapper_entities((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt'process_compile_state_replaced_entities�s



cCsA|
jj
sdS|j|
|
jt|
j�
o9|
jj�
dS(
N(RRRSRTt_lead_mapper_entitiesRURVt_for_refresh_state(R$R1((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytprocess_compile_state
s





c
Cs�|
jj
}|
j}|r�x�|jj�D]\\\}}}|rS|jrSq+n|j||�}	|	dk	r+||
j||	f<q+q+Wn|
jj	|j�

dS(
N(
RRRZRVR!RFRDt
_chop_pathR)t
attributesRH(
R$R1RWtraiseerrt
is_refreshRVttokent
start_pathRLtchopped_start_path((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRT
s

	

"



c
Cs�|j}d|_|r_|
jr_t|
t�rCtjd
�
�
q_tjd|
jf
�
�
nt|tj	�r|j
t�
}|}	|j
t�
s�|r
|r�t
|_n|r�d||f}n|r�|jr�|
j|}
n|
j|�
}
|
|_|
S|r
t|�
}
n	|
j}
tjd�

yt|
j|�}WnFtk
r�

}
|r�
tjtjd||
f�
d|�


q�
dSnlXy|j}}WnWtk
r�

}

t|t�s�
tjtjd|	|
t|�
f�
d|
�


q�
�n
X|
|}
nDt|�
}|js"|jrjtj|j|
d�sH|r`tjd	||
jf�
�
qgdSqHn�
|j r�|}}|
|}
n�
|j!rH|j}}tj|j|
d�s,|r%tjd
||
jt"|
�
dkr|
jjr|jjrd|
d
|jj#fndf�
�
q,dSn|j$rN|j$rN|j$|_$nt|dd�r;|j}t|�
}}|dkr�|j%}n|
j&|j'|d�}|jstj(|j)j*|j)dt+dt+d|dk	r�t|�
nd�}t|�
}n|
j&|j,|d|�
|
||}
||_qH|
|}
n|dk	rd|j-|�

n|
jry|
j&}
n|
|_|
S(Ns3Wildcard token cannot be followed by another entitys7Mapped attribute '%s' does not refer to a mapped entitys%s:%ss�Using strings to indicate column or relationship paths in loader options is deprecated and will be removed in SQLAlchemy 2.0.  Please use the class-bound attribute directly.s3Can't find property named "%s" on %s in this Query.treplace_contextsNExpected attribute "%s" on %s to be a mapped attribute; instead got %s object.i����s.Attribute '%s' does not link from element '%s's1Attribute "%s" does not link from element "%s".%si
s%  Did you mean to use %s.of_type(%s)?i����tRtpath_with_polymorphictaliasedt_use_mapper_patht_existing_alias(.RR)t
has_entityRGRtsa_exct
ArgumentErrortpropRtstring_typestendswithR	R
R"RDtis_aliased_classtparentR`RRR%twarn_deprecated_20tgetattrtclass_tAttributeErrortraise_tpropertyRttypet	is_mappertorm_utilt$_entity_corresponds_to_use_path_impltis_propertytis_attributetlent__name__RR!tentity_pathtgettwith_polymorphictmappertbase_mappertTruetsett
_get_strategy(R$Rtattrtfor_strategytwildcard_keyR^tpolymorphic_entity_contexttexisting_of_typet
default_tokent
attr_str_nametentterrtfound_propertytaeR&Rltactext_infotof_type_infotexisting((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt_generate_path
s�		
	














	

	





















	




	







&

	



	

	
	


	





	

	
c

Csd
|jf
S(NsLoad(strategy=%r)(
R(
R$((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt__str__�
s
cCs+|
dk	r't
t|
j��
�
}
n|
S(
N(R)R=tsortedRF(R$R((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt
_coerce_strat�
s


cCstd
�
�
dS(NsHOnly 'unbound' loader options may be used with the Load.options() method(
tNotImplementedError(R$RpRBtbound((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt_apply_to_parent�
s

c
Gs�i}t|t
�}|r+td
�
�
nxs|
D]k}y|j|||�
Wq2tk
r�
}
t|t�s�tjtj	d|f
�
d|�


q��q2Xq2WdS(s�Apply a series of options as sub-options to this
        :class:`_orm.Load`
        object.

        E.g.::

            query = session.query(Author)
            query = query.options(
                        joinedload(Author.book).options(
                            load_only(Book.summary, Book.excerpt),
                            joinedload(Book.citations).options(
                                joinedload(Citation.author)
                            )
                        )
                    )

        :param \*opts: A series of loader option objects (ultimately
         :class:`_orm.Load` objects) which should be applied to the path
         specified by this :class:`_orm.Load` object.

        .. versionadded:: 1.3.6

        .. seealso::

            :func:`.defaultload`

            :ref:`relationship_loader_options`

            :ref:`deferred_loading_w_multiple`

        sMThe options() method is currently only supported for 'unbound' loader optionssBLoader option %s is not compatible with the Load.options() method.tfrom_N(
RGt_UnboundLoadR�R�RtRRRuRjRk(R$toptstapply_cacheR�R>R�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytoptions�
s !














cCsq|j|�
}||_
|j|
|d
�}|j|_|j|_|j|_t|_|_|j
|_
dS(Ntrelationship(R�RDt_clone_for_bind_strategyRRRR"R#(R$R�RRDRI((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytset_relationship_strategys
	





c	CsW|j|�
}t
|_x8|
D]0}|j||d
d|d|�}t|_qWdS(Ntcolumnt	opts_onlyR�(R�R"R#R�R�RD(R$tattrsRR�R�R�RI((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytset_column_strategy%s
	



cCsB|j|�
}x,|
D]$}|j
||d�}t|_qWdS(
N(R�R�R)R�RD(R$R�RR�RI((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytset_generic_strategy/s



cCsJ|j|
�
}
|j
d|
d�}t|_t|_|jj|�

dS(
N(R�R�R)R�R#RDRRH(R$RR�RI((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytset_class_strategy6s


	
	
cCs�|j�}|j
|j|
||�
||_|j|_|rS|jj|�

n|ret|_n|st|jr�|j�
n|S(
s
Create an anonymous clone of the Load/_UnboundLoad that is suitable
        to be placed in the context / _to_bind collection of this Load
        object.   The clone will then lose references to context/_to_bind
        in order to not create reference cycles.

        (	RCR�RRRRHR�REt_set_path_strategy(R$R�RR�R�R�RI((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR�>s	

	






cCs�|s
|rl|j|
d
�}|rV|ri|j
j|j
�

|j|j7_qiq�|j|
d
|�
n\|j|
d
�}|j|
d
|�
|r�|jr�|j
j|j
�

|j|j7_ndS(NRL(R�RRHRR�RE(R$R!Rtreplacet
merge_optsR�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt
_set_for_pathUs










c
Cs�|jr%|j
jr%|j
j}
n	|j
}
|
jrsx[|
j�D](}|j|j|d
td|j	�
qDWn"|j|j|
d
td|j	�
d|_dS(NR�R�(R#RRiRptis_tokentgenerate_for_superclassesR�R!R�RER)(R$teffective_pathR((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR�es 

		










c
Cs]|jj
�}
d|
d
<|
ddk	rFtj|
dd�|
d<n|jj�|
d<|
S(NRR!RLR((
RL(t__dict__tcopyR)Rtserialize_context_dictRt	serialize(R$t
d((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt__getstate__s




cCsP|jj
|
�

tj|j�
|_|jdk	rLtj|j�
|_ndS(
N(R�RHRtdeserializeRR!R)tdeserialize_context_dict(R$tstate((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt__setstate__�s



cCs�d
}x�tt
|
|j��
D]�\}\}}t|tj�r�|dkrf|jdt�
rf|
S|dtf
kr�||j	kr�dSn||kr�qqt|t�r�|jr�|jr�|j
|�
r�qqdSqW|
|dS(Ni����it
:srelationship:%si
(t	enumeratetzipRRGRRmRnR	R
RJR)RRxtisa(R$tto_chopRt
itc_tokentp_token((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR\�s"
+




	
	

N((4R~t
__module__t__doc__R�t_is_strategy_optionRtExtendedInternalTraversaltdp_has_cache_keytdp_plain_objtdp_multitInternalTraversaltdp_clauseelement_listtdp_has_cache_key_tuplestdp_string_multi_dictt_cache_key_traversalR'tclassmethodR,R/R:R-RARvRRCR"RER#R)RRDRRRXR[RTR�R�R�R�RR�R�R�R�R�R�R�R�R�R�R\(((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR&sZ)




	
		%		!	




			
�			7
				
	R�cBs�eZ
dZd
�Zdd�
ZeZd�Zd�Z	dd�
Z
d�Zd�Zd�Z
d	�Zed
��
Zd�Zed�
Zd
�Zd�Zd�ZRS(s<
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

Cs(d
|_g|_
i|_d|_dS(N(((Rt_to_bindRR(
R$((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR'�s
	
	
	
cs+
t|�
}|j
}|�kr/�||fS�|}tj}|��dkr`t��n||f|jd
|j|��
�d|jf|j	r�dt
��
�fd�|j	D�
�
fnd	|jr�dt
��
fd�|jD�
�
fnd
|jr&
|j
d|j|��
�ndS(sXInlined gen_cache_key

        Original traversal is::


            _cache_key_traversal = [
                ("path", visitors.ExtendedInternalTraversal.dp_multi_list),
                ("strategy", visitors.ExtendedInternalTraversal.dp_plain_obj),
                (
                    "_to_bind",
                    visitors.ExtendedInternalTraversal.dp_has_cache_key_list,
                ),
                (
                    "_extra_criteria",
                    visitors.InternalTraversal.dp_clauseelement_list),
                (
                    "local_opts",
                    visitors.ExtendedInternalTraversal.dp_string_multi_dict,
                ),
            ]

        The inlining is so that the "_to_bind" list can be flattened to not
        repeat the same UnboundLoad options over and over again.

        See #6869

        RRR�c
3sC|]9}
|
�kr�j|
�
r|
j
��
d��
V
qd
S(t_unbound_option_seenN(taddt_gen_cache_key(R;telem(tanon_mapt
bindparamstseen(sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pys	<genexpr>�s
Rc
3s!|]}
|
j��
�V
qdS(
N(
R�(R;R�(R�R�(sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pys	<genexpr>s
RN((((tidt	__class__Rt_cache_key_traversal_visitorR)R�tvisit_multi_listRRR�R=RRtvisit_string_multi_dict(R$R�R�R�tidselfR*tid_tvis((R�R�R�sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR��s
	

	

!�'
c

Cs|jj
|�

d|_dS(
N(R�RMR)(
R$((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR�s
cCs�||
kr|
|S|j�}||
|<|j
|_
|j|jksNt�
|j|jksft�
|j|jks~t�
g|jp�d
D]}|j|
|�^q�|_|jj	|j�

||�

|S(N((
RCRRDR0R#RER�RARRH(R$RBR@RIR�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRAs




1
c	Cs�
||kr||S|dkr,|j
}n|j�}|||<|j|_|jr�|jd
}t|tj�r�|jt	�
r�|j
d�
ddt}n|j|
j|jdd
!||jd�
n|j
|j
ks�t�
|j|jks
t�
|j|jks
t�
t�}|
j
|_
g|j
D](}||kr7
|j|�
r7
|^q7
g|D]:}||kri
|j|�
ri
|j|
|||�^qi
|j
(|jj|j�

|S(Ni����R�i(R)R�RCRRRGRRmRnR	tsplitR
R�RDR0R#RER�R�R�RRH(	R$RpRBR�tto_bindRIR�tuniqR�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR�5s6




	



	

'

	


%


?cCs�|rUt|t
j�rU|ttfkrU|tkrBt|_nd
||f}n|
r�t|
d�
r�|jr�|
dd!}
n|r�|
|f
}
n|
|_	t
|dd�|_|
S(Ns%s:%si����iR((RGRRmR
R	R"RDRR#RRrR(R$RR�R�R�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR�cs




 



	
c
Cs9|jj
�}
d|
d
<|j|jdt�

|
d<|
S(NRtfilter_aliased_classR((R�R�t_serialize_pathRR�(R$R�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR�us


cCs�g}x�|
d
D]�}t|t
�r�t|�
dkrM|\}}d}n|\}}}t||�}|r�|j|�
}n|j|�

q|j|�

qWt
|�
|
d
<|
|_dS(NRi(RGR=R}R)Rrtof_typeRMR�(R$R�tretRJR*tpropkeyR�Rl((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR�~s




	





cCs�|
jd
}|
j
j}xu|jD]j}||kr#|j|�

|rX|jrXq#n|jg|D]}|j^qe|
j|
j|�
q#q#WdS(Nt_unbound_load_dedupes(	R]RRRZR�R�RDt_bind_loadertentity_zeroRV(R$R1RWR^tdedupesR_tvalR�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRT�s













c
Cs�t�}d
�}g|D]}||�
D]}|^q)q}	xH|	dd!D]9}t
|_|rv|
|||�}qL|j|�
}qLW|
||	d|�}t|_|S(Nc

Sspt|t
j�re|tkr%tf
S|jd
t�
rXt
jddd�


|d}n|jd
�
S|f
SdS(Nt
.s�The undocumented `.{WILDCARD}` format is deprecated and will be removed in a future version as it is believed to be unused. If you have been using this functionality, please comment on Issue #4390 on the SQLAlchemy project tracker.tversions1.4i
(RGRRmR
R	t
startswithtwarn_deprecatedR�(
RJ((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt
_split_key�s






ii����(R�R�t_is_chain_linktdefaultloadR"(
R*tmethtkeystchainedtkwR>R�RJR`t
all_tokens((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt
_from_keys�s		,	


	
cCs
d
}x�tt
|
|j���
D]�\}\}\}}t|tj�r�|dkro|jdt�
ro|
S|dtf
kr�||j	kr�dSq"t|t�r"|j|k	s�|j
|k	r�|j
js�|j
j|�
r�dSq"q"W|d7}|
|S(Ni����iR�srelationship:%si
(R�R�tpairsRGRRmRnR	R
RJR)RRvt
_parententityRxR�(R$R�RR�R�tp_entitytp_prop((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR\�s"


.








cCs�g}x�|
D]�}t|t
�r�|re|jret|j�
jre|j|jj|jdf�

q�|j|jj|j|jr�|jj
ndf�

q
t|t�r�|j|jj|jdf�

q
|j|�

q
W|S(
N(RGR
RRRoRMt
_parentmapperRsRJR)R%R(R$RR�R�R`((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR��s




	
"	

"
"
c	Cs�|j}|j
r,|r,||
d
f
7}n|rG|j||�}n|sQdS|d
}t|tj�r�|j|
||�}n~t|t�r�|j	}|j
|
||j|�}nH|j
r�t|�
r�t
|�
}||
kr
d}q
ntjd�
�
|s

dS|}	t|	�
}
|dkr7
|
j}n|j|
_|j|
_|j
|
_
|j|
_|
j}|
j
s�
xdt|�
D]S\}}|
j|
j||t|�
dkr�
|jndd|d|�
s�
dSq�
Wn|
jj|j�

|
j
r|
jjr|
jj}
n	|
j}
|
jrgx]|
j�D])}|
j||d|jd|j�
q7Wn#|
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))

        is6mapper option expects string key or list of attributesNi
R�R�R�( RR#R\R)RGRRmt_find_entity_basestringRRvt_find_entity_prop_comparatorR�RRRjRkRR!RRERR�R�R}RRHRiRpR�R�R�R�(R$tentitiesRVR!R^RaR`R%Rltpath_elementRLRtidxR�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR��st$	






	





	




		




"


	
		












cCs�t|�
r|}nt
|�
}x�|
D]}tj||�r(|Sq(W|r�t|
�
s�tjd
tjt	|�
�
|f�
�
q�tjd|dj
d�|
D�
�
f�
�
ndSdS(NsGQuery 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
ss|]}
t|
�
V
qdS(
N(
tstr(R;t
x((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pys	<genexpr>�s(RRRyt_entity_corresponds_totlistRjRkRtclsname_as_plain_nameRwtjoinR)(R$R
RlR�R^t	searchforR�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR

s

	






"
&cCs�|jd
t
�
rytt|
�
�
dkr�|rvtjddjd�|
D�
�
djd�|
D�
�
f�
�
qvq�n|jt�
r�t}nx2|
D]}|SW|r�tjd|f
�
�
ndSdS(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
ss|]}
t|
�
V
qdS(
N(
R
(R;R�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pys	<genexpr>�sc
ss|]}
d|
V
qd
S(sLoad(%s).some_option('*')N((R;R�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pys	<genexpr>�s
sJQuery has only expression-based entities - can't find property named "%s".(
RnR
R}R
RjRkR

R	R"R)(R$R
R`R^R�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR
�s$








	



N(R~R�R�R'R)R�R"R�R�RAR�R�R�R�RTR�R�R\R�R�R

R
(((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR��s"		S		.					(		�	t
loader_optionc
Bs,eZ
d�Zd
�Zd�Zd�ZRS(c


CsdS(
N((
R$((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR'�s
cCsO|
j|_
}|
|_tt|�r;td
|�
�
ntt||
�
|S(Ns#Load class already has a %s method.(R~tnametfnthasattrRt	TypeErrortsetattr(R$R
R

((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt__call__�s

	


cCs<|
|_|j
j}d
i
|jd6|j
_||
_|S(Ns�Produce a new :class:`_orm.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
tfn_doc((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt_add_unbound_fn�s
	

	
cCsPd
i
|jd6|
_
tjddi
|jd6dt�
|
�
}
|
|_|S(Ns}
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

s0.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` insteadtadd_deprecation_to_docstring(R

R�Rt
deprecatedR"t_unbound_all_fn(R$R
((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt_add_unbound_all_fn�s



		
(R~R�R'R
R
R
(((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR
�s
				cCs�|d	k	rIt
|t�s3t|�
}|j}qvtjd
dd�


n-t|
dd	�rvt|
j�
}|j}n|j	|
i
dd6dt
�
}||jd<|S(
s�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`

    s�Passing a string name for the 'alias' argument to 'contains_eager()` is deprecated, and will not work in a future release.  Please use a sqlalchemy.alias() or sqlalchemy.orm.aliased() construct.R�s1.4RtjoinedtlazyRDteager_from_aliasN(R)RGR
Rt
selectableRR�RrRR�R"R(tloadoptR�taliastinfototRI((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytcontains_eager�s'









cOst�j
tj|t|
�S(
N(R�R�R"
R�(R�R�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR"
9s	
c
GsL|j|
it
d
6td6�}|jditd
6td6i
td6�
|S(slIndicate that for a particular entity, only the given list
    of column-based attribute names should be loaded; all others will be
    deferred.

    This function is part of the :class:`_orm.Load` interface and supports
    both method-chained and standalone operation.

    Example - given a class ``User``, load only the ``name`` and ``fullname``
    attributes::

        session.query(User).options(load_only(User.name, User.fullname))

    Example - given a relationship ``User.addresses -> Address``, specify
    subquery loading for the ``User.addresses`` collection, but on each
    ``Address`` object load only the ``email_address`` attribute::

        session.query(User).options(
                subqueryload(User.addresses).load_only(Address.email_address)
        )

    For a :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(User.name, User.fullname),
                    Load(Address).load_only(Address.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

    tdeferredt
instrumentt
*tundefer_pks(R�R"R�(R
R�RI((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt	load_only@s
&

"c
Gst�j
|�S(
N(R�R'
(
R�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR'
oscCs9|j|
i
d
d6�}|dk	r5||jd<n|S(s?
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
t	innerjoinN(R�R)R(R
R�R(
RL((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt
joinedloadtsX


cOstj
tj|t|
�S(
N(R�R�R)
R"(R�R�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR)
�scCs|j|
i
d
d6�S(sIndicate 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`

    tsubqueryR
(
R�(R
R�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytsubqueryload�sc
Gstj
tj|ti�S(
N(R�R�R+
R"(
R�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR+
�scCs|j|
i
d
d6�S(s9Indicate that the given attribute should be loaded using
    SELECT IN eager loading.

    This function is part of the :class:`_orm.Load` interface and supports
    both method-chained and standalone operation.

    examples::

        # selectin-load the "orders" collection on "User"
        query(User).options(selectinload(User.orders))

        # selectin-load Order.items and then Item.keywords
        query(Order).options(
            selectinload(Order.items).selectinload(Item.keywords))

        # lazily load Order.items, but when Items are loaded,
        # selectin-load the keywords collection
        query(Order).options(
            lazyload(Order.items).selectinload(Item.keywords))

    .. versionadded:: 1.2

    .. seealso::

        :ref:`loading_toplevel`

        :ref:`selectin_eager_loading`

    tselectinR
(
R�(R
R�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytselectinload�sc
Gstj
tj|ti�S(
N(R�R�R-
R"(
R�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR-
scCs|j|
i
d
d6�S(s 
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`

    tselectR
(
R�(R
R�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytlazyload$sc
Gstj
tj|ti�S(
N(R�R�R/
R"(
R�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR/
6scCs|j|
i
d
d6�}|S(s�Indicate that the given attribute should be loaded using
    an immediate load with a per-attribute SELECT statement.

    The load is achieved using the "lazyloader" strategy and does not
    fire off any additional eager loaders.

    The :func:`.immediateload` option is superseded in general
    by the :func:`.selectinload` option, which performs the same task
    more efficiently by emitting a SELECT for all loaded objects.

    This function is part of the :class:`_orm.Load` interface and supports
    both method-chained and standalone operation.

    .. seealso::

        :ref:`loading_toplevel`

        :ref:`selectin_eager_loading`

    t	immediateR
(
R�(R
R�RL((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt
immediateload;s
c
Gstj
tj|ti�S(
N(R�R�R1
R"(
R�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR1
UscCs|j|
i
d
d6�S(sIndicate that the given relationship attribute should remain unloaded.

    The relationship attribute will return ``None`` when accessed without
    producing any loading effect.

    This function is part of the :class:`_orm.Load` interface and supports
    both method-chained and standalone operation.

    :func:`_orm.noload` applies to :func:`_orm.relationship` attributes; for
    column-based attributes, see :func:`_orm.defer`.

    .. note:: Setting this loading strategy as the default strategy
        for a relationship using the :paramref:`.orm.relationship.lazy`
        parameter may cause issues with flushes, such if a delete operation
        needs to load related objects and instead ``None`` was returned.

    .. seealso::

        :ref:`loading_toplevel`

    tnoloadR
(
R�(R
R�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR2
Zsc
Gstj
tj|ti�S(
N(R�R�R2
R"(
R�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR2
uscCs#|j|
i
|rd
ndd6�S(s�Indicate that the given attribute should raise an error if accessed.

    A relationship attribute configured with :func:`_orm.raiseload` will
    raise an :exc:`~sqlalchemy.exc.InvalidRequestError` upon access.   The
    typical way this is useful is when an application is attempting to ensure
    that all relationship attributes that are accessed in a particular context
    would have been already loaded via eager loading.  Instead of having
    to read through SQL logs to ensure lazy loads aren't occurring, this
    strategy will cause them to raise immediately.

    :func:`_orm.raiseload` applies to :func:`_orm.relationship`
    attributes only.
    In order to apply raise-on-SQL behavior to a column-based attribute,
    use the :paramref:`.orm.defer.raiseload` parameter on the :func:`.defer`
    loader option.

    :param sql_only: if True, raise only if the lazy load would emit SQL, but
     not if it is only checking the identity map, or determining that the
     related value should just be None due to missing keys.  When False, the
     strategy will raise for all varieties of relationship loading.

    This function is part of the :class:`_orm.Load` interface and supports
    both method-chained and standalone operation.


    .. versionadded:: 1.1

    .. seealso::

        :ref:`loading_toplevel`

        :ref:`prevent_lazy_with_raiseload`

        :ref:`deferred_raiseload`

    traise_on_sqltraiseR
(
R�(R
R�tsql_only((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt	raiseloadzs'
cOstj
tj|t|
�S(
N(R�R�R6
R"(R�R�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR6
�scCs|j|
d
�S(s: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`

    N(R�R)(R
R�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR��s"c
Gstj
tj|ti�S(
N(R�R�R�R"(
R�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR��scCs:itd
6td6}|r't|d<n|j
|
f
|�S(s�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 raiseload: raise :class:`.InvalidRequestError` if the column
     value is to be loaded from emitting SQL.   Used to prevent unwanted
     SQL from being emitted.

     .. versionadded:: 1.4

     .. seealso::

        :ref:`deferred_raiseload`

    :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$
R6
(R�R�(R
RJR6
R((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytdefer�sE



c
Os<|
rtj
d
dd�


ntjtj|f
|
t|�S(Ns}The *addl_attrs on orm.defer is deprecated.  Please use method chaining in conjunction with defaultload() to indicate a path.R�s1.3(RR�R�R�R7
R"(RJt
addl_attrsR�((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR7
 s



cCs!|j|
f
it
d
6td6�S(sgIndicate 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`

    R#
R$
(R�R"R�(R
RJ((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytundefer.s,
c
Gs<|
rtj
d
dd�


ntjtj|f
|
ti�S(NsThe *addl_attrs on orm.undefer is deprecated.  Please use method chaining in conjunction with defaultload() to indicate a path.R�s1.3(RR�R�R�R9
R"(RJR8
((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR9
_s



cCs$|jd
di
td|
6dt�
S(sIndicate 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%
sundefer_group_%sR�N(R�R)R�(R
R

((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt
undefer_groupms
c

Cst�j
|�
S(
N(R�R:
(
R

((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR:
�scCsBtj
tjt|�
�}|j|
f
i
td
6di
|d6�
S(s�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 populated.

    :param expr: SQL expression to be applied to the attribute.

    .. versionchanged:: 1.4  Loader options such as
       :func:`_orm.with_expression`
       take effect only at the **outermost** query used, and should not be used
       within subqueries or inner elements of a UNION. See the change notes at
       :ref:`change_8879` for background on how to correctly add arbitrary
       columns to subqueries.

    .. 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`

    tquery_expressionR�t
expression(RtexpectRtLabeledColumnExprRoleR
R�R�(R
RJR<
((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytwith_expression�s(

cCs#tj
tj|f
ti
|
d
6�S(NR<
(R�R�R?
R"(RJR<
((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR?
�s
c	CsA|ji
t
d
6di
ttd�|
D�
dt�

�
d6�


|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:`polymorphic_selectin`

    tselectinload_polymorphicR�c
ss|]}
t|
�
V
qdS(
N(
R(R;R*((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pys	<genexpr>�sRJR
(R�R�R=R�R�(R
tclasses((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytselectin_polymorphic�s




$cCs5t�}t
|_t|�
f
|_|j|
�

|S(
N(R�R�R#RRRB
(tbase_clsRA
tul((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRB
�s
	
	



N(7R�RdRRyR]R
tbaseRRRRt
interfacesRRRt
path_registryR	R
RRR
RRjRtsqlRRRRRtsql.baseRRRR�tobjectR
R)R"
R
R'
R)
R+
R-
R/
R1
R2
R"R6
R�R7
R9
R:
R?
RB
(((sP/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt<module>
s�






















�����;
?/
]!"
+%
J1$1