a
    •˜ëjXE  ã                   @   s¶   d Z ddlmZ ddlZddlmZ ddlmZ ddl	mZ
 ddlmZ ddlmZ ddlmZ dd	lmZ ddlmZ e e¡ZG d
d„ dƒZG dd„ dƒZG dd„ dƒZejZdS )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 Zd ZdZdZdd„ Zdd„ ZdS )Ú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
   )ÚselfZcls_r   © r   úS/mnt/bigstor/www/usecases/.venv/lib/python3.9/site-packages/sqlalchemy/ext/baked.pyÚ__init__0   s    zBakery.__init__c                 G   s   |   | j||¡S r   r
   )r   Ú
initial_fnÚargsr   r   r   Ú__call__4   s    zBakery.__call__N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú	__slots__r   r   r   r   r   r   r	   "   s   r	   c                   @   s´   e Zd ZdZdZd+dd„Zed,dd	„ƒZd
d„ Zd-dd„Z	dd„ Z
dd„ Zdd„ Zdd„ Zdd„ Zdd„ Zd.dd„Zdd„ Zd/dd „Zd0d!d"„Zd#d$„ Zd%d&„ Zd'd(„ Zd)d*„ ZdS )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
    zBakedQuery.__init__éÈ   Nc                 C   s   t | tj||d�ƒS )zSConstruct a new bakery.

        :return: an instance of :class:`.Bakery`

        )Z
size_alert)r	   r   ZLRUCache)r   ÚsizeZ_size_alertr   r   r   r    D   s    zBakedQuery.bakeryc                 C   s2   t  t ¡}| j|_t| jƒ|_| j|_| j|_|S r   )r   Ú__new__r   Úlistr   r   r   )r   Úb1r   r   r   Ú_cloneN   s    
zBakedQuery._clonec                 C   s   |  j |jf| 7  _ d S r   )r   Ú__code__©r   Úfnr   r   r   r   r   V   s    zBakedQuery._update_cache_keyc                 C   s$   t |tƒr| j|Ž  n
|  |¡ | S r   )Ú
isinstanceÚtupleÚadd_criteria©r   Úotherr   r   r   Ú__iadd__Y   s    

zBakedQuery.__iadd__c                 C   s"   t |tƒr| j|Ž S |  |¡S d S r   )r*   r+   Úwith_criteriar-   r   r   r   Ú__add__`   s    

zBakedQuery.__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,   f   s    zBakedQuery.add_criteriac                 G   s   |   ¡ j|g|¢R Ž 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   r0   q   s    zBakedQuery.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    zBakedQuery.for_sessionc                 C   s
   |   |¡S r   )r6   r4   r   r   r   r   …   s    zBakedQuery.__call__Fc                 C   s4   |s*| j s*|  ¡ }| jd7  _|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.

        )Z_query_onlyT)r   r&   r   Ú_retrieve_baked_queryr   )r   ÚfullZ_spoil_pointr   r   r   Úspoilˆ   s    

zBakedQuery.spoilc                 C   s   | j |jf 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_clsr4   r   r   r   Ú_effective_key£   s    zBakedQuery._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 |jr| ¡ }|du r>| jdd� q|d rNJ dƒ‚||d 7 }q|  ‡ ‡fdd	„|j|¡ dS )
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)r8   é   z‘loader 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_keyr9   r,   Úpath)r   r=   r>   r;   ÚkeyÚoptZckr   rC   r   r<   ¶   s"    

ÿýz BakedQuery._add_lazyload_optionsc                 C   sF   | j  |  |¡d ¡}|d u r<|  |¡}| d ¡| j |  |¡< | |¡S r   )r   Úgetr:   Ú	_as_queryZwith_session)r   r5   Úqueryr   r   r   r7   Ù   s    
ÿz BakedQuery._retrieve_baked_queryc                 C   s<   |   |¡}d |_| ¡ }|jjr4||f| j|  |¡< ||fS r   )rJ   r5   Z_statement_20Z_compile_optionsZ_bake_okr   r:   )r   r5   rK   Ú	statementr   r   r   Ú_bakeâ   s    
þzBakedQuery._bakec                 C   sN   t |tƒr|}n4t |tƒr4|j}|du rDt d¡‚ntdt|ƒ ƒ‚|  |¡S )a  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   r5   Úsa_excÚArgumentErrorÚ	TypeErrorÚtyperJ   )r   Zquery_or_sessionr5   r   r   r   Úto_queryû   s    "

ÿÿÿzBakedQuery.to_queryc                 C   s.   | j d |ƒ}| j dd … D ]}||ƒ}q|S ©Nr   rA   )r   )r   r5   rK   Ústepr   r   r   rJ   ,  s    
zBakedQuery._as_query)r   )r!   N)r   )F)N)N)r   r   r   r   r   r   Úclassmethodr    r&   r   r/   r1   r,   r0   r6   r   r9   r:   r@   r<   r7   rM   rR   rJ   r   r   r   r   r   8   s*   
	





