File: //usr/local/lib/python3.10/dist-packages/sqlalchemy/ext/__pycache__/baked.cpython-310.pyc
o
���gYE � @ s� d Z ddlmZ ddlZddlmZ ddlmZ ddl mZ
ddl m Z ddl
mZ ddlmZ dd lmZ ddlmZ e�e�ZG d
d � d �ZG d d
� d
�ZG dd� d�ZejZdS )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 Zd ZdZdZdd� Zdd� ZdS )�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
)�self�cls_r � r �?/usr/local/lib/python3.10/dist-packages/sqlalchemy/ext/baked.py�__init__1 s
zBakery.__init__c G s | � | j||�S r
r
)r �
initial_fn�argsr r r �__call__5 s zBakery.__call__N)�__name__�
__module__� __qualname__�__doc__� __slots__r r r r r r r # s
r c @ s� e Zd ZdZdZd+dd�Zed,dd ��Zd
d � Zd+d d
�Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zd-dd �Zd d � Zd.d d �Zd.d!d"�Zd#d$� Zd%d&� Zd'd(� Zd)d*� ZdS )/�
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
zBakedQuery.__init__�� Nc C s t | tj||d��S )zSConstruct a new bakery.
:return: an instance of :class:`.Bakery`
)�
size_alert)r r �LRUCache)r �size� _size_alertr r r r! E s zBakedQuery.bakeryc C s2 t �t �}| j|_t| j�|_| j|_| j|_|S r
)r �__new__r �listr r r )r �b1r r r �_cloneO s
zBakedQuery._clonec C s | j |jf| 7 _ d S r
)r �__code__�r �fnr r r r r W s z BakedQuery._update_cache_keyc C s& t |t�r | j|� | S | �|� | S r
)�
isinstance�tuple� add_criteria�r �otherr r r �__iadd__Z s
�zBakedQuery.__iadd__c C s t |t�r
| j|� S | �|�S r
)r. r/ �
with_criteriar1 r r r �__add__a s
zBakedQuery.__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 r0 g s zBakedQuery.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* r0 r, r r r r4 r s zBakedQuery.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
zBakedQuery.for_sessionc C s
| � |�S r
)r: r8 r r r r � s
zBakedQuery.__call__Fc C s4 |s| j s| �� }| jd7 _|jg| _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 r* r �_retrieve_baked_queryr )r �full� _spoil_pointr r r �spoil� s
zBakedQuery.spoilc C s | j |jf 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_clsr8 r r r �_effective_key� s zBakedQuery._effective_keyc C s | � � }|j|||d� |S )z)Cloning version of _add_lazyload_options.)�
cache_path)r* �_add_lazyload_options)r �options�effective_pathrB �qr r r �_with_lazyload_options� s z!BakedQuery._with_lazyload_optionsc sz d}|s� }�D ]%}|j s|jr-|�� }|du r | jdd� q|d r'J d��||d 7 }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.
r NT)r= � 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
)�_with_current_pathrD �rF �rE rD r r �<lambda>� s z2BakedQuery._add_lazyload_options.<locals>.<lambda>)�_is_legacy_option�_is_compile_state�_generate_cache_keyr? r0 �path)r rD rE rB �key�opt�ckr rK r rC � s$
� � �z BakedQuery._add_lazyload_optionsc C sF | j �| �|�d �}|d u r | �|�}|�d �| j | �|�< |�|�S r
)r �getrA � _as_query� with_session)r r9 �queryr r r r< � s
�
z BakedQuery._retrieve_baked_queryc C s< | � |�}d |_|�� }|jjr||f| j| �|�< ||fS r
)rU r9 �
_statement_20�_compile_options�_bake_okr rA )r r9 rW � statementr r r �_bake� s
�zBakedQuery._bakec C sN t |t�r|}nt |t�r|j}|du rt�d��ntdt|� ��| �|�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 r9 �sa_exc�
ArgumentError� TypeError�typerU )r �query_or_sessionr9 r r r �to_query� s
"
����
zBakedQuery.to_queryc C s. | j d |�}| j dd � D ]}||�}q|S �Nr rH )r )r r9 rW �stepr r r rU - s
zBakedQuery._as_query)r )r" N)Fr
)r r r r r r � classmethodr! r* r r3 r5 r0 r4 r: r r? rA rG rC r< r\ rb rU r r r r r 9 s,
# 1r c @ s� e Zd ZdZdZdd� Zdd� Zdd� Zd d
� Zd d � Z d
d� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#S )$r7 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.
��bqr9 �_params�_post_criteriac C s || _ || _i | _g | _d S r
rf )r rg r9 r r r r A s
zResult.__init__c O sB t |�dkr|�|d � n t |�dkrt�d��| j�|� | S )z@Specify parameters to be replaced into the string SQL statement.rH r zFparams() takes zero or one positional argument, which is a dictionary.)�len�updater] r^ rh )r r �kwr r r �paramsG s � z
Result.paramsc C s |r| j �|� | S r
)ri �extend)r �fnsr r r �_using_post_criteriaT s zResult._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
)rp )r r- r r r �with_post_criteriaY s zResult.with_post_criteriac C s. | j �| j��| j�}| jD ]}||�}q|S r
)rg rU r9 rm rh ri )r rF r- r r r rU r s
zResult._as_queryc C s t | �� �S r
)�strrU �r r r r �__str__x � zResult.__str__c C � | � � �� S r
)�_iter�__iter__rs r r r rx { ru zResult.__iter__c C s� | j }| jjr
|jr| �� �� S |j�|�| j�d�\}}|d u r)|� | j�\}}| j
r3|� | j
�}n|}| j D ]}||�}q8|j
}t
|j�}|�|j|jd�� | jj|||d�}|j�dd�re|�� }|j�dd�rp|�� }|S )N)NN)�_sa_orm_load_options�compiled_cache)�execution_options�is_single_entityF�filtered)rg r9 �enable_baked_queriesr rU rw r rT rA r\ rh rm ri �dict�_execution_optionsrk � load_options�execute� _attributes�scalars�unique) r rg rW r[ rF r- rm r{ �resultr r r rw ~ s8 �
���z Result._iterc s: t �td��� | j�� fdd��}|�| 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
)�_legacy_from_selfrJ ��colr r rL � s
z Result.count.<locals>.<lambda>)
r �countr rg r4 r: r9 rm rh �scalar�r rg r r� r r� � s
z Result.countc C s< z| � � }t|tj�s|W S |d W S tjy Y dS w )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_exc�
NoResultFound)r �retr r r r� � s
�z
Result.scalarc C s4 | j �dd� �}|�| j��| j��| j��� � � S )zRReturn the first row.
Equivalent to :meth:`_query.Query.first`.
c S s | � dd�S rc )�slicerJ r r r rL � s z Result.first.<locals>.<lambda>)
rg r4 r: r9 rm rh rp ri rw �firstr� r r r r� � s
�z Result.firstc C rv )zkReturn exactly one result or raise an exception.
Equivalent to :meth:`_query.Query.one`.
)rw r� rs r r r r� � � z
Result.onec C rv )z�Return one or zero results, or raise an exception for multiple
rows.
Equivalent to :meth:`_query.Query.one_or_none`.
)rw � one_or_noners r r r r� � s zResult.one_or_nonec C rv )zKReturn all rows.
Equivalent to :meth:`_query.Query.all`.
)rw �allrs r r r r� � r� z
Result.allc C s | j jd | j�}|�|| j�S )z`Retrieve an object based on identity.
Equivalent to :meth:`_query.Query.get`.
r )rg r r9 � _get_impl�_load_on_pk_identity)r �identrW r r r rT � s z
Result.getc
s� |j d jd ��j\� �� ����fdd�}�j}|�� }| j� f7 _|�|tdd� �D ���}�fdd�t��j �D �}t
|� �j �j
d i |���}t|�} | d krZt�� �| r`|d S d
S ) z6Load the given primary key identity from the database.r � parententityc st � }| � � }|�� d |_d �v r$�fdd�t�j��D �}t�||�}t�|ddi�f|_�j D ]}||�}q1|S )Nc s" h | ]
\}}|d u r� | j �qS r
�rQ )�.0r� �value�� _get_paramsr r � <setcomp> s
�z=Result._load_on_pk_identity.<locals>.setup.<locals>.<setcomp>�
_orm_adaptT)
r* �_get_condition� _order_by�zip� primary_key�sql_util�adapt_criterion_to_null�_deep_annotate�_where_criteriari )rW �_lcl_get_clauserF �nonesr- �� _get_clauser� �mapper�primary_key_identityr r r �setup� s$
����
z*Result._load_on_pk_identity.<locals>.setupc s s � | ]}|d u V qd S r
r )r� �elemr r r � <genexpr>& s � z.Result._load_on_pk_identity.<locals>.<genexpr>c s i | ]
\}}� | j |�qS r r� )r� �id_valr� r� r r �
<dictcomp>) s
��z/Result._load_on_pk_identity.<locals>.<dictcomp>rH Nr )� _raw_columns� _annotationsr� rg r* r r4 r/ r� r� r( r: r9 rm rj r� �MultipleResultsFound)
r r9 rW r� rl r� rg rm r� �lr r� r r� � s*
�
�� zResult._load_on_pk_identityN)r r r r r r rm rp rq rU rt rx rw r� r� r� r� r� r� rT r� r r r r r7 6 s&
'
r7 )r �collections.abc�abcr� �logging� r r] r �ormr� � orm.queryr � orm.sessionr �sqlr r r� � getLoggerr �logr r r7 r! r r r r �<module> s&
~