Why Gemfury? Push, build, and install  RubyGems npm packages Python packages Maven artifacts PHP packages Go Modules Debian packages RPM packages NuGet packages

trilio-internal / idna python

Repository URL to install this package:

Version: 
2.5  ▾
Details    
idna / lib / python2.7 / site-packages / sqlalchemy / orm / strategy_options.pyc
Size: Mime: 
ó
‹EYc@s±dZddlmZmZddlmZddlmZmZddlm	Z
mZddlm
Z
mZddlmZddlmZmZmZmZd	eefd
„ƒYZdefd„ƒYZd
efd„ƒYZeƒd(d„ƒZejd„ƒZeƒd„ƒZejd„ƒZeƒd(d„ƒZejd„ƒZejd„ƒZeƒd„ƒZ e jd„ƒZ e jd„ƒZ!eƒd„ƒZ"e"jd„ƒZ"e"jd„ƒZ#eƒd„ƒZ$e$jd„ƒZ$eƒd„ƒZ%e%jd„ƒZ%eƒd „ƒZ&e&jd!„ƒZ&eƒd"„ƒZ'e'jd#„ƒZ'eƒd$„ƒZ(e(jd%„ƒZ(eƒd&„ƒZ)e)jd'„ƒZ)d(S()s

i(tMapperOptiontPropComparatori(tutil(t_generativet
Generative(texctinspect(t_is_aliased_classt_class_to_mapper(tPathRegistryt
TokenRegistryt_WILDCARD_TOKENt_DEFAULT_TOKENtLoadcBs³eZdZd„Zd„ZeZdZeZ	d„Z
d„Zd„Ze
d„Zd„Zd„Zee
d	„ƒZedd
„ƒZd„Zd„Zd
„Zd„ZRS(sC
Represents loader options which modify the state of a
    :class:`.Query` in order to affect how various mapped attributes are
    loaded.

    .. versionadded:: 0.9.0 The :meth:`.Load` system is a new foundation for
       the existing system of loader options, including options such as
       :func:`.orm.joinedload`, :func:`.orm.defer`, and others.   In
       particular, it introduces a new method-chained system that replaces the
       need for dot-separated paths as well as "_all()" options such as
       :func:`.orm.joinedload_all`.

    A :class:`.Load` object can be used directly or indirectly.  To use one
    directly, instantiate given the parent class.  This style of usage is
    useful when dealing with a :class:`.Query` that has multiple entities,
    or when producing a loader option that can be applied generically to
    any style of query::

        myopt = Load(MyClass).joinedload("widgets")

    The above ``myopt`` can now be used with :meth:`.Query.options`::

        session.query(MyClass).options(myopt)

    The :class:`.Load` construct is invoked indirectly whenever one makes use
    of the various loader options that are present in ``sqlalchemy.orm``,
    including options such as :func:`.orm.joinedload`, :func:`.orm.defer`,
    :func:`.orm.subqueryload`, and all the rest.  These constructs produce an
    "anonymous" form of the :class:`.Load` object which tracks attributes and
    options, but is not linked to a parent class until it is associated with a
    parent :class:`.Query`::

        # produce "unbound" Load object
        myopt = joinedload("widgets")

        # when applied using options(), the option is "bound" to the
        # class observed in the given query, e.g. MyClass
        session.query(MyClass).options(myopt)

    Whether the direct or indirect style is used, the :class:`.Load` object
    returned now represents a specific "path" along the entities of a
    :class:`.Query`.  This path can be traversed using a standard
    method-chaining approach.  Supposing a class hierarchy such as ``User``,
    ``User.addresses -> Address``, ``User.orders -> Order`` and
    ``Order.items -> Item``, we can specify a variety of loader options along
    each element in the "path"::

        session.query(User).options(
                    joinedload("addresses"),
                    subqueryload("orders").joinedload("items")
                )

    Where above, the ``addresses`` collection will be joined-loaded, the
    ``orders`` collection will be subquery-loaded, and within that subquery
    load the ``items`` collection will be joined-loaded.


    cCs.t|ƒ}|j|_i|_i|_dS(N(Rt_path_registrytpathtcontextt
local_opts(tselftentitytinsp((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt__init__Ps	cCs"tt|ƒjƒ}i|_|S(N(tsuperR
t	_generateR(Rtcloned((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRVs	cCs|j|tƒdS(N(t_processtTrue(Rtquery((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt
process_query_scCs|j|tƒdS(N(RtFalse(RR((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytprocess_query_conditionallybscCsƒ|j}|rlxm|jjƒD]F\\}}}|j||ƒ}|dk	r||j||f<qqWn|jj|jƒdS(N(t
_current_pathRtitemst
_chop_pathtNonet_attributestupdate(RRtraiseerrtcurrent_pathttokent
start_pathtloadertchopped_start_path((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRes	"c	CsY|rY|jrYt|tƒr1tjdƒ‚qYtjd|jj|jjfƒ‚nt|t	j
ƒr3|jtƒ}|jt
ƒs|rÇ|r¡t|_n|rºd||f}n|j|ƒSyt|jj|ƒ}Wn:tk
r|rtjd||jfƒ‚q&dSn
X|j}||}n
|j}|jj|jƒs}|rvtjd||jfƒ‚q}dSnt|ddƒr6|j}t|ƒ}|j}	|j|j|jdƒ}
|jstj|jj |jdt!d	t!d
|
ƒ}n|j|j"|jdt|ƒƒ|||	}n
||}|jrU|j}n|S(Ns3Wildcard token cannot be followed by another entitys?Attribute '%s' of entity '%s' does not refer to a mapped entitys%s:%ssFCan't find property named '%s' on the mapped entity %s in this Query. s.Attribute '%s' does not link from element '%s't_of_typetpath_with_polymorphictaliasedt_use_mapper_patht_existing_alias(#t
has_entityt
isinstanceR
tsa_exct
ArgumentErrortproptkeytparentRRtstring_typestendswithRRRtpropagate_to_loadersR'tgetattrtclass_tAttributeErrorR"tpropertyt
common_parenttmapperR+Rtentity_pathtgetRtis_aliased_classtorm_utiltwith_polymorphictbase_mapperRtset(RRtattrtwildcard_keyR%t
default_tokenR4tactext_infotpath_elementtexisting((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt_generate_pathosf

	
			
		

	cCsd|jfS(NsLoad(strategy=%r)(tstrategy(R((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt__str__·scCs+|dk	r'tt|jƒƒƒ}n|S(N(R"ttupletsortedR (RRO((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt
_coerce_stratºscCsY|j|ƒ}||_|j|j|dƒ|_||_|dk	rU|jƒndS(Ntrelationship(RSR9RNRROR"t_set_path_strategy(RRGROR9((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytset_relationship_strategy¿s		cCs†|j|ƒ}xp|D]h}|j|j|dƒ}|jƒ}||_||_t|_|rt|jj|ƒn|j	ƒqWdS(Ntcolumn(
RSRNRRRORR9RR$RU(RtattrsROtoptsRGRR((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytset_column_strategyËs
			cCs¡|jrY|jj|jdƒ}|r=|jj|jƒq|jj|jd|ƒnD|jjr„|jjj|jd|ƒn|jj|jd|ƒdS(NR)(	t_merge_into_pathRRARRR$RFR0R6(RRM((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRUÙs	cCs&|jjƒ}|jjƒ|d<|S(NR(t__dict__tcopyRt	serialize(Rtd((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt__getstate__çscCs)|jj|ƒtj|jƒ|_dS(N(R\R$R	tdeserializeR(Rtstate((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt__setstate__ìscCsµd}x tt||jƒƒD]†\}\}}t|tjƒr|dkrf|jdtƒrf|S|dtfkr||j	krdSn||kr¡qqdSqW||dS(Niÿÿÿÿit:srelationship:%si(t	enumeratetzipRR1RR7R8RRR5R"(Rtto_chopRtitc_tokentp_token((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR!ðs+N(t__name__t
__module__t__doc__RRRR[R"ROR9RRRRRNRPRSRRVRZRUR`RcR!(((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR
s(9					
H		

			t_UnboundLoadcBs}eZdZd„ZeZd„Zd„Zd„Zd„Z	d„Z
ed„ƒZd„Z
d	„Zd
„Zd„ZRS(s2Represent 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')``.

    cCs"d|_tƒ|_i|_dS(N((RRFt_to_bindR(R((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRs	cCs|jj|ƒdS(N(Rotadd(R((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRUscCs`|rUt|tjƒrU|ttfkrU|tkrBt|_nd||f}n||fS(Ns%s:%s(R1RR7RRRR9(RRRGRH((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRNscCsy|jjƒ}g|d<}xUtj|jƒD]A}t|tƒrd|j|jj	|j
fƒq0|j|ƒq0W|S(NR(R\R]Rtto_listRR1Rtappendt
_parentmapperR;R5(RR_tretR'((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR`#scCsyg}xS|dD]G}t|tƒrK|\}}|jt||ƒƒq|j|ƒqWt|ƒ|d<||_dS(NR(R1RQRrR:R\(RRbRtR5tclstpropkey((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRc-scCs.x'|jD]}|j||j|ƒq
WdS(N(Rot_bind_loaderR#(RRR%tval((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR8sc
Cs¬tƒ}d„}g|D]}||ƒD]}|^q)q}	xH|	dd!D]9}|rm||||}n|j|ƒ}t|_qLW|||	d|}t|_|S(NcSs]t|tjƒrR|tkr%tfS|jdtƒrE|d}n|jdƒS|fSdS(Nt.i(R1RR7RRt
startswithtsplit(R5((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt
_split_key@s

iiÿÿÿÿ(RntdefaultloadRt_is_chain_linkR(
RtmethtkeystchainedtkwtoptR|R5R't
all_tokens((sT/home/tvault/.virtenv/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|dtfkr½||j	kr½dSq"t|tƒr"|j|k	r½dSq"q"W|d7}||S(NiÿÿÿÿiRdsrelationship:%si(
ReRftpairsR1RR7R8RRR5R"RR=(RRgRRhRitp_mappertp_prop((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR!Ys.
cCsR|j}|j}|r-|j||ƒ}n|s7dS|d}t|tjƒrk|j|||ƒ}nHt|tƒr¤|j	}|j
||j|j|ƒ}nt
jdƒ‚|s½dS|j}	t|	ƒ}
||
_|j|
_|
j}x@|D]8}|
j|
j|d|ƒ|
_}|dkr÷dSq÷W|
jj|jƒ|
jjra|
jj}n	|
j}|jrxØ|jƒD]…}|jrÓ|j|dƒ}
|
r½|
jj|jƒq|j|d|
ƒq€|jrò|j|d|
ƒq€|j|d|
ƒq€WnB|jst‚|jr;|j|d|
ƒn|j|d|
ƒdS(Nis6mapper option expects string key or list of attributesR)( RRR!R"R1RR7t_find_entity_basestringRR=t_find_entity_prop_comparatorR5t
_parententityR2R3tentity_zeroR
RRORNRR$R0R6tis_tokentgenerate_for_superclassesR[RARFR~t
setdefaulttAssertionError(RRRR%R(R&R'RR4RLR)Rteffective_pathRM((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRwks`		
					
					cCs°t|ƒr|}nt|ƒ}xˆ|jD]}|j|ƒr+|Sq+W|r¨t|jƒsvtjd|fƒ‚q¬tjd|djd„|jDƒƒfƒ‚ndSdS(NsJQuery has only expression-based entities - can't find property named '%s'.s†Can't find property '%s' on any entity specified in this Query.  Note the full path from root (%s) to target entity must be specified.t,css|]}t|ƒVqdS(N(tstr(t.0tx((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pys	<genexpr>Ïs(	RRt_mapper_entitiestcorresponds_totlistR2R3tjoinR"(RRR'R?R%t	searchfortent((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRŠºs 	cCs |jdtƒrLtt|jƒƒdkrd|rItjdƒ‚qIqdn|jtƒrdt}nx5|jD]}|SW|r˜tjd|fƒ‚ndSdS(NRdisfWildcard loader can only be used with exactly one entity.  Use Load(ent) to specify specific entities.sJQuery has only expression-based entities - can't find property named '%s'.(
R8RtlenR˜R–R2R3RRR"(RRR'R%R›((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR‰Õs	(RkRlRmRRR~RURNR`RcRtclassmethodR…R!RwRŠR‰(((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRns						
				O	t
loader_optioncBs,eZd„Zd„Zd„Zd„ZRS(cCsdS(N((R((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRñscCsO|j|_}||_tt|ƒr;td|ƒ‚ntt||ƒ|S(Ns#Load class already has a %s method.(RktnametfnthasattrR
t	TypeErrortsetattr(RR RŸ((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt__call__ôs	cCs<||_|jj}di|jd6|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 RmRŸ(RR tfn_doc((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt_add_unbound_fnýs
		cCs$||_di|jd6|_|S(Ns
Produce a standalone "all" option for :func:`.orm.%(name)s`.

.. deprecated:: 0.9.0

    The "_all()" style is replaced by method chaining, e.g.::

        session.query(MyClass).options(
            %(name)s("someattribute").%(name)s("anotherattribute")
        )

RŸ(t_unbound_all_fnRŸRm(RR ((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt_add_unbound_all_fn
s	(RkRlRR¤R§R©(((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRžðs				
cCsf|dk	r6t|tƒs6t|ƒ}|j}q6n|j|idd6dtƒ}||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:`.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))

    .. seealso::

        :ref:`contains_eager`

    tjoinedtlazyR9teager_from_aliasN(R"R1R“Rt
selectableRVRR(tloadoptRGtaliastinfoR((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytcontains_eagers"
	
cOstƒjtj|t|ƒS(N(RnR…R±R(R€R‚((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR±Js	cGsL|j|itd6td6ƒ}|jditd6td6itd6ƒ|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

    tdeferredt
instrumentt*tundefer_pks(RZRR(R®RXR((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt	load_onlyPs"	cGstƒj|ŒS(N(RnR¶(RX((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR¶|scCs9|j|idd6ƒ}|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:`.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
     SQLite, 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 will prevent joins from being right-nested, and will instead
     link an "innerjoin" eagerload to an "outerjoin" eagerload by bypassing
     the "inner" join.   Using this form as follows::

        query(A).options(
            joinedload(A.bs, innerjoin=False).
                joinedload(B.cs, innerjoin="unnested")
        )

     Joins will be rendered as "a LEFT OUTER JOIN b LEFT OUTER JOIN c", so that
     all of "a" is matched rather than being incorrectly limited by a "b" that
     does not contain a "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.

     .. versionadded:: 0.9.4 Added support for "nesting" of eager "inner"
        joins.  See :ref:`feature_2976`.

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

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

        :func:`.orm.subqueryload`

        :func:`.orm.lazyload`

        :paramref:`.relationship.lazy`

        :paramref:`.relationship.innerjoin` - :func:`.relationship`-level
        version of the :paramref:`.joinedload.innerjoin` option.

    RªR«t	innerjoinN(RVR"R(R®RGR·R)((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt
joinedloads_cOstjtj|t|ƒS(N(RnR…R¸R(R€R‚((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR¸æscOstjtj|t|ƒS(N(RnR…R¸R(R€R‚((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytjoinedload_allìscCs|j|idd6ƒS(sAIndicate 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`

        :func:`.orm.joinedload`

        :func:`.orm.lazyload`

        :paramref:`.relationship.lazy`

    tsubqueryR«(RV(R®RG((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytsubqueryloadòs cGstjtj|tiƒS(N(RnR…R»R(R€((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR»scGstjtj|tiƒS(N(RnR…R»R(R€((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytsubqueryload_allscCs|j|idd6ƒS(sIndicate 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::

        :paramref:`.relationship.lazy`

    tselectR«(RV(R®RG((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytlazyloads
cGstjtj|tiƒS(N(RnR…R¾R(R€((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR¾/scGstjtj|tiƒS(N(RnR…R¾R(R€((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytlazyload_all4scCs|j|idd6ƒ}|S(sIndicate that the given attribute should be loaded using
    an immediate load with a per-attribute SELECT statement.

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

    .. seealso::

        :ref:`loading_toplevel`

        :func:`.orm.joinedload`

        :func:`.orm.lazyload`

        :paramref:`.relationship.lazy`

    t	immediateR«(RV(R®RGR)((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt
immediateload9scGstjtj|tiƒS(N(RnR…RÁR(R€((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRÁPscCs|j|idd6ƒS(sEIndicate 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`.

    tnoloadR«(RV(R®RG((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRÂVscGstjtj|tiƒS(N(RnR…RÂR(R€((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRÂescCs|j|dƒS(s"Indicate an attribute should load using its default loader style.

    This method is used to link to other loader options, such as
    to set the :func:`.orm.defer` option on a class that is linked to
    a relationship of the parent class being loaded, :func:`.orm.defaultload`
    can be used to navigate this path without changing the loading style
    of the relationship::

        session.query(MyClass).options(defaultload("someattr").defer("some_column"))

    .. seealso::

        :func:`.orm.defer`

        :func:`.orm.undefer`

    N(RVR"(R®RG((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR}jscGstjtj|tiƒS(N(RnR…R}R(R€((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR}ƒscCs!|j|fitd6td6ƒ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:`.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: Deprecated; 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.

    .. seealso::

        :ref:`deferred`

        :func:`.orm.undefer`

    R²R³(RZR(R®R5((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytdeferˆs4cGs tjtj|f|tiƒS(N(RnR…RÃR(R5t
addl_attrs((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRÃÂscCs!|j|fitd6td6ƒS(sí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("*"))

    :param key: Attribute to be undeferred.

    :param \*addl_attrs: Deprecated; 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.

    .. seealso::

        :ref:`deferred`

        :func:`.orm.defer`

        :func:`.orm.undefer_group`

    R²R³(RZRR(R®R5((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytundeferÈs#cGs tjtj|f|tiƒS(N(RnR…RÅR(R5RÄ((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRÅñscCs't|_|jdditd|6ƒ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
       particiular entity load path.

    .. seealso::

        :ref:`deferred`

        :func:`.orm.defer`

        :func:`.orm.undefer`

    R´sundefer_group_%sN(RR[RZR"(R®RŸ((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt
undefer_group÷s
	cCstƒj|ƒS(N(RnRÆ(RŸ((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRÆsN(*Rmt
interfacesRRtRtsql.baseRRRR2RtbaseRRRCt
path_registryR	R
RRR
RntobjectRžR"R±R§R¶R¸R©R¹R»R¼R¾R¿RÁRÂR}RÃRÅRÆ(((sT/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt<module>	sJ"ðë*/,d#:)'

Products

About

Resources

Contact Gemfury