o gYE@sdZddlmZddlZddlmZddlmZddl mZ ddl m Z ddl mZddlmZdd lmZddlmZeeZGd d d ZGd d d ZGdddZejZdS)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@s$eZdZdZdZddZddZdS)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 clscachecCs||_||_dSNr )selfcls_r rV/var/www/html/ecg_monitoring/venv/lib/python3.10/site-packages/sqlalchemy/ext/baked.py__init__1s zBakery.__init__cGs||j||Sr r )r initial_fnargsrrr__call__5szBakery.__call__N)__name__ __module__ __qualname____doc__ __slots__rrrrrrr #s   r c@seZdZdZdZd+ddZed,dd Zd d Zd+d d Z ddZ ddZ ddZ ddZ ddZddZd-ddZddZd.dd Zd.d!d"Zd#d$Zd%d&Zd'd(Zd)d*ZdS)/ BakedQueryz3A builder object for :class:`.query.Query` objects.)steps_bakery _cache_key_spoiledrcCs*d|_||||g|_d|_||_dS)NrF)r_update_cache_keyrrr)rbakeryrrrrrr>s   zBakedQuery.__init__NcCst|tj||dS)zSConstruct a new bakery. :return: an instance of :class:`.Bakery` ) size_alert)r rLRUCache)r size _size_alertrrrr!EszBakedQuery.bakerycCs2tt}|j|_t|j|_|j|_|j|_|Sr )r__new__rlistrrr)rb1rrr_cloneOs  zBakedQuery._clonecCs|j|jf|7_dSr )r__code__rfnrrrrr WszBakedQuery._update_cache_keycCs&t|tr |j||S|||Sr ) isinstancetuple add_criteriarotherrrr__iadd__Zs   zBakedQuery.__iadd__cCst|tr |j|S||Sr )r.r/ with_criteriar1rrr__add__as   zBakedQuery.__add__cGs||||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 rappendr,rrrr0gs  zBakedQuery.add_criteriacGs|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. )r*r0r,rrrr4rszBakedQuery.with_criteriacCs 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)``. )Resultrsessionrrr for_session|s zBakedQuery.for_sessioncCs ||Sr )r:r8rrrrs zBakedQuery.__call__FcCs4|s|js|}|jd7_|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)rr*r_retrieve_baked_queryr)rfull _spoil_pointrrrspoils  zBakedQuery.spoilcCs|j|jfS)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_clsr8rrr_effective_keys zBakedQuery._effective_keycCs|}|j|||d|S)z)Cloning version of _add_lazyload_options.) cache_path)r*_add_lazyload_options)roptionseffective_pathrBqrrr_with_lazyload_optionssz!BakedQuery._with_lazyload_optionscszd}|s}D]%}|js|jr-|}|dur|jddq|dr'Jd||d7}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. rNT)r=zloader options with variable bound parameters not supported with baked queries. Please use new-style select() statements for cached ORM queries.rcs|jSr )_with_current_pathrDrFrErDrrsz2BakedQuery._add_lazyload_options..)_is_legacy_option_is_compile_state_generate_cache_keyr?r0path)rrDrErBkeyoptckrrKrrCs$     z BakedQuery._add_lazyload_optionscCsF|j||d}|dur||}|d|j||<||Sr )rgetrA _as_query with_session)rr9queryrrrr<s  z BakedQuery._retrieve_baked_querycCs<||}d|_|}|jjr||f|j||<||fSr )rUr9 _statement_20_compile_options_bake_okrrA)rr9rW statementrrr_bakes  zBakedQuery._bakecCsNt|tr|}nt|tr|j}|durtdntdt|||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.) r.rrr9sa_exc ArgumentError TypeErrortyperU)rquery_or_sessionr9rrrto_querys "  zBakedQuery.to_querycCs.|jd|}|jddD]}||}q|SNrrH)r)rr9rWsteprrrrU-s zBakedQuery._as_query)r)r"N)Fr )rrrrrr classmethodr!r*r r3r5r0r4r:rr?rArGrCr<r\rbrUrrrrr9s,       #  1rc@seZdZdZdZddZddZddZd d Zd d Z d dZ ddZ ddZ ddZ ddZddZddZddZddZdd Zd!d"Zd#S)$r7aInvokes 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. bqr9_params_post_criteriacCs||_||_i|_g|_dSr rf)rrgr9rrrrAs zResult.__init__cOsBt|dkr||dn t|dkrtd|j||S)z@Specify parameters to be replaced into the string SQL statement.rHrzFparams() takes zero or one positional argument, which is a dictionary.)lenupdater]r^rh)rrkwrrrparamsGs   z Result.paramscCs|r|j||Sr )riextend)rfnsrrr_using_post_criteriaTs zResult._using_post_criteriacCs ||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 )rp)rr-rrrwith_post_criteriaYs zResult.with_post_criteriacCs.|j|j|j}|jD]}||}q|Sr )rgrUr9rmrhri)rrFr-rrrrUrs  zResult._as_querycCs t|Sr )strrUrrrr__str__x zResult.__str__cC |Sr )_iter__iter__rsrrrrx{ruzResult.__iter__c Cs|j}|jjr |jr|S|j||jd\}}|dur)| |j\}}|j r3| |j }n|}|j D]}||}q8|j }t |j}||j|jd|jj|||d}|jddre|}|jddrp|}|S)N)NN)_sa_orm_load_optionscompiled_cache)execution_optionsis_single_entityFfiltered)rgr9enable_baked_queriesrrUrwrrTrAr\rhrmridict_execution_optionsrk load_optionsexecute _attributesscalarsunique) rrgrWr[rFr-rmr{resultrrrrw~s8     z Result._itercs:ttd|jfdd}||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. *cs |Sr )_legacy_from_selfrJcolrrrLs zResult.count..) rcountrrgr4r:r9rmrhscalarrrgrrrrs z Result.countcCs<z|}t|tjs|WS|dWStjyYdSw)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)oner.collections_abcSequenceorm_exc NoResultFound)rretrrrrs  z Result.scalarcCs4|jdd}||j|j|j S)zRReturn the first row. Equivalent to :meth:`_query.Query.first`. cSs |ddSrc)slicerJrrrrLs zResult.first..) rgr4r:r9rmrhrprirwfirstrrrrrs z Result.firstcCrv)zkReturn exactly one result or raise an exception. Equivalent to :meth:`_query.Query.one`. )rwrrsrrrr z Result.onecCrv)zReturn one or zero results, or raise an exception for multiple rows. Equivalent to :meth:`_query.Query.one_or_none`. )rw one_or_nonersrrrrs zResult.one_or_nonecCrv)zKReturn all rows. Equivalent to :meth:`_query.Query.all`. )rwallrsrrrrrz Result.allcCs |jjd|j}|||jS)z`Retrieve an object based on identity. Equivalent to :meth:`_query.Query.get`. r)rgrr9 _get_impl_load_on_pk_identity)ridentrWrrrrTsz Result.getc  s|jdjdj\fdd}j}|}|jf7_||tddD}fddtj D}t | j j d i|}t|} | d krZt| r`|dSd S) z6Load the given primary key identity from the database.r parententitycst}|}|d|_dvr$fddtjD}t||}t|ddif|_j D]}||}q1|S)Ncs"h|] \}}|dur|jqSr rQ).0rvalue _get_paramsrr s z=Result._load_on_pk_identity..setup.. _orm_adaptT) r*_get_condition _order_byzip primary_keysql_utiladapt_criterion_to_null_deep_annotate_where_criteriari)rW_lcl_get_clauserFnonesr- _get_clausermapperprimary_key_identityrrrsetups$   z*Result._load_on_pk_identity..setupcss|]}|duVqdSr r)relemrrr &sz.Result._load_on_pk_identity..csi|] \}}|j|qSrr)rid_valrrrr )s z/Result._load_on_pk_identity..rHNr) _raw_columns _annotationsrrgr*rr4r/rrr(r:r9rmrjrMultipleResultsFound) rr9rWrrlrrgrmrlrrrrs*   zResult._load_on_pk_identityN)rrrrrrrmrprqrUrtrxrwrrrrrrrTrrrrrr76s& '  r7)rcollections.abcabcrloggingrr]rormr orm.queryr orm.sessionrsqlrrr getLoggerrlogr rr7r!rrrrs&          ~