[hYEdZddlmZddlZddlmZddlmZddl mZ ddl m Z ddl mZddlmZdd lmZddlmZejeZGd d ZGd d ZGddZejZdS)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)Query)Session)func)literal_columnc"eZdZdZdZdZdZdS)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"||_||_dSNr )selfcls_rs c/var/www/api.easyaligner.net/htdocs/venv_linux/lib/python3.11/site-packages/sqlalchemy/ext/baked.py__init__zBakery.__init__1s c:||j||Srr )r initial_fnargss r__call__zBakery.__call__5sxx J555rN)__name__ __module__ __qualname____doc__ __slots__rrrrr r #sC  I66666rr ceZdZdZdZddZeddZdZdd Z d Z d Z d Z d Z dZdZddZdZddZddZdZdZdZdZdS) BakedQueryz3A builder object for :class:`.query.Query` objects.)steps_bakery _cache_key_spoiledrcld|_||||g|_d|_||_dS)NrF)r$_update_cache_keyr"r%r#)rbakeryrrs rrzBakedQuery.__init__>s: z4000 \   rNcJt|tj||S)zSConstruct a new bakery. :return: an instance of :class:`.Bakery` ) size_alert)r rLRUCache)r size _size_alerts rr(zBakedQuery.bakeryEs#c4=+FFFGGGrctt}|j|_t|j|_|j|_|j|_|Sr)r!__new__r$listr"r#r%)rb1s r_clonezBakedQuery._cloneOsF    + +  ##\ m  rc8|xj|jf|zz c_dSr)r$__code__rfnrs rr'zBakedQuery._update_cache_keyWs BK>D00rcpt|tr |j|n|||Sr) isinstancetuple add_criteriarothers r__iadd__zBakedQuery.__iadd__Zs@ eU # # % D u % % %   e $ $ $ rcjt|tr |j|S||Sr)r9r: with_criteriar<s r__add__zBakedQuery.__add__as8 eU # # -%4%u- -%%e,, ,rcf||||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"appendr6s rr;zBakedQuery.add_criteriags5 r4((( " rcB|j|g|RS)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. )r3r;r6s rr@zBakedQuery.with_criteriars'*t{{}})"4t4444rc"t||S)zReturn 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)``. )Resultrsessions r for_sessionzBakedQuery.for_session|sdG$$$rc,||Sr)rIrGs rrzBakedQuery.__call__s(((rFc|s8|js1|}|xjdz c_|jg|_d|_|S)aCancel 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%r3r$_retrieve_baked_queryr")rfull _spoil_points rspoilzBakedQuery.spoilsP( >DM >;;==L  # #'7 7 # #&<=DJ  rc"|j|jfzS)aReturn 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_clsrGs r_effective_keyzBakedQuery._effective_keys'"4!666rc^|}|||||S)z)Cloning version of _add_lazyload_options.) cache_path)r3_add_lazyload_options)roptionseffective_pathrUqs r_with_lazyload_optionsz!BakedQuery._with_lazyload_optionss/ KKMM JOOOrcd}|s}D]Z}|js|jrJ|}||d=|dr Jd||dz }[|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. rNT)rNzloader options with variable bound parameters not supported with baked queries. Please use new-style select() statements for cached ORM queries.rc>|jSr)_with_current_pathrW)rYrXrWs rz2BakedQuery._add_lazyload_options..s Ba**>::BGLr)_is_legacy_option_is_compile_state_generate_cache_keyrPr;path)rrWrXrUkeyoptcks `` rrVz BakedQuery._add_lazyload_optionss ('J ! !C$ !(= !,,..:JJDJ))))!!u' 2a5LC  L L L L L O      rc|j||d}|E||}|d|j||<||Sr)r#getrS _as_query with_session)rrHquerys rrMz BakedQuery._retrieve_baked_querys   !4!4W!=!=tDD =NN7++E9>9K9K::DL,,W55 6!!'***rc||}d|_|}|jjr||f|j||<||fSr)rirH _statement_20_compile_options_bake_okr#rS)rrHrk statements r_bakezBakedQuery._bakeslw'' ''))   % . :DL,,W55 6 irct|tr|}nRt|tr|j}|t jdnt dt|z||S)aReturn 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.) r9rrrHsa_exc ArgumentError TypeErrortyperi)rquery_or_sessionrHs rto_queryzBakedQuery.to_querysD & 0 0 &GG (% 0 0 &.G*G ;'(() ~~g&&&rcl|jd|}|jddD] }||}|SNrr\)r")rrHrksteps rrizBakedQuery._as_query-sD 1 g&&JqrrN  DDKKEE r)r)r)N)Fr)rrrrrr classmethodr(r3r'r>rAr;r@rIrrPrSrZrVrMrqrxrirrrr!r!9s]==||_||_i|_g|_dSrr~)rrrHs rrzResult.__init__As%   rct|dkr||dn't|dkrtjd|j||S)z@Specify parameters to be replaced into the string SQL statement.r\rzFparams() takes zero or one positional argument, which is a dictionary.)lenupdatersrtr)rrkws rparamsz Result.paramsGsr t99>> IId1g     YY]]&)  B rc>|r|j||Sr)rextend)rfnss r_using_post_criteriazResult._using_post_criteriaTs&  ,   & &s + + + rc.||gS)aAdd 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)rr7s rwith_post_criteriazResult.with_post_criteriaYs.(("...rc|j|j|j}|jD] }||}|Sr)rrirHrrr)rrYr7s rrizResult._as_queryrsO G  dl + + 2 24< @ @%  B1AArcDt|Sr)strrirs r__str__zResult.__str__xs4>>##$$$rcN|Sr)_iter__iter__rs rrzResult.__iter__{szz||$$&&&rc|j}|jjr|jr&|S|j||jd\}}|| |j\}}|j r| |j }n|}|j D] }||}|j }t|j}||j|jd|j|||}|jddr|}|jddr|}|S)N)NN)_sa_orm_load_optionscompiled_cache)execution_optionsis_single_entityFfiltered)rrHenable_baked_queriesr%rirr#rhrSrqrrrdict_execution_optionsr load_optionsexecute _attributesscalarsunique) rrrkrprYr7rrresults rrz Result._iter~s W|0 ,BK ,>>##))++ +:>>   dl + +\  y =!xx 55 E9 <  T\**AAA%  B1AA !566  ()"$*     %% v1B&     ! !"4e < < &^^%%F   ! !*e 4 4 %]]__F rctjtd|jfd}||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. *c.|Sr)_legacy_from_self)rYcols rr_zResult.count..sQ-@-@-E-Er) rcountr rr@rIrHrrscalar)rrrs @rrz Result.countskj,,-- W " "#E#E#E#E F F~~dl++224<@@GGIIIrc |}t|tjs|S|dS#tj$rYdSwxYw)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`. rN)oner9collections_abcSequenceorm_exc NoResultFound)rrets rrz Result.scalars\ ((**Cc?#;<<  q6M$   44 s/::A  A c|jd}||j|j|j S)zRReturn the first row. Equivalent to :meth:`_query.Query.first`. c.|ddSrz)slice)rYs rr_zResult.first..sQWWQ]]r) rr@rIrHrrrrrfirst)rrs rrz Result.firstseW " "#:#: ; ; NN4< ( ( VDL ! ! ! !$"5 6 6 UWW UWW  rcN|S)zkReturn exactly one result or raise an exception. Equivalent to :meth:`_query.Query.one`. )rrrs rrz Result.one zz||!!!rcN|S)zReturn one or zero results, or raise an exception for multiple rows. Equivalent to :meth:`_query.Query.one_or_none`. )r one_or_noners rrzResult.one_or_noneszz||'')))rcN|S)zKReturn all rows. Equivalent to :meth:`_query.Query.all`. )rallrs rrz Result.allrrcx|jjd|j}|||jS)z`Retrieve an object based on identity. Equivalent to :meth:`_query.Query.get`. r)rr"rH _get_impl_load_on_pk_identity)ridentrks rrhz Result.gets5! a ..ud&?@@@rc " |jdjd j\ fd}j}|}|xj fz c_||tdD} fdt j D}t| j j di|}t|} | dkrtj| r|dSdS) z6Load the given primary key identity from the database.r parententitycB}|}|d|_dvr6fdtjD}t j||}t j|ddif|_ j D] }||}|S)Nc4h|]\}}||jSrrd).0rvalue _get_paramss r z=Result._load_on_pk_identity..setup..s6"U}  $(%}}r _orm_adaptT) r3_get_condition _order_byzip primary_keysql_utiladapt_criterion_to_null_deep_annotate_where_criteriar) rk_lcl_get_clauserYnonesr7 _get_clausermapperprimary_key_identityrs rsetupz*Result._load_on_pk_identity..setups)O A     AK+++&)*,@''#+"B#U## ',9MNN!A )  BqEEHrc3K|]}|duV dSrr)relems r z.Result._load_on_pk_identity..&s&GG$GGGGGGrc2i|]\}}|j|Srr)rid_valrrs r z/Result._load_on_pk_identity..)s7   #   $ (&   rr\Nr) _raw_columns _annotationsrrr3r$r@r:rrr1rIrHrrrMultipleResultsFound) rrHrkrrrrrrlrrrs ` ` @@@rrzResult._load_on_pk_identitysZ#A&3NC#)#5 [         @W YY[[ +'    5GG2FGGGGG      '*$f&8((   9bnnT\229CCFCCDD KK q55.00 0  !9 4rN)rrrrrrrrrrirrrrrrrrrrhrrrrrFrF6s!=I!!!    ///2 %%%'''%%%N J J J    """***"""AAAAAAAArrF)rcollections.abcabcrloggingrrsrormr orm.queryr orm.sessionrsqlrr r getLoggerrlogr r!rFr(rrrrsh*))))) !!!!!! """"""g!!66666666,zzzzzzzzzAAAAAAAAH  r