#	1r   c                   @   s”   e Zd ZdZdZdd„ Zdd„ Zdd„ Zd	d
„ Zdd„ Z	dd„ Z
dd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd „ Zd!d"„ Zd#S )$r3   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.

    ©Úbqr5   Ú_paramsÚ_post_criteriac                 C   s   || _ || _i | _g | _d S r   rV   )r   rW   r5   r   r   r   r   @  s    zResult.__init__c                 O   sB   t |ƒdkr| |d ¡ nt |ƒdkr2t d¡‚| j |¡ | S )z@Specify parameters to be replaced into the string SQL statement.rA   r   zFparams() takes zero or one positional argument, which is a dictionary.)ÚlenÚupdaterN   rO   rX   )r   r   Úkwr   r   r   ÚparamsF  s    ÿzResult.paramsc                 C   s   |r| j  |¡ | S r   )rY   Úextend)r   Úfnsr   r   r   Ú_using_post_criteriaS  s    zResult._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_criteriaX  s    zResult.with_post_criteriac                 C   s.   | j  | j¡ | j¡}| jD ]}||ƒ}q|S r   )rW   rJ   r5   r]   rX   rY   )r   r?   r)   r   r   r   rJ   q  s    

zResult._as_queryc                 C   s   t |  ¡ ƒS r   )ÚstrrJ   ©r   r   r   r   Ú__str__w  s    zResult.__str__c                 C   s   |   ¡  ¡ S r   )Ú_iterÚ__iter__rc   r   r   r   rf   z  s    zResult.__iter__c           	      C   sä   | j }| jjr|jr |  ¡  ¡ S |j | | j¡d¡\}}|d u rR| 	| j¡\}}| j
rf| | j
¡}n|}| jD ]}||ƒ}qp|j
}t|jƒ}| |j|jdœ¡ | jj|||d�}|j dd¡rÊ| ¡ }|j dd¡rà| ¡ }|S )N)NN)Z_sa_orm_load_optionsZcompiled_cache)Úexecution_optionsZis_single_entityFÚfiltered)rW   r5   Zenable_baked_queriesr   rJ   re   r   rI   r:   rM   rX   r]   rY   ÚdictZ_execution_optionsr[   Zload_optionsÚexecuteÚ_attributesZscalarsÚunique)	r   rW   rK   rL   r?   r)   r]   rg   Úresultr   r   r   re   }  s8    ÿ


þÿÿzResult._iterc                    s:   t  tdƒ¡‰ | j ‡ fdd„¡}| | 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_selfrB   ©Úcolr   r   rD   ¯  rE   zResult.count.<locals>.<lambda>)
r   Úcountr   rW   r0   r6   r5   r]   rX   Úscalar©r   rW   r   ro   r   rq   ¤  s    
zResult.countc                 C   s@   z$|   ¡ }t|tjƒs|W S |d W S  tjy:   Y dS 0 dS )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  dd„ ¡}| | j¡ | j¡ | j¡ ¡  	¡ S )zRReturn the first row.

        Equivalent to :meth:`_query.Query.first`.

        c                 S   s   |   dd¡S rS   )ÚslicerB   r   r   r   rD   É  rE   zResult.first.<locals>.<lambda>)
rW   r0   r6   r5   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 )z�Return 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    zResult.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 jd | jƒ}| || j¡S )z`Retrieve an object based on identity.

        Equivalent to :meth:`_query.Query.get`.

        r   )rW   r   r5   Z	_get_implÚ_load_on_pk_identity)r   ÚidentrK   r   r   r   rI   ë  s    z
Result.getc           
         sÊ   |j d jd ‰ˆj\‰ ‰‡ ‡‡‡‡fdd„}ˆj}| ¡ }| jˆ f7  _| |tdd„ ˆD ƒƒ¡}‡fdd„tˆˆj	ƒD ƒ}t
| ˆj¡jf i |¤Žƒ}t|ƒ}	|	d	kr¶t ¡ ‚n|	rÂ|d S d
S d
S )z6Load the given primary key identity from the database.r   Zparententityc                    st   ˆ }|   ¡ }| ¡  d |_d ˆv rH‡fdd„tˆjˆƒD ƒ}t ||¡}t |ddi¡f|_ˆj	D ]}||ƒ}qb|S )Nc                    s"   h | ]\}}|d u rˆ | j ’qS 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_utilZadapt_criterion_to_nullZ_deep_annotateZ_where_criteriarY   )rK   Z_lcl_get_clauser?   Znonesr)   ©Ú_get_clauserƒ   ZmapperÚprimary_key_identityr   r   r   Úsetupü  s$    
ÿþÿÿ

z*Result._load_on_pk_identity.<locals>.setupc                 s   s   | ]}|d u V  qd S r   r   )r€   Úelemr   r   r   Ú	<genexpr>%  rE   z.Result._load_on_pk_identity.<locals>.<genexpr>c                    s   i | ]\}}ˆ | j |“qS r   r   )r€   Zid_valr†   r‚   r   r   Ú
<dictcomp>(  s   ÿz/Result._load_on_pk_identity.<locals>.<dictcomp>rA   N)Z_raw_columnsZ_annotationsr‰   rW   r&   r   r0   r+   r…   r†   r$   r6   r5   r]   rZ   rw   ZMultipleResultsFound)
r   r5   rK   rŠ   r\   r‹   rW   r]   rm   Úlr   rˆ   r   r}   õ  s*    
 ÿ
ÿþ
zResult._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   r3   5  s$   '	
r3   )r   Úcollections.abcÚabcru   ÚloggingÚ r   rN   r   Zormrw   Z	orm.queryr   Zorm.sessionr   Zsqlr   r   r‡   Ú	getLoggerr   Úlogr	   r   r3   r    r   r   r   r   Ú<module>
   s$   	
 ~  