H`Tc@sdZddlmZmZddlmZddlmZmZddlm Z m Z ddl m Z mZddlmZddlmZmZmZmZd eefd YZd efd YZd efdYZed(dZejdZedZejdZed(dZejdZejdZedZ e jdZ e jdZ!edZ"e"jdZ"e"jdZ#edZ$e$jdZ$edZ%e%jdZ%ed Z&e&jd!Z&ed"Z'e'jd#Z'ed$Z(e(jd%Z(ed&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_TOKENtLoadcBseZdZdZdZdZeZdZ dZ dZ e dZ dZee dZedd 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((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt__init__Qs   cCs"tt|j}i|_|S(N(tsuperR t _generateR(Rtcloned((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRWs cCs|j|tdS(N(t_processtTrue(Rtquery((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt process_query_scCs|j|tdS(N(RtFalse(RR((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytprocess_query_conditionallybscCs|j}|rlxm|jjD]F\\}}}|j||}|dk r||j||fs( RRt_mapper_entitiestcorresponds_totlistR1R2tjoinR"(RRR'R>R%t searchfortent((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRs    cCs|jdtrLtt|jdkrd|rItjdqIqdn|jtrdt}nx5|jD]}|SW|rtjd|fndSdS(NR_isfWildcard 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'.( R7R tlenRRR1R2R RR"(RRR'R%R((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRs (RfRgRhRRRyRQRKR[R^Rt classmethodRR!RrRR(((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRis      = t loader_optioncBs,eZdZdZdZdZRS(cCsdS(N((R((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRscCsO|j|_}||_tt|r;td|ntt|||S(Ns#Load class already has a %s method.(RftnametfnthasattrR t TypeErrortsetattr(RRR((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt__call__s  cCs<||_|jj}di|jd6|j_||_|S(NsProduce a new :class:`.Load` object with the :func:`.orm.%(name)s` option applied. See :func:`.orm.%(name)s` for usage examples. R(t _unbound_fnRRhR(RRtfn_doc((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt_add_unbound_fns    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_fnRRh(RR((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt_add_unbound_all_fns (RfRgRRRR(((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRs  cCsf|dk r6t|ts6t|}|j}q6n|j|idd6dt}||jd<|S(sIndicate 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` tjoinedtlazyR8teager_from_aliasN(R"R0RRt selectableRRRR(tloadoptREtaliastinfoR((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pytcontains_eagers"     cOstjtj|t|S(N(RiRRR(R{R}((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR*s cGsL|j|itd6td6}|jditd6td6itd6|S(sIndicate 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("addreses").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*t undefer_pks(RVRR(RRTR((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt load_only0s" cGstj|S(N(RiR(RT((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR\scCs9|j|idd6}|dk r5||jd sJ"*/,D#:)&