/opt/cloudlinux/venv/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__
Edit: /opt/cloudlinux/venv/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__/baked.cpython-311.pyc (30911B)
7p^Ӎ X d Z ddlZddlZddlmZ ddlmZ ddlmZ ddlm Z ddl
m Z ddl m
Z
dd lmZ dd
lmZ ddlmZ ej e Z G d d e Z G d
de Z G d de Z ej dd d Z ej dd d Z e j d Z e j ej dd d Z e j ej dd d Z e j! Z e j" Z ej# Z#dS )zBaked 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)strategy_options)Query)Session)func)literal_columnc " e Zd ZdZdZd Zd ZdS )BakeryzCallable 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
clscachec " || _ || _ d S Nr
)selfcls_r s h/builddir/build/BUILD/cloudlinux-venv-1.0.12/venv/lib64/python3.11/site-packages/sqlalchemy/ext/baked.py__init__zBakery.__init__/ s
c : | | j || S r r
)r
initial_fnargss r __call__zBakery.__call__3 s xx
J555r N)__name__
__module__ __qualname____doc__ __slots__r r r r r r ! sC I 6 6 6 6 6r r c e Zd ZdZdZddZed d Zd Zdd Z d
Z
d Z d Z d
Z
d Zd Zd dZd Zd dZd dZd Zd Zd Zd Zd Zd ZdS )
BakedQueryz3A builder object for :class:`.query.Query` objects.)steps_bakery
_cache_key_spoiledr c l d| _ | || |g| _ d| _ || _ d S )Nr F)r% _update_cache_keyr# r& r$ )r bakeryr r s r r zBakedQuery.__init__< s: z4000 \
r Nc J t | t j || S )zSConstruct a new bakery.
:return: an instance of :class:`.Bakery`
)
size_alert)r r LRUCache)r size _size_alerts r r) zBakedQuery.bakeryC s# c4=+FFFGGGr c t t }| j |_ t | j |_ | j |_ | j |_ |S r )r" __new__r% listr# r$ r& )r b1s r _clonezBakedQuery._cloneM sF
+
+
##\
m r c 8 | xj |j f|z z
c_ d S r )r% __code__r fnr s r r( z BakedQuery._update_cache_keyU s BK>D00r c p t |t r | j | n| | | S r )
isinstancetuple add_criteriar others r __iadd__zBakedQuery.__iadd__X s@ eU # # % D u % % % e $ $ $ r c j t |t r
| j | S | | S r )r: r;
with_criteriar= s r __add__zBakedQuery.__add___ s8 eU # # -%4%u- -%%e,, ,r c f | || | j | | S )zAdd a criteria function to this :class:`.BakedQuery`.
This is equivalent to using the ``+=`` operator to
modify a :class:`.BakedQuery` in-place.
)r( r# appendr7 s r r< zBakedQuery.add_criteriae s5
r4(((
" r c B | j |g|R S )zAdd 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.
)r4 r< r7 s r rA zBakedQuery.with_criteriap s' *t{{}})"4t4444r c " t | | S )zReturn 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)``.
)Resultr sessions r for_sessionzBakedQuery.for_sessiony s dG$$$r c , | | S r )rJ rH s r r zBakedQuery.__call__ s (((r Fc |s8| j s1| }|xj dz
c_ |j g| _ 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.
) _query_onlyT)r& r4 r% _retrieve_baked_queryr# )r full _spoil_points r spoilzBakedQuery.spoil sP ( >DM > ;;==L # #'7 7 # #&<=DJ
r c " | j |j fz 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%
_query_clsrH s r _effective_keyzBakedQuery._effective_key s '"4!666r c ^ | }| ||| |S )z)Cloning version of _add_lazyload_options.)
cache_path)r4 _add_lazyload_options)r optionseffective_pathrV qs r _with_lazyload_optionsz!BakedQuery._with_lazyload_options s/ KKMM J OOOr c d}|s}|j d j r| d n<D ]9}| | }|du r| d 2|||z
}:| fd|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 r T)rO FNc > | j S r )_with_current_path_conditional_options)rZ rY rX s r
z2BakedQuery._add_lazyload_options.. s) #a** "G- r )pathis_aliased_classrQ _generate_cache_keyr< )r rX rY rV keyopt cache_keys `` r rW z BakedQuery._add_lazyload_options s ('J ?1 .
%
JJDJ ! ! ! !
%
% 3 3J ? ? %%JJDJ)))) *9$C
-
-
-
-
-
O
r c | j | | d }|E| | }| d | j | | < | | S r )r$ getrT _as_query with_session)r rI querys r rN z BakedQuery._retrieve_baked_query s !4!4W!=!=tDD =NN7++E9>9K9K: :DL,,W55 6 !!'***r c | | }| }| || d |_ |j d x|_ }|j d| j i |_ dD ] }|j
|d |j j r || j | | < |S )Ncompiled_cache)
_correlate _from_obj_mapper_adapter_map _joinpath
_joinpoint)
ri _compile_context_bake_subquery_loadersrI rk rj _execution_optionsunionr$ __dict__pop_bake_okrT )r rI rk contextattrs r _bakezBakedQuery._bake s w''((** ##GW555 '
: :4 @ @@
#(#;#A#A
t| ,$
$
+ +D
N tT * * * *
= ! A9@DL,,W55 6r c t |t r|}nRt |t r |j }|t j d n t
dt | z | | S )a5 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).as_scalar())
)
: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 rI sa_exc
ArgumentError TypeErrortyperi )r query_or_sessionrI s r to_queryzBakedQuery.to_query s J & 0 0 &GG
(%
0
0
&.G *G
;'(()
~~g&&&r c l | j d | }| j dd D ]
} || }|S Nr )r# )r rI rk steps r ri zBakedQuery._as_query2 sD
1
g&&JqrrN DDKKEE r c l g x|j d< }t |j D ]\ }t t red|v rYt | j fd }| j |z |_ | | | ||j f |j |= dS )ab 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.
baked_queriessubqueryc S r r )r vs r r` z3BakedQuery._bake_subquery_loaders..F s r N)
attributesr2 itemsr: r r" r$ r% r| rD )r rI rz r kbkr s @r rt z!BakedQuery._bake_subquery_loaders9 s ?A@?+m+113344 * *DAq!U##
* ??#DL////BBB$(Oa$7BMHHW%%%!((!R]A)>???&q) * *r c
d|j vrdS |j d D ]i\ }}}t | j |fd }||_ | | } |D ]}
| |
} | j di ||j |< jdS )zRetrieve subquery eager loaders stored by _bake_subquery_loaders
and turn them back into Result objects that will iterate just
like a Query object.
r Nc , | | S r )rj )sessrZ s r r` z5BakedQuery._unbake_subquery_loaders..Y s ANN44H4H r r )r r" r$ r% rJ with_post_criteriaparams) r rI rz r
post_criteriar rf rk r rZ r8 s r _unbake_subquery_loadersz#BakedQuery._unbake_subquery_loadersL s '"4 4 4 F#*#5o#F 7 7 Ay% U H H H B &BMw''A#
-
-((,,$,AH$6$6v$6$6G q ! ! 7 7r )r )r* N)Fr )r r r r r r classmethodr) r4 r( r? rB r< rA rJ r rQ rT r[ rW rN r| r ri rt r r r r r" r" 7 s{ ==2' 2' 2'h * * *&7 7 7 7 7r r" c p e Zd ZdZdZd Zd Zd Zd Zd Z d Z
d Z d
Z d Z
d Zd
Zd Zd Zd Zd ZdS )rG a 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.
bqrI _params_post_criteriac > || _ || _ i | _ g | _ d S r r )r r rI s r r zResult.__init__m s% r c t | dk r | |d n't | dk rt j 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.)lenupdater~ r r )r r kws r r z
Result.paramss sr t99>> IId1g
YY]]&)
B r c > |r| j | | S r )r extend)r fnss r _using_post_criteriazResult._using_post_criteria s& , & &s + + + r c . | |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. 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.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
)r )r r8 s r r zResult.with_post_criteria s ( (("...r c | j | j | j }| j D ]
} || }|S r )r ri rI r r r )r rZ r8 s r ri zResult._as_query sO G dl + + 2 24< @ @% B1AAr c D t | S r )strri r s r __str__zResult.__str__ s 4>>##$$$r c | j }| j j r|j r!t | S |j | | j d }|| | j }t j
| }| j |_ |j
|_ | | j || j
| j d|j _ |j r |j s| j |j | j
| j }| j D ]
} || }| | S NT)r rI enable_baked_queriesr& iterri r$ rh rT r| copyr r r r statement
use_labels autoflushpopulate_existing
_autoflushrk r rj _execute_and_instances)r r
baked_contextrz rZ r8 s r __iter__zResult.__iter__ s^
W|0 *BK *(()) )
r'8'8 'F'FMM
HHT\ 2 2M)M** , $ / 4 4 6 6
## L'4<1D
(,$ &W%> & L # # % % % M . . ; ;DL I I% B1AA''000r c t j t d | j fd }| | j | j S )zreturn 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.
.. versionadded:: 1.1.6
*c . | S r ) from_self)rZ cols r r` z Result.count.. s Q[[-=-= r )
r countr
r rA rJ rI r r scalar)r r r s @r r z Result.count sk j ,,--
W
"
"#=#=#=#=
>
>~~dl++224<@@GGIIIr c | }t |t s|S |d S # t j $ r Y dS w xY w)zReturn 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`.
.. versionadded:: 1.1.6
r N)oner: r; orm_exc
NoResultFound)r rets r r z
Result.scalar sY ((**C c5))
q6M$ 44 s *5 5 AAc | j d }t | | j | j | j }t | dk r|d S dS )zRReturn the first row.
Equivalent to :meth:`_query.Query.first`.
c . | dd S r )slice)rZ s r r` z Result.first.. s QWWQ]] r r N)
r rA r2 rJ rI r r r r r )r r r s r firstz Result.first s| W
"
"#:#:
;
; NN4< ( (
VDL
!
!
!
!$"5
6
6
s88a<<q6M4r c | }|t j d |S # t j $ r3}t j t j d | Y d}~dS d}~ww xY w)zkReturn exactly one result or raise an exception.
Equivalent to :meth:`_query.Query.one`.
NzNo row was found for one()z"Multiple rows were found for one())replace_context) one_or_noner r MultipleResultsFoundr raise_)r r errs r r z
Result.one s ""$$C { +,HIIIJ + K,8 !$
s . A0(A++A0c t | }t | }|dk r|d S |dk rdS t j d )zReturn one or zero results, or raise an exception for multiple
rows.
Equivalent to :meth:`_query.Query.one_or_none`.
.. versionadded:: 1.0.9
r r Nz*Multiple rows were found for one_or_none())r2 r r r )r r ls r r zResult.one_or_none sR 4jj HH 66q6M
!VV4.<
r c t | S )zKReturn all rows.
Equivalent to :meth:`_query.Query.all`.
)r2 r s r allz
Result.all s Dzzr c x | j j d | j }| || j S )z`Retrieve an object based on identity.
Equivalent to :meth:`_query.Query.get`.
r )r r# rI _get_impl_load_on_pk_identity)r identrk s r rh z
Result.get" s5 !
a ..ud&?@@@r c 4
|
j \
fd} j }| }|xj fz
c_ | |t
d D }t fdt
j D }t | j j
di | }t | }|dk rt j |r|d S dS )z6Load the given primary key identity from the database.c ^ }| }| d |_ d v rCt fdt j D }t
j || }| |dd }||_ j
D ]
} || }|S )Nc 4 g | ]\ }}|| j S r rd ).0r value _get_paramss r
z>Result._load_on_pk_identity..setup..= s6 &C != $C(, )==r TF) r4 _get_condition _order_bysetzip primary_keysql_utiladapt_criterion_to_null
_adapt_clause
_criterionr )
rk _lcl_get_clauserZ nonesr8 _get_clauser mapperprimary_key_identityr s
r setupz*Result._load_on_pk_identity..setup3 s )O A
AK +++ *- " .0D+ + #+"B#U# # oootU K KO*AL)
BqEEHr c 3 K | ]}|d u V d S r r )r elems r z.Result._load_on_pk_identity..[ s& GG$ GGGGGGr c 4 g | ]\ }}| j |fS r r )r id_valr r s r r z/Result._load_on_pk_identity.._ s:
'FK [)-v6
r r r Nr ) _mapper_zeror r r4 r% rA r; dictr r r2 rJ rI r r r r ) r rk r r r r resultr r r r s ` ` @@@r r zResult._load_on_pk_identity, sd ##%%#)#5 [ > W
YY[[
+ '
5GG2FGGGGG
+.(&*<, ,
9bnnT\229CCFCCDD KK q55.00 0
!9 4r N)r r r r r r r r r ri r r r r r r r r rh r r r r rG rG b s =I! ! !
/ / /, % % %1 1 14J J J $ " ( * A A AB B B B Br rG z1.2z5Baked lazy loading is now the default implementation.c dS )zEnable 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.
Nr r r r bake_lazy_loadersr q s Dr c t d )aH 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:`_orm.relationship.bake_queries` flag may be used to disable
the caching of queries on a per-relationship basis.
z4Baked lazy loading is now the default implementation)NotImplementedErrorr r r unbake_lazy_loadersr ~ s > r c 2 | |ddi S )zxIndicate that the given attribute should be loaded using "lazy"
loading with a "baked" query used in the load.
lazy baked_select)set_relationship_strategy)loadoptr{ s r baked_lazyloadr s , ,TFN3K L LLr zFBaked lazy loading is now the default implementation for lazy loading.c d t j t j j | di S )NFr _UnboundLoad
_from_keysr keyss r r r s. ( 3 3%4dE2 r c d t j t j j | di S r r r s r baked_lazyload_allr s. ( 3 3%4dD" r )$r r logging r r~ r ormr r orm.queryr orm.sessionr sqlr r
r getLoggerr logobjectr r" rG
deprecatedr r
loader_optionr _add_unbound_fn_add_unbound_all_fnr _unbound_fn_unbound_all_fnr) r r r r s " " " " " " ! ! ! ! ! ! " " " " " " g!!6 6 6 6 6V 6 6 6,h7 h7 h7 h7 h7 h7 h7 h7V L L L L LV L L L^ B B !!M M "!M '
# '
$# +'7 r