JezK
Edit File: strategy_options.pyc
� 1��fc @ 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 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$ � 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 � � Z0 e0 j' d1 � � Z0 e$ � d2 � � Z1 e1 j' d3 � � Z1 e$ � e/ d4 � � Z2 e2 j' d5 � � Z2 e$ � d6 � � Z3 e3 j' d7 � � Z3 e$ � d8 � � Z4 e4 j' d9 � � Z4 e$ � d: � � Z5 e5 j' d; � � Z5 e$ � d< � � Z6 e6 j' d= � � Z6 d> S(? s i ( t util( t QueryableAttribute( t _class_to_mapper( t _is_aliased_class( t _is_mapped_class( t InspectionAttr( t LoaderOption( t MapperProperty( t PropComparator( t _DEFAULT_TOKEN( t _WILDCARD_TOKEN( t PathRegistry( t TokenRegistry( t _orm_full_deannotatei ( t exc( t inspect( t and_( t coercions( t roles( t traversals( t visitors( t _generative( t Generativet Loadc B s� e Z d Z e Z d e j j f d e j j f d e j j f d e j j f d e j j f d e j j f g Z d � Z e d � � Z d � Z d � Z d � Z d � Z e d � � Z d � Z e Z e Z d! Z e Z d! Z d" Z d � Z! d � Z" d � Z# e d! 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 d! d � Z. e e d � Z/ d � Z0 d � Z1 d � Z2 d � Z3 RS(# 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` t patht strategyt _of_typet _extra_criteriat _context_cache_keyt local_optsc C sD t | � } | j | j | _ t j � | _ i | _ t | _ d S( N( R t _post_inspectt _path_registryR R t OrderedDictt contextR t Falset is_class_strategy( t selft entityt insp( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt __init__b s c C s@ | j | � } | | _ i | _ i | _ d | _ d | _ | S( N( ( t __new__R R! R t NoneR R ( t clsR t load( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt for_existing_pathm s c C s | j | � S( N( t _adjust_for_extra_criteria( R$ R! t uncached_opt( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt' _adapt_cached_option_to_uncached_optionw s c C s[ | j s t d � � | j j } | 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. s8 this should only be called if _extra_criteria is present( R t AssertionErrort compile_statet select_statementt queryt _generate_cache_keyt _apply_params_to_elementR ( R$ R! t orig_queryt current_queryt k1t k2( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt _generate_extra_criteriaz s c sC � j j � i } d d g � � � � f d � } | 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 | j s d S� d d k r< � j � � j j � f � (n � \ � � t � � f d � | j D� � | _ d S( Ni c 3 s! | ] } � j � | � Vq d S( N( R5 ( t .0t crit( R8 R9 ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pys <genexpr>� s ( R R) R4 R3 t tuple( t opt( t ckR! R6 ( R8 R9 sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt process� s N( R1 R2 R) t _deep_clone( R$ R! t appliedR@ ( ( R? R! R6 sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR- � s c C s | | k r | | S| j � } | | | <| j | _ | j | j k sN t � | j | j k sf t � | j | j k s~ t � | j r� t j g | j j � D]9 \ } } | t | t � r� | j | | � n | f ^ q� � | _ n | j j | j � | | � | S( N( t _generateR t propagate_to_loadersR0 R# t is_opts_onlyR! R R t itemst isinstanceR RA R t update( R$ RB R@ t clonedt keyt value( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRA � s U c C si g } | j d k r g SxI | j j � D]8 \ \ } } } | d k rM q) n | j | | f � q) W| S( Nt loader( R! R) RF t append( R$ t serializedRJ t loader_patht obj( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR � s " c C s" t t | � j � } i | _ | S( N( t superR RC R ( R$ RI ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRC � s c C s1 | j j s d S| j | | t | j � � d S( N( t compile_optionst _enable_eagerloadst _processt boolt current_path( R$ R1 t mapper_entities( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt' process_compile_state_replaced_entities� s c C sA | j j s d S| j | | j t | j � o9 | j j � d S( N( RR RS RT t _lead_mapper_entitiesRU RV t _for_refresh_state( R$ R1 ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt process_compile_state s c C s� | j j } | j } | r� x� | j j � D]\ \ \ } } } | rS | j rS q+ n | j | | � } | d k r+ | | j | | f <q+ q+ Wn | j j | j � d S( N( RR RZ RV R! RF RD t _chop_pathR) t attributesRH ( R$ R1 RW t raiseerrt is_refreshRV t tokent start_pathRL t chopped_start_path( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRT 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 } t j d � y t | j | � } WnF t k r�} | r�t j t j d | | f � d | �q�d Snl Xy | j } } WnW t k r�} t | t � s�t j t j d | | t | � f � d | �q�� n X| | } nDt | � } | j s"| j rjt j | j | d � sH| r`t j d | | j f � � qgd SqHn�| j r�| } } | | } n�| j! rH| j } } t j | j | d � s,| r%t j d | | j t" | � d k r| j j r| j j rd | d | j j# f n d f � � q,d Sn | j$ rN| j$ rN| j$ | _$ n t | d d � r;| j } t | � } } | d k r�| j% } n | j& | j' | d � } | j st j( | j) j* | j) d t+ d t+ d | d k r�t | � n d �} t | � } n | j& | j, | d | � | | | } | | _ qH| | } n | d k rd| j- | � n | j ry| j& } n | | _ | S( Ns3 Wildcard token cannot be followed by another entitys7 Mapped 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.s3 Can't find property named "%s" on %s in this Query.t replace_contextsN Expected attribute "%s" on %s to be a mapped attribute; instead got %s object.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_entityRG R t sa_exct ArgumentErrort propR t string_typest endswithR R R" RD t is_aliased_classt parentR` R R R% t warn_deprecated_20t getattrt class_t AttributeErrort raise_t propertyR t typet is_mappert orm_utilt$ _entity_corresponds_to_use_path_implt is_propertyt is_attributet lent __name__R R! t entity_patht gett with_polymorphict mappert base_mappert Truet sett _get_strategy( R$ R t attrt for_strategyt wildcard_keyR^ t polymorphic_entity_contextt existing_of_typet default_tokent attr_str_namet entt errt found_propertyt aeR& Rl 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)( R ( 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) R= t sortedRF ( R$ R ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt _coerce_strat� s c C s t d � � d S( NsH Only 'unbound' loader options may be used with the Load.options() method( t NotImplementedError( R$ Rp RB t bound( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt _apply_to_parent� s c G s� i } t | t � } | r+ t d � � n xs | D]k } y | j | | | � Wq2 t k r� } t | t � s� t j t j d | f � d | �q� � q2 Xq2 Wd S( 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` sM The options() method is currently only supported for 'unbound' loader optionssB Loader option %s is not compatible with the Load.options() method.t from_N( RG t _UnboundLoadR� R� Rt R R Ru Rj Rk ( R$ t optst apply_cacheR� R> R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt options� s ! c C sq | j | � } | | _ | j | | d � } | j | _ | j | _ | j | _ t | _ | _ | j | _ d S( Nt relationship( R� RD t _clone_for_bind_strategyR R R R" R# ( R$ R� R RD RI ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt set_relationship_strategy s c C sW | j | � } t | _ x8 | D]0 } | j | | d d | d | �} t | _ q Wd S( Nt columnt opts_onlyR� ( R� R" R# R� R� RD ( R$ t attrsR R� R� R� RI ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt set_column_strategy% s c C sB | j | � } x, | D]$ } | j | | d � } t | _ q Wd S( N( R� R� R) R� RD ( R$ R� R R� RI ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt set_generic_strategy/ s c C sJ | j | � } | j d | d � } t | _ t | _ | j j | � d S( N( R� R� R) R� R# RD R RH ( R$ R R� RI ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt set_class_strategy6 s c C s� | j � } | j | j | | | � | | _ | j | _ | rS | j j | � n | re t | _ n | st | j r� | 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. ( RC R� R R R RH R� RE t _set_path_strategy( R$ R� R R� R� R� RI ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR� > s c C s� | s | rl | j | d � } | rV | ri | j j | j � | j | j 7_ qi q� | j | d | � n\ | j | d � } | j | d | � | r� | j r� | j j | j � | j | j 7_ n d S( NRL ( R� R RH R R� RE ( R$ R! R t replacet merge_optsR� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt _set_for_pathU 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 | _ d S( NR� R� ( R# R Ri Rp t is_tokent generate_for_superclassesR� R! R� RE R) ( R$ t effective_pathR ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR� e s c C s] | j j � } d | d <| d d k rF t j | d d � | d <n | j j � | d <| S( NR R! RL R ( ( RL ( t __dict__t copyR) R t serialize_context_dictR t serialize( R$ t d( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt __getstate__ s c C sP | j j | � t j | j � | _ | j d k rL t j | j � | _ n d S( N( R� RH R t deserializeR R! R) t deserialize_context_dict( 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 enumeratet zipR RG R Rm Rn R R RJ R) R Rx 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( (4 R~ t __module__t __doc__R� t _is_strategy_optionR t ExtendedInternalTraversalt dp_has_cache_keyt dp_plain_objt dp_multit InternalTraversalt dp_clauseelement_listt dp_has_cache_key_tuplest dp_string_multi_dictt _cache_key_traversalR' t classmethodR, R/ R: R- RA Rv R RC R" RE R# R) R RD R R RX R[ RT 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.pyR & sZ ) % ! � 7 R� c B s� e Z d Z d � Z d d � Z e Z d � Z d � Z d 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( 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 C s( d | _ g | _ i | _ d | _ d S( N( ( ( R t _to_bindR R ( R$ ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR' � s c s+ t | � } | j } | � k r/ � | | f S� | } t j } | � � d k r` t � � n | | f | j d | j | � � � d | j f | j r� d t � � � f d � | j D� � f n d | j r� d t � � f d � | j D� � f n d | j r&| j d | j | � � � n d S( sX Inlined 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 R R R� c 3 sC | ]9 } | � k r � j | � r | j � � d � �Vq d S( t _unbound_option_seenN( t addt _gen_cache_key( R; t elem( t anon_mapt bindparamst seen( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pys <genexpr>� s R c 3 s! | ] } | j � � � Vq d S( N( R� ( R; R� ( R� R� ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pys <genexpr> s R N( ( ( ( t idt __class__R t _cache_key_traversal_visitorR) R� t visit_multi_listR R R� R= R R t visit_string_multi_dict( R$ R� R� R� t idselfR* t id_t vis( ( R� R� R� sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR� � s !�'c C s | j j | � d | _ d S( N( R� RM R) ( R$ ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR� s c C s� | | k r | | S| j � } | | | <| j | _ | j | j k sN t � | j | j k sf t � | j | j k s~ t � g | j p� d D] } | j | | � ^ q� | _ | j j | j � | | � | S( N( ( RC R RD R0 R# RE R� RA R RH ( R$ RB R@ RI R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRA s 1 c C s� | | k r | | S| d k r, | j } n | j � } | | | <| j | _ | j r� | j d } t | t j � r� | j t � r� | j d � d d t } n | j | j | j d d !| | j d � n | j | j k s� t � | j | j k s t � | j | j k st � t � } | j | _ g | j D]( } | | k r7| j | � r7| ^ q7g | D]: } | | k ri| j | � ri| j | | | | � ^ qi| j (| j j | j � | S( Ni����R� i ( R) R� RC R R RG R Rm Rn R t splitR R� RD R0 R# RE R� R� R� R RH ( R$ Rp RB R� t to_bindRI R� t uniqR� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR� 5 s6 ' % ?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 | | _ t | d d � | _ | S( Ns %s:%si����i R ( ( RG R Rm R R R" RD R R# R Rr R ( R$ R R� R� R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR� c s c C s9 | j j � } d | d <| j | j d t �| d <| S( NR t filter_aliased_classR ( ( R� R� t _serialize_pathR R� ( R$ R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR� u 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 ( RG R= R} R) Rr t of_typeRM R� ( R$ R� t retRJ R* t propkeyR� Rl ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR� ~ s c C s� | j d } | j j } xu | j D]j } | | k r# | j | � | rX | j rX q# n | j g | D] } | j ^ qe | j | j | � q# q# Wd S( Nt _unbound_load_dedupes( R] RR RZ R� R� RD t _bind_loadert entity_zeroRV ( R$ R1 RW R^ t dedupesR_ t valR� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRT � s c C s� t � } d � } g | D] } | | � D] } | ^ q) q } xH | d d !D]9 } t | _ | rv | | | | � } qL | j | � } qL W| | | d | � } t | _ | S( Nc S sp t | t j � re | t k r% t f S| j d t � rX t j d d d �| d } n | j d � S| f Sd S( 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.t versions 1.4i ( RG R Rm R R t startswitht warn_deprecatedR� ( RJ ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt _split_key� s i i����( R� R� t _is_chain_linkt defaultloadR" ( R* t metht keyst chainedt kwR> R� RJ R` t all_tokens( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt _from_keys� 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 pairsRG R Rm Rn R R RJ R) R Rv t _parententityRx 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 r� | j j n d f � q t | t � r� | j | j j | j d f � q | j | � q W| S( N( RG R R R Ro RM t _parentmapperRs RJ 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| j } n | j | _ | j | _ | j | _ | j | _ | j } | j s�xd t | � D]S \ } } | j | j | | t | � d k r�| j n d d | d | �s�d Sq�Wn | j j | j � | j r| j j r| j j } n | j } | j rgx] | 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)) i s6 mapper option expects string key or list of attributesNi R� R� R� ( R R# R\ R) RG R Rm t _find_entity_basestringR Rv t _find_entity_prop_comparatorR� R R Rj Rk R R! R RE R R� R� R} R RH Ri Rp R� R� R� R� ( R$ t entitiesRV R! R^ Ra R` R% Rl t path_elementRL R t idxR� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR� � st $ " 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 Ry t _entity_corresponds_tot listRj Rk R t clsname_as_plain_nameRw t joinR) ( R$ R Rl R� R^ t searchforR� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR 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; R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pys <genexpr>� s c s s | ] } d | Vq d S( s Load(%s).some_option('*')N( ( R; R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pys <genexpr>� s sJ Query has only expression-based entities - can't find property named "%s".( Rn R R} R Rj Rk R R R" R) ( R$ R R` R^ R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR � s$ N( R~ R� R� R' R) R� R" R� R� RA R� R� R� R� RT R� R� R\ R� R� R R ( ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR� � s" 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:`_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 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( 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 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 rI t | t � s3 t | � } | j } qv t j d d d �n- t | d d � rv t | j � } | j } n | j | i d d 6d t �} | | j d <| 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� s 1.4R t joinedt lazyRD t eager_from_aliasN( R) RG R R t selectableR R� Rr R R� R" R ( t loadoptR� t aliast infot otRI ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt contains_eager� s ' c O s t � j t j | t | � S( N( R� R� R" R� ( R� R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR" 9 s c G sL | j | i t d 6t d 6� } | j d i t d 6t d 6i t d 6� | S( sl 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:`_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 t deferredt instrumentt *t undefer_pks( R� R" R� ( R R� RI ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt load_only@ s &"c G s t � j | � S( N( R� R' ( R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR' o 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:`_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 ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt joinedloadt s X c O s t j t j | t | � S( N( 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 | 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:`_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` t subqueryR ( R� ( R R� ( ( 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( R� 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( s9 Indicate 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` t selectinR ( R� ( R R� ( ( 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( R� 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( 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` t selectR ( R� ( R R� ( ( 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( R� R� R/ R" ( R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR/ 6 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 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 ( ( 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( R� R� R1 R" ( R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR1 U s c C s | j | i d d 6� S( s Indicate 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` t noloadR ( R� ( R R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR2 Z s c G s t j t j | t i � S( N( R� R� R2 R" ( R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR2 u s c C s# | j | i | r d n d d 6� 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_sqlt raiseR ( R� ( R R� t sql_only( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt raiseloadz s 'c O s t j t j | t | � S( N( R� R� R6 R" ( R� R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR6 � s c C s | 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� ( ( 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( R� R� R� R" ( R� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR� � s c C s: i t d 6t d 6} | 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 RJ R6 R ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt defer� s E c O s< | r t j d d d �n t j t j | 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� s 1.3( R R� R� R� R7 R" ( RJ t addl_attrsR� ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR7 s c C s! | j | f i t d 6t d 6� S( sg 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:`_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 ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt undefer. s ,c G s< | r t j d d 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� s 1.3( R R� R� R� R9 R" ( RJ R8 ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR9 _ 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) R� ( R R ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt undefer_groupm s c C s t � j | � S( N( R� R: ( R ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR: � s c C sB t j t j t | � � } | j | f i t d 6d i | d 6�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` t query_expressionR� t expression( R t expectR t LabeledColumnExprRoleR R� R� ( R RJ R< ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt with_expression� s (c C s# t j t j | f t i | d 6� S( NR< ( R� R� R? R" ( RJ R< ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyR? � 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:`polymorphic_selectin` t selectinload_polymorphicR� 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 RJ R ( R� R� R= R� R� ( R t classes( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt selectin_polymorphic� s $c C s5 t � } t | _ t | � f | _ | j | � | S( N( R� R� R# R R RB ( t base_clsRA t ul( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyRB � s N(7 R� Rd R Ry R] R t baseR R R R t interfacesR R R t path_registryR R R R R R Rj R t sqlR R R R R t sql.baseR R R R� t objectR R) R" R R' R) R+ R- R/ R1 R2 R" R6 R� R7 R9 R: R? RB ( ( ( sR /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyt <module> s� � � �� � ;?/]!"+%J1$1