+hNhdZddlZddlmZddlmZddlmZddlmZddl m Z ddl m Z dd l mZdd l mZddl mZdd lmZej$eZGd d eZGddeZGddeZej2dddZej2dddZej8dZej<ej2dddZej>ej2dddZ ejBZe jDZ ejFZ#y)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_column)collections_abcc eZdZdZdZdZdZy)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 ||_||_yNr)selfcls_rs G/var/www/html/venv/lib/python3.12/site-packages/sqlalchemy/ext/baked.py__init__zBakery.__init__/s c<|j|j||Srr)r initial_fnargss r__call__zBakery.__call__3sxx J55rN)__name__ __module__ __qualname____doc__ __slots__rrrrr r !s I6rr ceZdZdZdZddZeddZdZddZ dZ d Z d Z d Z d Zd ZddZdZddZddZdZdZdZdZy) BakedQueryz3A builder object for :class:`.query.Query` objects.)steps_bakery _cache_key_spoiledcbd|_|j|||g|_d|_||_y)Nr!F)r&_update_cache_keyr$r'r%)rbakeryrrs rrzBakedQuery.__init__<s0 z40 \   rNcDt|tj||S)zSConstruct a new bakery. :return: an instance of :class:`.Bakery` ) size_alert)r rLRUCache)rsize _size_alerts rr*zBakedQuery.bakeryCsc4==+FGGrctjt}|j|_t|j|_|j |_|j |_|Sr)r#__new__r&listr$r%r')rb1s r_clonezBakedQuery._cloneMsH    +  #\\ mm  rcJ|xj|jf|zz c_yr)r&__code__rfnrs rr)zBakedQuery._update_cache_keyUs BKK>D00rcjt|tr|j||S|j||Sr) isinstancetuple add_criteriarothers r__iadd__zBakedQuery.__iadd__Xs8 eU # D  u %    e $ rcbt|tr|j|S|j|Sr)r:r; with_criteriar=s r__add__zBakedQuery.__add___s0 eU #%4%%u- -%%e, ,rc`|j|||jj||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$appendr7s rr<zBakedQuery.add_criteriaes+ r4( " rcD|jj|g|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. )r4r<r7s rrAzBakedQuery.with_criteriaps"*t{{}))"4t44rct||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_sessionzsdG$$rc$|j|Sr)rJrHs rrzBakedQuery.__call__s((rc|sC|js7|j}|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'r4r&_retrieve_baked_queryr$)rfull _spoil_points rspoilzBakedQuery.spoilsF(DMM;;=L  # #'7 7 #&<<=DJ  rc6|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_clsrHs r_effective_keyzBakedQuery._effective_keys'"4"4!666rcN|j}|j||||S)z)Cloning version of _add_lazyload_options.) cache_path)r4_add_lazyload_options)roptionseffective_pathrVqs r_with_lazyload_optionsz!BakedQuery._with_lazyload_optionss' KKM JOrcd}|s}D]T}|js |js|j}||jdA|drJd||dz }V|j fd|j |y) 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)rOzloader options with variable bound parameters not supported with baked queries. Please use new-style select() statements for cached ORM queries.rc@|jjSr)_with_current_pathrX)rZrYrXs rz2BakedQuery._add_lazyload_options..s Ba**>:BBGLr)_is_legacy_option_is_compile_state_generate_cache_keyrQr<path)rrXrYrVkeyoptcks `` rrWz BakedQuery._add_lazyload_optionss'J !C$$(=(=,,.:JJDJ)!!u'9 2a5LC !  L OO  rc|jj|j|d}|>|j|}|j d|j|j|<|j |Sr)r%getrT _as_query with_session)rrIquerys rrNz BakedQuery._retrieve_baked_querysp   !4!4W!=tD =NN7+E9>9K9K:DLL,,W5 6!!'**rc|j|}d|_|j}|jjr ||f|j |j |<||fSr)rjrI _statement_20_compile_options_bake_okr%rT)rrIrl statements r_bakezBakedQuery._bakesfw' '')   % % . .:DLL,,W5 6 irct|tr|}nJt|tr#|j}|,t j dt dt|z|j|S)aLReturn 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 z1Given Query needs to be associated with a Sessionz)Query or Session object expected, got %r.) r:rrrIsa_exc ArgumentError TypeErrortyperj)rquery_or_sessionrIs rto_queryzBakedQuery.to_queryswL & 0&G (% 0&..G**G;'() ~~g&&rch|jd|}|jddD] }||} |SNrr])r$)rrIrlsteps rrjzBakedQuery._as_query/s? 1 g&JJqrN DKE  r)r!)N)Fr)rrrrr r classmethodr*r4r)r?rBr<rArJrrQrTr[rWrNrrryrjr!rrr#r#7sw= IId1g  Y]&&)  B rc@|r|jj||Sr)rextend)rfnss r_using_post_criteriazResult._using_post_criteriaVs     & &s + rc&|j|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)rr8s rwith_post_criteriazResult.with_post_criteria[s.(("..rc|jj|jj|j}|j D] }||} |Sr)rrjrIrrr)rrZr8s rrjzResult._as_querytsL GG  dll + 2 24<< @%% B1A rc4t|jSr)strrjrs r__str__zResult.__str__zs4>>#$$rc>|jjSr)_iter__iter__rs rrzResult.__iter__}szz|$$&&rcR|j}|jjr |jr|j j S|j j|j|jd\}}||j|j\}}|jr|j|j}n|}|jD] }||} |j}t|j}|j|j |j d|jj#|||}|j$jddr|j'}|j$jddr|j)}|S)N)NN)_sa_orm_load_optionscompiled_cache)execution_optionsis_single_entityFfiltered)rrIenable_baked_queriesr'rjrr%rirTrrrrrdict_execution_optionsr load_optionsexecute _attributesscalarsunique) rrrlrqrZr8rrresults rrz Result._itersd WW||00BKK>>#))+ +::>>   dll +\ y =!xx 5 E9 << T\\*AA%% B1A  !5!56  ()"$**  %% v1B&     ! !"4e <^^%F    ! !*e 4]]_F rctjtd|jj fd}|j |j j|jjS)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&|jSr) _from_self)rZcols rr`zResult.count..sQ\\#->r) r countr rrArJrIrrscalar)rrrs @rrz Result.countsXjj,- WW " "#> ?~~dll+224<<@GGIIrc |j}t|tjs|S|dS#tj $rYywxYw)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 rN)oner:r Sequenceorm_exc NoResultFound)rrets rrz Result.scalarsH ((*Cc?#;#;< q6M$$  s+33A A c |jjd}|j|jj |j j |jjjS)zRReturn the first row. Equivalent to :meth:`_query.Query.first`. c&|jddSr{)slice)rZs rr`zResult.first..sQWWQ]r) rrArJrIrrrrrfirst)rrs rrz Result.firsts[WW " "#: ; NN4<< ( VDLL ! ! !$"5"5 6 UW UW  rc>|jjS)zkReturn exactly one result or raise an exception. Equivalent to :meth:`_query.Query.one`. )rrrs rrz Result.one zz|!!rc>|jjS)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 one_or_noners rrzResult.one_or_noneszz|''))rc>|jjS)zKReturn all rows. Equivalent to :meth:`_query.Query.all`. )rallrs rrz Result.allrrc|jjd|j}|j||jS)z`Retrieve an object based on identity. Equivalent to :meth:`_query.Query.get`. r)rr$rI _get_impl_load_on_pk_identity)ridentrls rriz Result.gets8! a .ud&?&?@@rc j |jdjdj\ fd}j}|j }|xj fz c_|j |tdD}ttjDcgc]\}} |j|fc}}} t|jjjdi| } t!| } | dkDrt#j$| r| dSycc}}w)z6Load the given primary key identity from the database.r parententityc}|j}|jd|_d vrWtt j Dcgc]\}}||j c}}}tj||}tj|ddif|_ jD] }||} |Scc}}w)N _orm_adaptT) r4_get_condition _order_bysetzip primary_keyresql_utiladapt_criterion_to_null_deep_annotate_where_criteriar) rl_lcl_get_clauserZrvaluenonesr8 _get_clause _get_paramsmapperprimary_key_identityrs rsetupz*Result._load_on_pk_identity..setups)O A   AK+++."..0D+&C!= $C(,,#+"B"B#U# '',9MN!A )) qE H's B? c3$K|]}|du ywrr!).0elems r z.Result._load_on_pk_identity..0sG$Gsr]Nr!) _raw_columns _annotationsrrr4r&rAr;rrrrer2rJrIrrrMultipleResultsFound)rrIrlrrrrid_valrrrlrrrs` ` @@@rrzResult._load_on_pk_identitys*##A&33NC#)#5#5 [  DWW YY[ +'    5G2FGG ,/(&*<*<, 'FK[)--v6  9bnnT\\299CFCD K q5..0 0 !9  s,D/ N)rrrrr rrrrrjrrrrrrrrrrirr!rrrGrG8sb=I!  /2 %'%NJ $ " *"AErrGz1.2z5Baked lazy loading is now the default implementation.cy)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!rrbake_lazy_loadersrFs rctd)aHDisable 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!rrunbake_lazy_loadersrSs > rc*|j|ddiS)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)loadoptattrs rbaked_lazyloadrds  , ,TFN3K LLrzFBaked lazy loading is now the default implementation for lazy loading.cvtjjtjj|diS)NFr _UnboundLoad _from_keysrkeyss rrrms2  ( ( 3 3%%44dE2 rcvtjjtjj|diS)NTrrs rbaked_lazyload_allrys2  ( ( 3 3%%44dD" r)$rloggingrrtrormrr orm.queryr orm.sessionrsqlr r rr getLoggerrlogobjectr r#rG deprecatedrr loader_optionr_add_unbound_fn_add_unbound_all_fnr _unbound_fn_unbound_all_fnr*r!rrrse "! ""g!6V6,~~BKVK\ B   B   !M"M '    ## '  $   ++'77   r