Current File : //opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyo
�
��4]c @ s� d Z d d l Z d d l 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 e j e � Z d e f d � � YZ d
e f d � � YZ d e f d � � YZ e j d d � d � � Z e j d d � d � � Z e j � d � � Z e j e j d d � d � � � Z e j e j d d � d � � � Z e j! Z e j" Z e j# Z# d S( s� Baked query extension.
Provides a creational pattern for the :class:`.query.Query` object which
allows the fully constructed object, Core select statement, and string
compiled result to be fully cached.
i����Ni ( t exc( t util( t strategy_options( t Query( t Session( t func( t literal_columnt Bakeryc B s& e Z d Z d Z d � Z d � Z RS( s� Callable which returns a :class:`.BakedQuery`.
This object is returned by the class method
:meth:`.BakedQuery.bakery`. It exists as an object
so that the "cache" can be easily inspected.
.. versionadded:: 1.2
t clst cachec C s | | _ | | _ d S( N( R R ( t selft cls_R ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyt __init__/ s c G s | j | j | | � S( N( R R ( R
t
initial_fnt args( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyt __call__3 s ( R R ( t __name__t
__module__t __doc__t __slots__R R ( ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyR ! s
t
BakedQueryc B s� e Z d Z d Z d d � Z e d d d � � Z d � Z d d � Z d
� Z
d � Z d � Z d
� Z
d � Z d � Z e d � Z d � Z d d � Z d d � Z d � Z d � Z d � Z d � Z d � Z d � Z RS( s3 A builder object for :class:`.query.Query` objects.t stepst _bakeryt
_cache_keyt _spoiledc C s; d | _ | j | | � | g | _ t | _ | | _ d S( N( ( R t _update_cache_keyR t FalseR R ( R
t bakeryR
R ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyR < s
i� c C s t | t j | d | �� S( sS Construct a new bakery.
:return: an instance of :class:`.Bakery`
t
size_alert( R R t LRUCache( R t sizet _size_alert( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyR C s c C sI t j t � } | j | _ t | j � | _ | j | _ | j | _ | S( N( R t __new__R t listR R R ( R
t b1( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyt _cloneM s c C s | j | j f | 7_ d S( N( R t __code__( R
t fnR ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyR U s c C s0 t | t � r | j | � n
| j | � | S( N( t
isinstancet tuplet add_criteria( R
t other( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyt __iadd__X s
c C s- t | t � r | j | � S| j | � Sd S( N( R& R' t
with_criteria( R
R) ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyt __add___ s
c G s$ | j | | � | j j | � | S( s� Add a criteria function to this :class:`.BakedQuery`.
This is equivalent to using the ``+=`` operator to
modify a :class:`.BakedQuery` in-place.
( R R t append( R
R% R ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyR( e s c G s | j � j | | � S( s� Add a criteria function to a :class:`.BakedQuery` cloned from this one.
This is equivalent to using the ``+`` operator to
produce a new :class:`.BakedQuery` with modifications.
( R# R( ( R
R% R ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyR+ p s c C s
t | | � S( s� Return a :class:`.Result` object for this :class:`.BakedQuery`.
This is equivalent to calling the :class:`.BakedQuery` as a
Python callable, e.g. ``result = my_baked_query(session)``.
( t Result( R
t session( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyt for_sessiony s c C s
| j | � S( N( R0 ( R
R/ ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyR � s c C sK | r> | j r> | j � } | j d 7_ | j g | _ n t | _ | S( sz Cancel any query caching that will occur on this BakedQuery object.
The BakedQuery can continue to be used normally, however additional
creational functions will not be cached; they will be called
on every invocation.
This is to support the case where a particular step in constructing
a baked query disqualifies the query from being cacheable, such
as a variant that relies upon some uncacheable value.
:param full: if False, only functions added to this
:class:`.BakedQuery` object subsequent to the spoil step will be
non-cached; the state of the :class:`.BakedQuery` up until
this point will be pulled from the cache. If True, then the
entire :class:`.Query` object is built from scratch each
time, with all creational functions being called on each
invocation.
t _query_only( R1 ( R R# R t _retrieve_baked_queryR t True( R
t fullt _spoil_point( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyt spoil� s c C s | j | j f S( s� Return the key that actually goes into the cache dictionary for
this :class:`.BakedQuery`, taking into account the given
:class:`.Session`.
This basically means we also will include the session's query_class,
as the actual :class:`.Query` object is part of what's cached
and needs to match the type of :class:`.Query` that a later
session will want to use.
( R t
_query_cls( R
R/ ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyt _effective_key� s c C s& | j � } | j | | d | �| S( s2 Cloning version of _add_lazyload_options.
t
cache_path( R# t _add_lazyload_options( R
t optionst effective_pathR9 t q( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyt _with_lazyload_options� s c s� d } | s � } n | j d j r2 | j � nR xO � D]G } | j | � } | t k rg | j � q9 | d k r9 | | 7} q9 q9 W| j � � f d � | j | � d S( s* Used by per-state lazy loaders to add options to the
"lazy load" query from a parent query.
Creates a cache key based on given load path and query options;
if a repeatable cache key cannot be generated, the query is
"spoiled" so that it won't use caching.
i c s | j � � j � � S( N( t _with_current_patht _conditional_options( R= ( R< R; ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyt <lambda>� s N( ( t patht is_aliased_classR6 t _generate_cache_keyR t NoneR( ( R
R; R< R9 t keyt optt cache_key( ( R< R; sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyR: � s
c C sh | j j | j | � d � } | d k r[ | j | � } | j d � | j | j | � <n | j | � S( N( R t getR8 RE t _as_queryt with_session( R
R/ t query( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyR2 � s c C s� | j | � } | j � } | j | | � d | _ | j j d � | _ } | j j i | j d 6� | _ x! d D] } | j
j | d � qs W| | j | j | � <| S( Nt compiled_cachet
_correlatet _from_objt _mapper_adapter_mapt _joinpatht
_joinpoint( RN RO RP RQ RR (
RJ t _compile_contextt _bake_subquery_loadersRE R/ RL RK t _execution_optionst unionR t __dict__t popR8 ( R
R/ RL t contextt attr( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyt _bake� s
c C st t | t � r | } nO t | t � rQ | j } | d k rg t j d � � qg n t d t | � � � | j | � S( s# Return the :class:`.Query` object for use as a subquery.
This method should be used within the lambda callable being used
to generate a step of an enclosing :class:`.BakedQuery`. The
parameter should normally be the :class:`.Query` object that
is passed to the lambda::
sub_bq = self.bakery(lambda s: s.query(User.name))
sub_bq += lambda q: q.filter(
User.id == Address.user_id).correlate(Address)
main_bq = self.bakery(lambda s: s.query(Address))
main_bq += lambda q: q.filter(
sub_bq.to_query(q).exists())
In the case where the subquery is used in the first callable against
a :class:`.Session`, the :class:`.Session` is also accepted::
sub_bq = self.bakery(lambda s: s.query(User.name))
sub_bq += lambda q: q.filter(
User.id == Address.user_id).correlate(Address)
main_bq = self.bakery(
lambda s: s.query(Address.id, sub_bq.to_query(q).as_scalar())
)
:param query_or_session: a :class:`.Query` object or a class
:class:`.Session` object, that is assumed to be within the context
of an enclosing :class:`.BakedQuery` callable.
.. versionadded:: 1.3
s1 Given Query needs to be associated with a Sessions) Query or Session object expected, got %r.N(
R& R R R/ RE t sa_exct
ArgumentErrort TypeErrort typeRJ ( R
t query_or_sessionR/ ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyt to_query� s % c C s; | j d | � } x! | j d D] } | | � } q! W| S( Ni i ( R ( R
R/ RL t step( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyRJ , s c s� g | j d <} x� t | j j � � D]� \ } � t � t � r' d | k r� t | j � f d � � } | j | | _ | j | � | j | | j � f � n | j | =q' q' Wd S( sb convert subquery eager loaders in the cache into baked queries.
For subquery eager loading to work, all we need here is that the
Query point to the correct session when it is run. However, since
we are "baking" anyway, we may as well also turn the query into
a "baked" query so that we save on performance too.
t
baked_queriest subqueryc s � S( N( ( R ( t v( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyRA @ t N(
t
attributesR! t itemsR& R R R R R[ R- ( R
R/ RY Rc t kt bk( ( Re sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyRT 3 s "
c C s� x� | j d D]u \ } } } t | j | d � � } | | _ | j | � } x | D] }
| j |
� } qT W| j | � | j | <q Wd S( s� Retrieve subquery eager loaders stored by _bake_subquery_loaders
and turn them back into Result objects that will iterate just
like a Query object.
Rc c S s
| j | � S( N( RK ( t sessR= ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyRA P Rf N( Rg R R R R0 t with_post_criteriat params( R
R/ RY Rm t
post_criteriaRi RH RL Rj R= R% ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyt _unbake_subquery_loadersF s
( R R R R ( N( ( R R R R R t classmethodRE R R# R R* R, R( R+ R0 R R R6 R8 R> R: R2 R[ Ra RJ RT Ro ( ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyR 7 s.
# 4 R. c B s� e Z d Z d Z d � Z d � Z d � Z d � Z d � Z d
� Z d � Z
d � Z d
� Z d � Z
d � Z d � Z d � Z d � Z d � Z RS( s Invokes a :class:`.BakedQuery` against a :class:`.Session`.
The :class:`.Result` object is where the actual :class:`.query.Query`
object gets created, or retrieved from the cache,
against a target :class:`.Session`, and is then invoked for results.
t bqR/ t _paramst _post_criteriac C s( | | _ | | _ i | _ g | _ d S( N( Rq R/ Rr Rs ( R
Rq R/ ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyR d s c O s^ t | � d k r& | j | d � n$ t | � d k rJ t j d � � n | j j | � | S( s@ Specify parameters to be replaced into the string SQL statement.i i sF params() takes zero or one positional argument, which is a dictionary.( t lent updateR\ R] Rr ( R
R t kw( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyRm j s c C s | r | j j | � n | S( N( Rs t extend( R
t fns( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyt _using_post_criteriaw s c C s | j | g � S( s Add a criteria function that will be applied post-cache.
This adds a function that will be run against the
:class:`.Query` object after it is retrieved from the
cache. Functions here can be used to alter the query in ways
that **do not affect the SQL output**, such as execution options
and shard identifiers (when using a shard-enabled query object)
.. warning:: :meth:`.Result.with_post_criteria` functions are applied
to the :class:`.Query` object **after** the query's SQL statement
object has been retrieved from the cache. Any operations here
which intend to modify the SQL should ensure that
:meth:`.BakedQuery.spoil` was called first.
.. versionadded:: 1.2
( Ry ( R
R% ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyRl | s c C sE | j j | j � j | j � } x | j D] } | | � } q+ W| S( N( Rq RJ R/ Rm Rr Rs ( R
R= R% ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyRJ � s !c C s t | j � � S( N( t strRJ ( R
( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyt __str__� s c C s: | j } | j j s | j r/ t | j � � S| j j | j | j � d � } | d k rq | j
| j � } n t j | � } | j | _ | j j � | _ | j
| j | | j | j � t | j _ | j r� | j r� | j j � n | j j | j � j | j � } x | j D] } | | � } qW| j | � S( N( Rq R/ t enable_baked_queriesR t iterRJ R RI R8 RE R[ t copyRg Ro Rr Rs R3 t statementt
use_labelst autoflusht populate_existingt
_autoflushRL Rm RK t _execute_and_instances( R
Rq t
baked_contextRY R= R% ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyt __iter__� s$ ! !c sR t j t d � � � | j j � f d � � } | j | j � j | j � j � S( s� return the 'count'.
Equivalent to :meth:`.Query.count`.
Note this uses a subquery to ensure an accurate count regardless
of the structure of the original statement.
.. versionadded:: 1.1.6
t *c s
| j � � S( N( t from_self( R= ( t col( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyRA � Rf (
R t countR Rq R+ R0 R/ Rm Rr t scalar( R
Rq ( ( R� sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyR� � s c C sG y+ | j � } t | t � s" | S| d SWn t j k
rB d SXd S( s� Return the first element of the first result or None
if no rows present. If multiple rows are returned,
raises MultipleResultsFound.
Equivalent to :meth:`.Query.scalar`.
.. versionadded:: 1.1.6
i N( t oneR& R' t orm_exct
NoResultFoundRE ( R
t ret( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyR� � s
c C sg | j j d � � } t | j | j � j | j � j | j � � } t | � d k r_ | d Sd Sd S( sL Return the first row.
Equivalent to :meth:`.Query.first`.
c S s | j d d � S( Ni i ( t slice( R= ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyRA � Rf i N( Rq R+ R! R0 R/ Rm Rr Ry Rs Rt RE ( R
Rq R� ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyt first� s c C s\ y | j � } Wn# t j k
r5 t j d � � n# X| d k rT t j d � � n | Sd S( se Return exactly one result or raise an exception.
Equivalent to :meth:`.Query.one`.
s" Multiple rows were found for one()s No row was found for one()N( t one_or_noneR� t MultipleResultsFoundRE R� ( R
R� ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyR� � s
c C sO t | � } t | � } | d k r, | d S| d k r< d St j d � � d S( s� Return one or zero results, or raise an exception for multiple
rows.
Equivalent to :meth:`.Query.one_or_none`.
.. versionadded:: 1.0.9
i i s* Multiple rows were found for one_or_none()N( R! Rt RE R� R� ( R
R� t l( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyR� � s c C s
t | � S( sE Return all rows.
Equivalent to :meth:`.Query.all`.
( R! ( R
( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyt all
s c C s, | j j d | j � } | j | | j � S( sZ Retrieve an object based on identity.
Equivalent to :meth:`.Query.get`.
i ( Rq R R/ t _get_implt _load_on_pk_identity( R
t identRL ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyRI s c
s | j � � � j \ � � � � � � � f d � } � j } | j � } | j � f 7_ | j | t d � � D� � � } t g t � � j � D] \ } } � | j
| f ^ q� � } t | j � j
� j | � � } t | � } | d k rt j � � n | r| d Sd Sd S( s6 Load the given primary key identity from the database.c s� � } | j � } | j � d | _ d � k r� t g t � j � � D]% \ } } | d k rG � | j ^ qG � } t j | | � } n | j
| t t � } | | _
x � j D] } | | � } q� W| S( N( R# t _get_conditionRE t _order_byt sett zipt primary_keyRF t sql_utilt adapt_criterion_to_nullt
_adapt_clauseR3 R t
_criterionRs ( RL t _lcl_get_clauseR= R� t valuet nonesR% ( t _get_clauset _get_paramst mappert primary_key_identityR
( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyt setup& s"
" c s s | ] } | d k Vq d S( N( RE ( t .0t elem( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pys <genexpr>N s i i N( t _mapper_zeroR� Rq R# R R+ R' t dictR� R� RF R! R0 R/ Rm Rt R� R� RE (
R
RL R� R� Rq t id_valR� Rm t resultR� ( ( R� R� R� R� R
sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyR� s& 5! ( Rq R/ Rr Rs ( R R R R R Rm Ry Rl RJ R{ R� R� R� R� R� R� R� RI R� ( ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyR. Y s"
s 1.2s5 Baked lazy loading is now the default implementation.c C s d S( s� Enable the use of baked queries for all lazyloaders systemwide.
The "baked" implementation of lazy loading is now the sole implementation
for the base lazy loader; this method has no effect except for a warning.
N( ( ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyt bake_lazy_loadersd s
c C s t d � � d S( sD Disable the use of baked queries for all lazyloaders systemwide.
This method now raises NotImplementedError() as the "baked" implementation
is the only lazy load implementation. The
:paramref:`.relationship.bake_queries` flag may be used to disable
the caching of queries on a per-relationship basis.
s4 Baked lazy loading is now the default implementationN( t NotImplementedError( ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyt unbake_lazy_loadersq s c C s | j | i d d 6� S( sx Indicate that the given attribute should be loaded using "lazy"
loading with a "baked" query used in the load.
t baked_selectt lazy( t set_relationship_strategy( t loadoptRZ ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyt baked_lazyload� s sF Baked lazy loading is now the default implementation for lazy loading.c G s t j j t j j | t i � S( N( R t _UnboundLoadt
_from_keysR� R ( t keys( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyR� � s c G s t j j t j j | t i � S( N( R R� R� R� R3 ( R� ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyt baked_lazyload_all� s ($ R R~ t loggingRf R R\ R t ormR� R t orm.queryR t orm.sessionR t sqlR R R� t getLoggerR t logt objectR R R. t
deprecatedR� R� t
loader_optionR� t _add_unbound_fnt _add_unbound_all_fnR� t _unbound_fnt _unbound_all_fnR ( ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyt <module> sB � #�
Mini Shell