U
|
¸ý°dØG ã @ s¶ d Z ddlmZ ddlZddlmZ ddlmZ ddl mZ
|
ddl m Z ddl mZ ddlmZ dd lmZ ddlmZ e e¡ZG d
|
d d ZG d d d ZG dd dZejZdS )zÎ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.
|
|
|
é Né )Úexc)Úutil)ÚQuery)ÚSession)Úfunc)Úliteral_columnc @ s$ e Zd ZdZdZdd Zdd ZdS )ÚBakeryzê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
|
|
|
©ÚclsÚcachec C s || _ || _d S ©Nr
|
)ÚselfZcls_r © r úKd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/ext/baked.pyÚ__init__1 s zBakery.__init__c G s | | j||¡S r r
|
)r Ú
|
initial_fnÚargsr r r Ú__call__5 s zBakery.__call__N)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__Ú __slots__r r r r r r r # s r c @ s´ e Zd ZdZdZd+ddZed,dd Zd
|
d Zd-d d Z dd Z
|
dd Z dd Z dd Z dd Zdd Zd.dd Zd d Zd/d d Zd0d!d"Zd#d$ Zd%d& Zd'd( Zd)d* ZdS )1Ú
|
BakedQueryz3A builder object for :class:`.query.Query` objects.)ÚstepsÚ_bakeryÚ
|
_cache_keyÚ_spoiledr c C s* d| _ | ||¡ |g| _d| _|| _d S )Nr F)r Ú_update_cache_keyr r r )r Úbakeryr r r r r r > s
|
zBakedQuery.__init__éÈ Nc C s t | tj||dS )zSConstruct a new bakery.
|
|
:return: an instance of :class:`.Bakery`
|
|
)Z
|
size_alert)r r ZLRUCache)r ÚsizeZ _size_alertr r r r E s zBakedQuery.bakeryc C s2 t t ¡}| j|_t| j|_| j|_| j|_|S r )r Ú__new__r Úlistr r r )r Zb1r r r Ú_cloneO s
|
zBakedQuery._clonec C s | j |jf| 7 _ d S r )r Ú__code__©r Úfnr r r r r W s z BakedQuery._update_cache_keyc C s$ t |tr| j| n
|
| |¡ | S r )Ú
|
isinstanceÚtupleÚ add_criteria©r Úotherr r r Ú__iadd__Z s
|
|
zBakedQuery.__iadd__c C s" t |tr| j| S | |¡S d S r )r) r* Ú with_criteriar, r r r Ú__add__a s
|
|
zBakedQuery.__add__c G s | ||¡ | j |¡ | S )z«Add a criteria function to this :class:`.BakedQuery`.
|
|
This is equivalent to using the ``+=`` operator to
|
modify a :class:`.BakedQuery` in-place.
|
|
)r r Úappendr' r r r r+ g s zBakedQuery.add_criteriac G s | ¡ j|f| S )zÓ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 r r/ r s zBakedQuery.with_criteriac C s
|
t | |S )zàReturn a :class:`_baked.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)``.
|
|
)ÚResult©r Úsessionr r r Ú for_session| s zBakedQuery.for_sessionc C s
|
| |¡S r )r5 r3 r r r r s zBakedQuery.__call__Fc C s4 |s*| j s*| ¡ }| jd7 _|jg| _d| _ | S )a 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.Query` object is built from scratch each
|
time, with all creational functions being called on each
|
invocation.
|
|
)Z _query_onlyT)r r% r Ú_retrieve_baked_queryr )r ÚfullZ _spoil_pointr r r Úspoil s
|
|
zBakedQuery.spoilc C s | j |jf S )a« 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.Query` object is part of what's cached
|
and needs to match the type of :class:`_query.Query` that a later
|
session will want to use.
|
|
)r Z
|
_query_clsr3 r r r Ú_effective_key¤ s zBakedQuery._effective_keyc C s | ¡ }|j|||d |S )z)Cloning version of _add_lazyload_options.)Ú
|
cache_path)r% Ú_add_lazyload_options)r ÚoptionsÚeffective_pathr: Úqr r r Ú_with_lazyload_options± s z!BakedQuery._with_lazyload_optionsc sz d}|s }D ]J}|j s |jr| ¡ }|dkr>| jdd q|d rNtd||d 7 }q| fdd |j|¡ dS )
|
a* 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.
|
|
r NT)r7 é zloader options with variable bound parameters not supported with baked queries. Please use new-style select() statements for cached ORM queries.r c s | ¡j S r )Z_with_current_pathr< ©r> ©r= r< r r Ú<lambda>Õ ó z2BakedQuery._add_lazyload_options.<locals>.<lambda>)Z_is_legacy_optionZ_is_compile_stateZ_generate_cache_keyr8 ÚAssertionErrorr+ Úpath)r r< r= r: ÚkeyÚoptZckr rB r r; · s"
|
|
ÿ ýz BakedQuery._add_lazyload_optionsc C sF | j | |¡d ¡}|d kr<| |¡}| d ¡| j | |¡< | |¡S r )r Úgetr9 Ú _as_queryZ with_session)r r4 Úqueryr r r r6 Ú s
|
ÿz BakedQuery._retrieve_baked_queryc C s< | |¡}d |_| ¡ }|jjr4||f| j| |¡< ||fS r )rJ r4 Z _statement_20Z_compile_optionsZ_bake_okr r9 )r r4 rK Ú statementr r r Ú_bakeã s
|
þzBakedQuery._bakec C sN t |tr|}n4t |tr4|j}|dkrDt d¡ntdt| | |¡S )aL Return the :class:`_query.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.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).scalar_subquery())
|
)
|
|
:param query_or_session: a :class:`_query.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
|
|
|
Nz1Given Query needs to be associated with a Sessionz)Query or Session object expected, got %r.) r) r r r4 Úsa_excÚ ArgumentErrorÚ TypeErrorÚtyperJ )r Zquery_or_sessionr4 r r r Úto_queryü s &
|
|
ÿÿÿzBakedQuery.to_queryc C s. | j d |}| j dd
D ] }||}q |S ©Nr r@ )r )r r4 rK Ústepr r r rJ 1 s
|
zBakedQuery._as_query)r )r! N)r )F)N)N)r r r r r r Ú classmethodr r% r r. r0 r+ r/ r5 r r8 r9 r? r; r6 rM rR rJ r r r r r 9 s*
|
|
|
|
|
|
|
# 5r c @ s e Zd ZdZdZdd Zdd Zdd Zd d
|
Zd d Z d d Z
|
dd Z dd Z dd Z dd Zdd Zdd Zdd Zd d Zd d Zd!d" Zd#S )$r2 a Invokes a :class:`.BakedQuery` against a :class:`.Session`.
|
|
The :class:`_baked.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.
|
|
©Úbqr4 Ú_paramsÚ_post_criteriac C s || _ || _i | _g | _d S r rV )r rW r4 r r r r E s zResult.__init__c O sB t |dkr | |d ¡ nt |dkr2t d¡| j |¡ | S )z@Specify parameters to be replaced into the string SQL statement.r@ r zFparams() takes zero or one positional argument, which is a dictionary.)ÚlenÚupdaterN rO rX )r r Úkwr r r ÚparamsK s ÿ z Result.paramsc C s |r| j |¡ | S r )rY Úextend)r Úfnsr r r Ú_using_post_criteriaX s zResult._using_post_criteriac C s | |g¡S )aô Add a criteria function that will be applied post-cache.
|
|
This adds a function that will be run against the
|
:class:`_query.Query` object after it is retrieved from the
|
cache. This currently includes **only** the
|
:meth:`_query.Query.params` and :meth:`_query.Query.execution_options`
|
methods.
|
|
.. warning:: :meth:`_baked.Result.with_post_criteria`
|
functions are applied
|
to the :class:`_query.Query`
|
object **after** the query's SQL statement
|
object has been retrieved from the cache. Only
|
:meth:`_query.Query.params` and
|
:meth:`_query.Query.execution_options`
|
methods should be used.
|
|
|
.. versionadded:: 1.2
|
|
|
)r` )r r( r r r Úwith_post_criteria] s zResult.with_post_criteriac C s. | j | j¡ | j¡}| jD ] }||}q |S r )rW rJ r4 r] rX rY )r r> r( r r r rJ v s
|
|
zResult._as_queryc C s t | ¡ S r )ÚstrrJ ©r r r r Ú__str__| s zResult.__str__c C s | ¡ ¡ S r )Ú_iterÚ__iter__rc r r r rf s zResult.__iter__c C sä | j }| jjr|jr | ¡ ¡ S |j | | j¡d¡\}}|d krR| | j¡\}}| j
|
rf| | j
|
¡}n|}| j D ] }||}qp|j
|
}t |j}| |j|jd¡ | jj|||d}|j dd¡rÊ| ¡ }|j dd¡rà| ¡ }|S )N)NN)Z_sa_orm_load_optionsZcompiled_cache)Úexecution_optionsZis_single_entityFÚfiltered)rW r4 Zenable_baked_queriesr rJ re r rI r9 rM rX r] rY ÚdictZ_execution_optionsr[ Z load_optionsÚexecuteÚ _attributesZscalarsÚunique) r rW rK rL r> r( r] rg Úresultr r r re s>
|
ÿ
|
|
|
þÿ ÿz Result._iterc s: t td¡ | j fdd¡}| | j¡ | j¡ ¡ S )zÎreturn the 'count'.
|
|
Equivalent to :meth:`_query.Query.count`.
|
|
Note this uses a subquery to ensure an accurate count regardless
|
of the structure of the original statement.
|
|
Ú*c s
|
| ¡S r )Z_legacy_from_selfrA ©Úcolr r rC ´ rD z Result.count.<locals>.<lambda>)
|
r Úcountr rW r/ r5 r4 r] rX Úscalar©r rW r ro r rq © s
|
z Result.countc C sB z$| ¡ }t|tjs |W S |d W S tjk
|
r< Y dS X dS )zÓ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.Query.scalar`.
|
|
r N)Úoner) Úcollections_abcÚSequenceÚorm_excZ NoResultFound)r Úretr r r rr · s
|
z Result.scalarc C s4 | j dd ¡}| | j¡ | j¡ | j¡ ¡ ¡ S )zRReturn the first row.
|
|
Equivalent to :meth:`_query.Query.first`.
|
|
c S s | dd¡S rS )ÚslicerA r r r rC Î rD z Result.first.<locals>.<lambda>)
|
rW r/ r5 r4 r] rX r` rY re Úfirstrs r r r rz Ç s ÿþ
|
ÿz Result.firstc C s | ¡ ¡ S )zkReturn exactly one result or raise an exception.
|
|
Equivalent to :meth:`_query.Query.one`.
|
|
)re rt rc r r r rt × s z
|
Result.onec C s | ¡ ¡ S )zReturn one or zero results, or raise an exception for multiple
|
rows.
|
|
Equivalent to :meth:`_query.Query.one_or_none`.
|
|
)re Ú one_or_nonerc r r r r{ ß s zResult.one_or_nonec C s | ¡ ¡ S )zKReturn all rows.
|
|
Equivalent to :meth:`_query.Query.all`.
|
|
)re Úallrc r r r r| è s z
|
Result.allc C s | j jd | j}| || j¡S )z`Retrieve an object based on identity.
|
|
Equivalent to :meth:`_query.Query.get`.
|
|
r )rW r r4 Z _get_implÚ_load_on_pk_identity)r ÚidentrK r r r rI ð s z
|
Result.getc
|
sÆ |j d jd j\ fdd}j}| ¡ }| j f7 _| |tdd D ¡}fddtj D }t
|
| j ¡j f |}t|} | d kr²t ¡ n| r¾|d S d
|
S d
|
S ) z6Load the given primary key identity from the database.r Z parententityc st }| ¡ }| ¡ d |_d krHfddtjD }t ||¡}t |ddi¡f|_j D ] }||}qb|S )Nc s" h | ]\}}|d kr | j qS r ©rG )Ú.0rp Úvalue©Ú _get_paramsr r Ú <setcomp>
|
s üz=Result._load_on_pk_identity.<locals>.setup.<locals>.<setcomp>Z
|
_orm_adaptT)
|
r% Z_get_conditionZ _order_byÚzipÚ primary_keyÚsql_utilZadapt_criterion_to_nullZ_deep_annotateZ_where_criteriarY )rK Z_lcl_get_clauser> Znonesr( ©Ú _get_clauser ZmapperÚprimary_key_identityr r r Úsetup s(
|
ÿþ ÿÿ
|
|
z*Result._load_on_pk_identity.<locals>.setupc s s | ]}|d kV qd S r r )r Úelemr r r Ú <genexpr>* s z.Result._load_on_pk_identity.<locals>.<genexpr>c s i | ]\}} | j |qS r r )r Zid_valr r r r Ú
|
<dictcomp>- s ÿ z/Result._load_on_pk_identity.<locals>.<dictcomp>r@ N)Z _raw_columnsZ _annotationsr rW r% r r/ r* r
r r$ r5 r4 r] rZ rw ZMultipleResultsFound)
|
r r4 rK r r\ r rW r] rm Úlr r r r} ú s.
|
ÿ
|
ÿþ
|
zResult._load_on_pk_identityN)r r r r r r r] r` ra rJ rd rf re rq rr rz rt r{ r| rI r} r r r r r2 : s$ '
|
r2 )r Úcollections.abcÚabcru ÚloggingÚ r rN r Zormrw Z orm.queryr Z orm.sessionr Zsqlr r r Ú getLoggerr Úlogr r r2 r r r r r Ú<module>
|
s&
|
|
