|
Server : Apache System : Linux iad1-shared-b8-43 6.6.49-grsec-jammy+ #10 SMP Thu Sep 12 23:23:08 UTC 2024 x86_64 User : dh_edsupp ( 6597262) PHP Version : 8.2.26 Disable Function : NONE Directory : /lib/python3/dist-packages/django/db/models/sql/__pycache__/ |
Upload File : |
o
��Ih� � @ s d Z ddlZddlZddlZddlZddlZddlZddlmZm Z ddl
m Z m Z ddl
mZmZmZ ddlmZ ddlmZmZ ddlmZmZmZ dd lmZ dd
l m Z dd l m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z% dd l&m'Z' dd
l(m)Z) ddl*m+Z+ ddl,m-Z-m.Z.m/Z/ ddl0m1Z1m2Z2m3Z3m4Z4m5Z5 ddl6m7Z7m8Z8m9Z9m:Z: ddl;m<Z<m=Z=m>Z>m?Z?m@Z@ ddlAmBZB ddlCmDZD ddlEmFZF ddlGmHZH ddgZIeFd�ZJeFd�ZKdd � ZLd d � ZMe d d �ZNG d!d� d�ZOG d"d� de �ZPd,d$d%�ZQd&d'� ZRd(d)� ZSG d*d+� d+�ZTdS )-aW
Create SQL statements for QuerySets.
The code in here encapsulates all of the SQL construction so that QuerySets
themselves do not have to (and could be backed by things other than SQL
databases). The abstraction barrier only works one way: this module has to know
all about the internals of models in order to get the information it needs.
� N)�Counter�
namedtuple)�Iterator�Mapping)�chain�count�product)�ascii_uppercase)�FieldDoesNotExist�
FieldError)�DEFAULT_DB_ALIAS�NotSupportedError� connections)�Count)�
LOOKUP_SEP)�BaseExpression�Col�Exists�F�OuterRef�Ref�ResolvedOuterRef)�Field)�MultiColSource)�Lookup)�Q� check_rel_lookup_compatibility�refs_expression)�INNER�LOUTER� ORDER_DIR�
ORDER_PATTERN�SINGLE)� BaseTable�Empty�Join� MultiJoin)�AND�OR�
ExtraWhere� NothingNode� WhereNode)�RemovedInDjango40Warning)�cached_property)�_lazy_re_compile)�Node�Query�RawQueryz['`\"\]\[;\s]|--|/\*|\*/z[\w\-]+c C s t t�dd� | �� D ���S )Nc s s* � | ]}|j r
|j|jfn|jfV qd S �N)�concrete�name�attname��.0�f� r9 �</usr/lib/python3/dist-packages/django/db/models/sql/query.py� <genexpr>; s
� �
�z,get_field_names_from_opts.<locals>.<genexpr>)�setr �
from_iterable�
get_fields)�optsr9 r9 r: �get_field_names_from_opts: s
�r@ c c s2 � | j D ]}t|t�rt|�E d H q|V qd S r2 )�children�
isinstancer/ �get_children_from_q)�q�childr9 r9 r: rC A s �
�rC �JoinInfo)� final_field�targetsr? �joins�path�transform_functionc @ s^ e Zd ZdZddd�Zdd� Zdd� Zd d
� Zd d � Zd
d� Z e
dd� �Z dd� Z dd� Z
dS )r1 zA single raw SQL query.r9 c C s4 || _ || _|| _d | _d\| _| _i | _i | _d S )N�r N)�params�sql�using�cursor�low_mark� high_mark� extra_select�annotation_select)�selfrN rO rM r9 r9 r: �__init__R s
zRawQuery.__init__c C s
| � |�S r2 ��clone�rU rO r9 r9 r: r ^ s
zRawQuery.chainc C s t | j|| jd�S )N)rM )r1 rN rM rY r9 r9 r: rX a � zRawQuery.clonec s6 | j d u r | �� t| j jj� � fdd�| j jD �S )Nc s g | ]}� |d ��qS �r r9 )r7 � column_meta�� converterr9 r: �
<listcomp>h s �z(RawQuery.get_columns.<locals>.<listcomp>)rP �_execute_queryr rO �
introspection�identifier_converter� description�rU r9 r] r: � get_columnsd s
�zRawQuery.get_columnsc C s6 | � � t| j jjst| j�}t|�S | j}t|�S r2 )r` r rO �features�can_use_chunked_reads�listrP �iter)rU �resultr9 r9 r: �__iter__k s
�zRawQuery.__iter__c C s d| j j| f S )Nz<%s: %s>)� __class__�__name__rd r9 r9 r: �__repr__w s zRawQuery.__repr__c C s" | j d u rd S t| j t�rtS tS r2 )rM rB r �dict�tuplerd r9 r9 r: � params_typez s
zRawQuery.params_typec C s" | j d u r| jS | j| � | j� S r2 )rq rN rM rd r9 r9 r: �__str__� s
zRawQuery.__str__c s� t | j }| j}|jj� |tu r t� fdd�| jD ��}n |tu r.� fdd�| j�� D �}n
|d u r5d }nt d| ��|�
� | _
| j
� | j |� d S )Nc 3 s � | ]}� |�V qd S r2 r9 )r7 �val��adapterr9 r: r; � � � z*RawQuery._execute_query.<locals>.<genexpr>c s i | ] \}}|� |��qS r9 r9 )r7 �keyrs rt r9 r: �
<dictcomp>� s z+RawQuery._execute_query.<locals>.<dictcomp>zUnexpected params type: %s)
r rO rq �ops�adapt_unknown_valuerp rM ro �items� RuntimeErrorrP �executerN )rU �
connectionrq rM r9 rt r: r` � s
zRawQuery._execute_queryN)r9 )rm �
__module__� __qualname__�__doc__rV r rX re rk rn �propertyrq rr r` r9 r9 r9 r: r1 O s
c @ s` e Zd ZdZdZeeg�ZdZedfdd�Z e
dd� �Z e
d d
� �Z e
d d � �Zd
d� Zdd� Zdd� Zd�dd�Zdd� Zdd� Zd�dd�Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd�d(d)�Z d*d+� Z d�d,d-�Z d.d/� Z d0d1� Z d�d3d4�Z!d5d6� Z"d�d8d9�Z#d:d;� Z$d<d=� Z%d>d?� Z&d@dA� Z'dBdC� Z(dDdE� Z)dFdG� Z*d�dHdI�Z+dJdK� Z,dLdM� Z-d�dNdO�Z.dPdQ� Z/dRdS� Z0d�dTdU�Z1dVdW� Z2dXdY� Z3dZd[� Z4d\d]� Z5d^d_� Z6d`da� Z7dbdc� Z8ddde� Z9 2 d�dfdg�Z:dhdi� Z;djdk� Z<dldm� Z= 2 d�dndo�Z>d�dpdq�Z?drds� Z@d�dtdu�ZA 2d�dvdw�ZBdxdy� ZCeDd�dzd{��ZEeDd|d}� �ZFd�d~d�ZGd�d�� ZHd�d�� ZId�d�� ZJd�d�d��ZKd�d�� ZLe
d�d�� �ZMd�d�� ZNd�d�� ZOd�d�� ZPd�d�� ZQd�d�� ZRd�d�� ZSd�d�� ZTd�d�d��ZUd�d�� ZVd�d�d��ZWd�d�d��ZXd�d�� ZYd�d�� ZZd�d�� Z[d�d�� Z\d�d�� Z]d�d�� Z^d�d�� Z_d�d�� Z`d�d�� Zad�d�� Zbd�d�� Zce
d�d�� �Zde
d�d�� �Zed�d�� Zfd�d�� ZgdS )�r0 zA single SQL query.�T� SQLCompilerTc C s || _ i | _i | _|| _i | _i | _d| _d| _d| _t � | _
d| _ d| _ d| _
|� | _|| _d | _d| _d\| _| _d| _d| _d| _d| _d| _d| _d| _d| _d| _ d| _ i | _ d | _ d | _ d | _!d| _"d| _#i | _$d | _%d | _&d| _'d| _(t)� df| _*i | _+d| _,d | _-i | _.d S )NTFr9 rL � )/�model�alias_refcount� alias_map�
alias_cols�external_aliases� table_map� default_cols�default_ordering�standard_orderingr< � used_aliases�filter_is_sticky�subquery�select�where� where_class�group_by�order_byrQ rR �distinct�distinct_fields�select_for_update�select_for_update_nowait� select_for_update_skip_locked�select_for_update_of�select_for_no_key_update�select_related� max_depth�
values_select� annotations�annotation_select_mask�_annotation_select_cache�
combinator�combinator_all�combined_queries�extra�extra_select_mask�_extra_select_cache� extra_tables�extra_order_by� frozenset�deferred_loading�_filtered_relations�
explain_query�explain_format�explain_options)rU r� r� r� r9 r9 r: rV � sX
zQuery.__init__c C sP t | j�dkr| jd }t|dd �p|jS t | j�dkr&tt| j�� ��jS d S )N� r �target) �lenr� �getattr�fieldrT �nextri �values� output_field)rU r� r9 r9 r: r� � s
�zQuery.output_fieldc C s t | jp | jp | j�S r2 )�boolr� r� r� rd r9 r9 r: �has_select_fields � zQuery.has_select_fieldsc C s | j D ]}| S d S r2 )r� �rU �aliasr9 r9 r: �
base_table s
�zQuery.base_tablec C s | � � \}}|| S )a(
Return the query as a string of SQL with the parameter values
substituted in (use sql_with_params() to see the unsubstituted string).
Parameter values won't necessarily be quoted correctly, since that is
done by the database interface at execution time.
)�sql_with_params)rU rN rM r9 r9 r: rr
s z
Query.__str__c C s | � t��� S )zw
Return the query as an SQL string and the parameters that will be
substituted into the query.
)� get_compilerr �as_sqlrd r9 r9 r: r� s zQuery.sql_with_paramsc C s | � � }||t| �< |S )z4Limit the amount of work when a Query is deepcopied.)rX �id)rU �memorj r9 r9 r: � __deepcopy__ s zQuery.__deepcopy__Nc C s: |d u r |d u r t d��|rt| }|j�| j�| ||�S )Nz Need either using or connection)�
ValueErrorr ry �compiler)rU rO r~ r9 r9 r: r� " s
zQuery.get_compilerc C s | j jS )z�
Return the Options instance (the model._meta) from which to start
processing. Normally, this is self.model._meta, but it can be changed
by subclasses.
)r� �_metard r9 r9 r: �get_meta) � zQuery.get_metac C sJ t � }| j|_| j�� |_| j�� |_| j�� |_| j�� |_| j�� |_| j� � |_| j
�� |_
| j du r:d|_ n| j �� |_ t dd� | j
D ��|_
d|_| j�� |_| jdu r]d|_n| j�� |_| jdu rld|_n| j�� |_| jdur~t�|j�|_d| jv r�| j�� |_| j�� |_| j�� |_z|`W |S ty� Y |S w )zi
Return a copy of the current Query. A lightweight alternative to
to deepcopy().
Nc s s � | ]}|� � V qd S r2 rW )r7 �queryr9 r9 r: r; E rv z Query.clone.<locals>.<genexpr>F� subq_aliases)r$ rl �__dict__�copyr� r� r� r� r� rX r� r� rp r� r� r� r� r� r� �deepcopyr� r� r� r� �AttributeError)rU �objr9 r9 r: rX 1 sD
��z Query.clonec C sF | � � }|r|j|kr||_|jst� |_d|_t|d�r!|�� |S )z�
Return a copy of the current Query that's ready for another operation.
The klass argument changes the type of the Query, e.g. UpdateQuery.
F� _setup_query)rX rl r� r< r� �hasattrr� )rU �klassr� r9 r9 r: r d s
z Query.chainc C s | � � }|�|� |S r2 )rX �change_aliases)rU �
change_maprX r9 r9 r: �relabeled_clones s
zQuery.relabeled_clonec C s | j sd }|�||�S r2 �r� �get_col)rU r� r� r� r9 r9 r: �_get_colx s zQuery._get_colc C s� |� � }g }|D ]h}t|t�r|�|� qt|ttf�r*| �||�\}}|�|� q| j�� D ]\}}||u r>t||�} n-q/t|t �sJ|j
rc|j sc|d7 }d| }|| j |< | �
|g� t||�}n| �||�\}}|�|� q|�|� ||fS )Nr� z__col%d)�get_source_expressionsrB r �appendr+ r � rewrite_colsrT r{ r �contains_aggregate�
is_summaryr� �append_annotation_mask�set_source_expressions) rU �
annotation�col_cnt�
orig_exprs� new_exprs�expr�new_expr� col_alias�selected_annotationr9 r9 r: r� } s.
�
zQuery.rewrite_colsc s | j si S � fdd�| j�� D �}t| jt�s"| js"|s"| js"| jr�ddl m
} | � � }d|_ || j
|�}d|_d|_|�| j � |jdd� |jsgtdd � |D ��}|jrd|rd| j
jj�|�� �f|_d|_d
d � |jD �}d |d
< d} t|j �� �D ])\}
} |j} | jr�|� | | �\} } | � |�|j|
< |j|
= | � |
� |�|j� q||j dkr�|js�|js�| j
jj�|�� �f|_ n | }d| _ d| _i | _ |jdd� |�!� d|_d|_|�"|�}
|
�#t$�}|d
u r�d
gt%|j � }|
�&|j �'� �}t(|
�)|f|��}t*t+|j |��S )zU
Return the dictionary with the values of the existing aggregations.
c s g | ]
\}}|� vr|�qS r9 r9 )r7 r� r� ��added_aggregate_namesr9 r: r_ � s
�z)Query.get_aggregation.<locals>.<listcomp>r )�AggregateQueryTF��forcec s s � | ] }t |d d�r|V qdS )r� TN)r� )r7 r� r9 r9 r: r; � s �
�
�z(Query.get_aggregation.<locals>.<genexpr>c S s i | ]}|d �qS )r� r9 �r7 �tr9 r9 r: rx � � z)Query.get_aggregation.<locals>.<dictcomp>r� Nr9 ),rT r� r{ rB r� rp � is_slicedr� r� � django.db.models.sql.subqueriesr� rX r� r� r� r� �set_annotation_mask�clear_ordering�anyr� r� �pkr� �get_initial_aliasr� rh r� r� r� r� �remover� r� � clear_limitsr� � execute_sqlr" r� �get_convertersr� r� �apply_convertersro �zip)rU rO r� �existing_annotationsr� � inner_query� outer_query�"has_existing_aggregate_annotations�relabelsr� r� �
expressionr� r� rj �
convertersr9 r� r: �get_aggregation� sl
��� �
�
zQuery.get_aggregationc C s> | � � }|jtd�ddd� |�|dg�d }|du r d}|S )zO
Perform a COUNT() query using the current filter constraints.
�*�__countT)r� r� Nr )rX �add_annotationr r )rU rO r� �numberr9 r9 r: � get_count s zQuery.get_countc C s | j S r2 )r� rd r9 r9 r: � has_filters s zQuery.has_filtersc s� | � � }|js$|jdu r |�dd� | jjjD �d� |jdd� |�� |j r@|j
dkr@t � j j
� t� �fdd�|j D ��|_ |jdd� |rN|jd d
� |�d d id d d d d � |�d g� |S ) NTc s � � | ]}|j V qd S r2 �r5 r6 r9 r9 r: r; � � z Query.exists.<locals>.<genexpr>F��
allow_aliases�unionc 3 s � | ]
}|j �� d �V qdS ))�limitN)�exists)r7 �combined_query��limit_combinedrO r9 r: r; " �
� �
�r� r� )�high�a)rX r� r� �
add_fieldsr� r� �concrete_fields� set_group_by�clear_select_clauser� r� r rf �%supports_slicing_ordering_in_compoundrp r� �
set_limits� add_extra�set_extra_mask)rU rO r rD r9 r r: r s"
� z Query.existsc C s | � |�}|j|d�}|�� S )N�rO )r r� � has_results)rU rO rD r� r9 r9 r: r$ - s
zQuery.has_resultsc K s` | � � }|D ]}t�|�rd|v rtd|�d���qd|_||_||_|j|d�}d�|�� �S )Nz--zInvalid option name: �.Tr# �
) rX �EXPLAIN_OPTIONS_PATTERN� fullmatchr� r� r� r� r� �join)rU rO �format�optionsrD � option_namer� r9 r9 r: �explain2 s �� z
Query.explainc
s* �j |j ks
J d���jrJ d���j|jksJ d���j|jks%J d��i � |tk}|r0t� nt�j�}��� t|dd�}|� �fdd��jD �� t� }t
|j�d d
� }|D ]4}|j| } | � � �} �j | |d �}
| j
tkrw|�|
� |�|
� ||
kr�|
� |< |j| s���|
� qZ|� |� |��� � j|jO _|j�� } | �� � �j�| |� |jr�� fd d
�|jD �� nd�_|tkrԈjr�|jr�t d���j� |j� t� } �j d
ur�| � �j � |j d
ur�| � |j � | r��� | � � j |j 7 _ |j!�p �j!�_!|j"�p�j"�_"d
S )aN
Merge the 'rhs' query into the current one (with any 'rhs' effects
being applied *after* (that is, "to the right of") anything in the
current query. 'rhs' is not modified during a call to this function.
The 'connector' parameter describes how to connect filters from the
'rhs' query.
z4Cannot combine queries on two different base models.z3Cannot combine queries once a slice has been taken.z6Cannot combine a unique query with a non-unique query.z6Cannot combine queries with different distinct fields.� Fc 3 s$ � | ]
}� j | jtkr|V qd S r2 �r� � join_typer )r7 �jrd r9 r: r; g s � �z Query.combine.<locals>.<genexpr>r� N)�reusec � g | ]}|� � ��qS r9 �r� �r7 �col�r� r9 r: r_ � � z!Query.combine.<locals>.<listcomp>r9 zSWhen merging querysets using 'or', you cannot have extra(select=...) on both sides.)#r� r� r� r� r' r< r� r� � JoinPromoter� add_votesrh r� r) r0 r �add�discardr� � unref_alias�update_join_typesr� r� rX �relabel_aliasesr� �
set_selectr( r� r� �updater� r" r� r� r� )
rU �rhs� connector� conjunctionr2 � joinpromoter� rhs_votes�
rhs_tablesr� r) � new_alias�wr� r9 )r� rU r: �combine@ sr ���� �
�
z
Query.combinec C s | j \}}|s dS | �� }i }|j|jhi}|D ]u}|�t�} | jjj}
|} | dd� D ]5} |
}
| | jv r;| j| j } | �
| �}t |�rH|j }
n|j
j}
|
j} t |�sZ||
�|� t||
| j� q,| �
| d �}|joo|j }|ru|j n|j}|jj}|| jkr�|
}t |�s�t|||� q|r�i }|�� D ]\}}|jjD ]}||vr�|jjj}t|||� q�q�|�� D ]\}}||v r�|| �|� q�|�� D ]
\}}||||� q�dS |�� D ]\}}||v r�|| �|� q�|||< q�|�� D ] }|�|t� � q�|�� D ] \}}||||� �qdS )a
Convert the self.deferred_loading data structure to an alternate data
structure, describing the field that *will* be loaded. This is used to
compute the columns to select from the database and also by the
QuerySet class to work out which fields are being initialized on each
model. Models that have all their fields included aren't mentioned in
the result, only those that have field restrictions in place.
The "target" parameter is the instance that is populated (in place).
The "callback" is a function that is called whenever a (model, field)
pair need to be added to "target". It accepts three parameters:
"target", and the model and list of fields being added for that model.
N���)r� r� �concrete_modelr� �splitr r� r� r� �
relation_name� get_field�is_reverse_o2o�
related_model� remote_fieldr; � add_to_dict� auto_createdr3 r{ � local_fieldsrA �get_parent_list�
setdefaultr< )rU r� �callback� field_names�defer� orig_opts�seen� must_include�
field_name�parts� cur_modelr? r4 � old_model�sourcer� �is_reverse_objectr� �worksetr� �mr9 r9 r: �deferred_to_data� sp
�
����
�zQuery.deferred_to_dataFc C s� | j �|�}|s|r|d }| j| d7 < |dfS |r/d| jt| j�d f }|�|� n|dur6|jn|}|g| j |< d| j|< |dfS )a
Return a table alias for the given table_name and whether this is a
new alias or not.
If 'create' is true, a new alias is always created. Otherwise, the
most recently created alias for the table (if one exists) is reused.
r r� F�%s%dNT)r� �getr� � alias_prefixr� r� r� r� )rU �
table_name�create�filtered_relation�
alias_listr� r9 r9 r: � table_alias� s
zQuery.table_aliasc C s | j | d7 < dS )z-Increases the reference count for this alias.r� N�r� r� r9 r9 r: � ref_alias r� zQuery.ref_aliasr� c C s | j | |8 < dS )z-Decreases the reference count for this alias.Nro )rU r� �amountr9 r9 r: r= r� zQuery.unref_aliasc s� t ����r]��d�� �j� jdu rq�j� jdus J ��j� j}|o-�j| jtk}�j� jtk}�j� js>|rY|sY�j� �� �j� < ��� ��fdd��jD �� �sdS dS )a
Promote recursively the join type of given aliases and its children to
an outer join. If 'unconditional' is False, only promote the join if
it is nullable or the parent join is an outer join.
The children promotion is done to avoid join chains that contain a LOUTER
b INNER c. So, if we have currently a INNER b INNER c and a->b is promoted,
then we must also promote b->c automatically, or otherwise the promotion
of a->b doesn't actually change anything in the query results.
r Nc 3 s, � | ]}�j | j� kr|�vr|V qd S r2 )r� � parent_alias)r7 r) �r� �aliasesrU r9 r: r; = s � ��z&Query.promote_joins.<locals>.<genexpr>) rh �popr� r0 rr r �nullable�promote�extend)rU rt rr �
parent_louter�already_louterr9 rs r: �
promote_joins s"
�� �zQuery.promote_joinsc C sl t |�}|r4|�d�}| j| jtkr0| j| �� | j|< | j| j}| j| jtkr0|�|� |sdS dS )a�
Change join type from LOUTER to INNER for all joins in aliases.
Similarly to promote_joins(), this method must ensure no join chains
containing first an outer, then an inner join are generated. If we
are demoting b->c join in chain a LOUTER b LOUTER c then we must
demote a->b automatically, or otherwise the demotion of b->c doesn't
actually change anything in the query results. .
r N) rh ru r� r0 r �demoterr r r� )rU rt r� rr r9 r9 r: � demote_joinsB s
�zQuery.demote_joinsc C s8 | j �� �� D ]\}}||�|d� }| �||� qdS )zp
Reset reference counts for aliases so that they match the value passed
in `to_counts`.
r N)r� r� r{ rh r= )rU � to_countsr� � cur_refcount� unref_amountr9 r9 r: �reset_refcountsU s �zQuery.reset_refcountsc s* t � ��� �� �s J �| j�� � t| jt�r$t� fdd�| jD ��| _t� fdd�| jD ��| _| j o?� fdd�| j �
� D �| _ � �
� D ]@\}}|| j vrOqE| j | � � �}|| j |< | j
| | j
|< | j
|= | j |= | j|j }t|�D ]\}}||kr�|||< nqvqE� fdd�| j�
� D �| _dS )z�
Change the aliases in change_map (which maps old-alias -> new-alias),
relabelling any references to them in select columns and the where
clause.
c r3 r9 r4 r5 r7 r9 r: r_ j r8 z(Query.change_aliases.<locals>.<listcomp>c r3 r9 r4 r5 r7 r9 r: r_ k r8 c s i | ]
\}}||� � ��qS r9 r4 )r7 rw r6 r7 r9 r: rx l s �z(Query.change_aliases.<locals>.<dictcomp>c s& i | ]\}}� � ||�|p|� v �qS r9 �rh )r7 r� �aliasedr7 r9 r: rx s ��N)r< �
isdisjointr� r� r? rB r� rp r� r� r{ r� r� r� r� rj � enumerater� )rU r� � old_aliasrH �
alias_data�
table_aliases�posr� r9 r7 r: r� ^ s4 �
��
�zQuery.change_aliasesc s� � fdd�}� j |j krdS t�� d }t|� �D ]\}}|� jvr'|� _ n ||kr/td��q� j�� j g�� _|j�� j�|_� �� fdd�t� j�D �� dS )a
Change the alias prefix to the next letter in the alphabet in a way
that the outer query's aliases and this query's aliases will not
conflict. Even tables that previously had no alias will get an alias
after this call.
c 3 sl � t } tt� j�d �}|V td�D ] }|r | | �|�d� n| }t||d�D ]}d�|�V q(d}qdS )a
Generate a sequence of characters in alphabetical order:
-> 'A', 'B', 'C', ...
When the alphabet is finished, the sequence will continue with the
Cartesian product:
-> 'AA', 'AB', 'AC', ...
r� N)�repeat� )r �chr�ordri r �indexr r) )�alphabet�prefix�n�seq�srd r9 r: �
prefix_gen� s � �z%Query.bump_prefix.<locals>.prefix_genN� z6Maximum recursion depth exceeded: too many subqueries.c s i | ] \}}|d � j |f �qS )rg )ri )r7 r� r� rd r9 r: rx � s ��z%Query.bump_prefix.<locals>.<dictcomp>) ri �sys�getrecursionlimitr� r� �RecursionErrorr r� r� )rU r r� �local_recursion_limitr� r� r9 rd r: � bump_prefix� s$
�� �zQuery.bump_prefixc C s4 | j r
| j}| �|� |S | �t| �� jd��}|S )zf
Return the first alias for this query, after increasing its reference
count.
N)r� r� rp r) r# r� �db_tabler� r9 r9 r: r� � s
�zQuery.get_initial_aliasc C s t dd� | j�� D ��S )z�
Return the number of tables in this query with a non-zero reference
count. After execution, the reference counts are zeroed, so tables
added in compiler will not be seen by this method.
c S s g | ]}|rd �qS �r� r9 )r7 r r9 r9 r: r_ � � z-Query.count_active_tables.<locals>.<listcomp>)r� r� r� rd r9 r9 r: �count_active_tables� s zQuery.count_active_tablesc s� |r�r� �fdd�| j �� D �}n
� �fdd�| j �� D �}|r5� j|v r*� j}n|d }| �|� |S | j� jd� jd�\}}� jrX| j � j jtksP� j rSt}nt
}|� _|� _� | j |< |S )a�
Return an alias for the 'join', either reusing an existing alias for
that join or creating a new one. 'join' is either a
sql.datastructures.BaseTable or Join.
The 'reuse' parameter can be either None which means all joins are
reusable, or it can be a set containing the aliases that can be reused.
The 'reuse_with_filtered_relation' parameter is used when computing
FilteredRelation instances.
A join is always created as LOUTER if the lhs alias is LOUTER to make
sure chains like t1 LOUTER t2 INNER t3 aren't generated. All new
joins are created as LOUTER if the join is nullable.
c s* g | ]\}}|�v r|j � d d�r|�qS )F)�with_filtered_relation)�equals�r7 r r1 �r) r2 r9 r: r_ � s
�z Query.join.<locals>.<listcomp>c s, g | ]\}}�d u s|�v r|� kr|�qS r2 r9 r� r� r9 r: r_ � s
�rK T)rk rl ) r� r{ rn rp rj rl r0 rr r rv r ) rU r) r2 � reuse_with_filtered_relation�
reuse_aliases� reuse_aliasr� �_r0 r9 r� r: r) � s, � �
z
Query.joinc
C s� ||v r|| S |� |�}|s|S |}|D ]1}||v r#|j}|| }q|j| s,|j}q|�|�}| �|jg||�} |j}| jd }||< q|pL|d S )a}
Make sure the given 'model' is joined in the query. If 'model' isn't
a parent of 'opts' or if it is None this method is a no-op.
The 'alias' is the root alias for starting the join, 'seen' is a dict
of model -> alias of existing joins. It must also contain a mapping
of None -> some alias. This will be returned in the no-op case.
rK N)�get_base_chainr� �parents�get_ancestor_link� setup_joinsr4 rI )
rU r? r� r� r\ r � curr_opts� int_model�
link_field� join_infor9 r9 r: �join_parent_model� s&
zQuery.join_parent_modelc C s t �|�r td��d S )NzbColumn aliases cannot contain whitespace characters, quotation marks, semicolons, or SQL comments.)�FORBIDDEN_ALIAS_PATTERN�searchr� r� r9 r9 r: � check_alias s
��zQuery.check_aliasc C sT | � |� |j| dd|d�}|r| �|g� n | �t| j��|h�� || j|< dS )z0Add a single annotation expression to the Query.TN)� allow_joinsr2 � summarize)r� �resolve_expressionr� r� r< rT �
differencer� )rU r� r� r� r� r9 r9 r: r " s
�zQuery.add_annotationc
O s� | � � }|�|� d|_| jdkr"| jd u r"| js"| js"|jdd� |jj |g|�R i |�� |j
� � D ]!\}}|j |g|�R i |��}t |d�rP|j
�|j
� ||j
|< q4|j� � D ] \}} t| t�rl| jjjj|kpvt| t�ov| j| jk|j
|< q[|S )NTr r� r� )rX r� r� rQ rR r� r� r� r� r� r� r{ r� r� rA r� rB r% �
join_fieldrQ r� r� r# rj rn )
rU r� �args�kwargsrX rw �value�resolvedr� �tabler9 r9 r: r� - s(
��
�zQuery.resolve_expressionc s0 t � j�� � jj�}� fdd�� j|dd�D �S )Nc s g | ]
}|j � jv r|�qS r9 )r� r� r5 rd r9 r: r_ H s
�z+Query.get_external_cols.<locals>.<listcomp>T��include_external)r r� r� r� rA � _gen_cols)rU �exprsr9 rd r: �get_external_colsF s
�zQuery.get_external_colsc C s4 |rt || �gS | �� }tdd� |D ��r| gS |S )Nc s r
r2 )�possibly_multivaluedr5 r9 r9 r: r; Q r z*Query.get_group_by_cols.<locals>.<genexpr>)r r� r� )rU r� �
external_colsr9 r9 r: �get_group_by_colsM s zQuery.get_group_by_colsc C s* | j |d��� \}}| jrd| }||fS )N)r~ z(%s))r� r� r� )rU r� r~ rN rM r9 r9 r: r� U s z Query.as_sqlc sh t |d�r|j��� d�}|S t|ttf�r2� ��fdd�|D �}t|�}t |d�r.||� S ||�S |S )Nr� )r2 r� c 3 s � | ]
}�� |�� �V qd S r2 )�resolve_lookup_value)r7 � sub_value�r� � can_reuserU r9 r: r; c r z-Query.resolve_lookup_value.<locals>.<genexpr>�_make)r� r� rB rh rp �type)rU r� r� r� r� �type_r9 r� r: r� [ s
���
zQuery.resolve_lookup_valuec C s� |� t�}| jrt|| j�\}}|r|d|fS | �|| �� �\}}}}|dt|�t|� � }t|�dkrC|sCtd|| �� jj f ��||dfS )zX
Solve the lookup type from the lookup (e.g.: 'foobar__id__icontains').
r9 r r� z"Invalid lookup "%s" for model %s".F)
rM r r� r �
names_to_pathr� r� r r� rm ) rU �lookup�lookup_splittedr �expression_lookupsr� r� � lookup_parts� field_partsr9 r9 r: �solve_lookup_typem s
��
zQuery.solve_lookup_typec C s4 t |d�rt|jj||�std||jf ��dS dS )z�
Check whether the object passed while querying is of the correct type.
If not, raise a ValueError specifying the wrong object.
r� z)Cannot query "%s": Must be "%s" instance.N)r� r r� r� r� � object_name)rU r� r? r� r9 r9 r: �check_query_object_type s
���z Query.check_query_object_typec C s� |j r=t|t�r |js t|j||�s td|jjj|jf ��t |d�r,| �
|||� dS t |d�r?|D ]
}| �
|||� q3dS dS dS )z3Check the type of object passed to query relations.z6Cannot use QuerySet for "%s": Use a QuerySet for "%s".r� rk N) � is_relationrB r0 r� r r� r� r� r� r� r� )rU r� r� r? �vr9 r9 r: �check_related_objects� s" ���
�zQuery.check_related_objectsc C sP t |d�rt|dd�st|jjd ��t |d�r$|�� D ] }| �|� q dS dS )z>Raise an error if expression cannot be used in a WHERE clause.r� �
filterableTz$ is disallowed in the filter clause.r� N)r� r� r
rl rm r� �check_filterable)rU r r� r9 r9 r: r� � s �
�
�
�zQuery.check_filterablec C s� |pdg�^ }}|D ]}| � ||�}q
|�|�}|s6|jjr%td�|���| � ||�}d}|�|�}|s6dS |||�}|jdu rS|jsS|dvrKtd��|�d�|d�S t t
j j rj|dkrj|jdkrj|�d�|d�S |S ) a1
Try to extract transforms and lookup from given lhs.
The lhs value is something that works like SQLExpression.
The rhs value is what the lookup is going to compare against.
The lookups is a list of names to extract using get_lookup()
and get_transform().
�exact�$Related Field got invalid lookup: {}N)r� �iexactz Cannot use None as a query value�isnullTr� )
�
try_transform�
get_lookupr� r� r r* rB �can_use_none_as_rhsr� r r rf �!interprets_empty_strings_as_nulls) rU �lookups�lhsrB �
transforms� lookup_namer4 � lookup_classr� r9 r9 r: � build_lookup� s*
zQuery.build_lookupc C sZ |� |�}|r ||�S |jj}t�||�� �}|r!dd�|� }nd}td||j|f ��)z�
Helper method for build_lookup(). Try to fetch and initialize
a transform for name parameter from lhs.
z, perhaps you meant %s?z or r% zCUnsupported lookup '%s' for %s or join on the field not permitted%s) �
get_transformr� rl �difflib�get_close_matches� get_lookupsr) r rm )rU r� r4 �transform_classr� �suggested_lookups�
suggestionr9 r9 r: r� � s
��zQuery.try_transformc
s� t |t�r td��t |t�r| j|||||||d�S t|d�rDt|dd�s)td��| �dg|j | |d�d �} | �
� }
|
� | t � |
g fS |\} } | sPtd
| ��| �
| �\}
}}|r_| �|� |skt|�d krktd ��| j�� � | �| ||�} � fd
d�| j�� D �}|r�| �| � | �
� }
|r�| �|
|| �} |
� | t � |
g fS | �� }| �� }| p�| }z#| j||||||d�}t | t�r�t| �} | �|j| |j� |j | _ W n t y� } z| � |||j �W Y d}~S d}~ww |�!|j � | �"|j#|j |j$�\}}}|du�r
|�!|� |jj%�r=t|
�}|d k�r!td�&|
d ���t|�d k�r3| �'|d |j|�}nt(|||j#|j�}n
| �'|d |j|�}| �|
|| �} | j)}|
� | t � |dk�od| j*d u �od| }|�r�|dk�ss| j*du �r�| j*du�r�d }|dk�r�| �+|d ��s�| j,|d j-t.k�r�|d �/d�} | �'|d |j#d |�}|
� | |d�t � t | t0��r�| �+| j1��r�| j1�/d�} |
� | | d�t � |
|�s�|fS dfS )a�
Build a WhereNode for a single filter clause but don't add it
to this Query. Query.add_q() will then add this filter to the where
Node.
The 'branch_negated' tells us if the current branch contains any
negations. This will be used to determine if subqueries are needed.
The 'current_negated' is used to determine if the current filter is
negated or not and this will be used to determine if IS NULL filtering
is needed.
The difference between current_negated and branch_negated is that
branch_negated is set on first negation, but current_negated is
flipped for each negation.
Note that add_filter will not do any negating itself, that is done
upper in the code by add_q().
The 'can_reuse' is a set of reusable joins for multijoins.
If 'reuse_with_filtered_relation' is True, then only joins in can_reuse
will be reused.
The method will create a filter clause that can be added to the current
query. However, if the filter isn't added to the query then the caller
is responsible for unreffing the joins used.
z"Cannot parse keyword query as dict)�branch_negated�current_negatedr� r� �
split_subqr� r� � conditionalFz3Cannot filter against a non-conditional expression.r� �r� Tz Cannot parse keyword query %rr� �7Joined field references are not permitted in this queryc s$ h | ]\}}|� � |d �kr|�qS r[ r� �r7 �kr� �� pre_joinsr9 r: � <setcomp>. s $ z%Query.build_filter.<locals>.<setcomp>)r� �
allow_manyr� Nr� r r� rK r9 )2rB ro r r �_add_qr� r� � TypeErrorr� r� r� r; r' r� r� r� r� r� r� r{ r� r� r� r rh r� rG r? rI �
_lookup_joinsr& �
split_exclude�names_with_pathrA �
trim_joinsrH rJ r� r* r� r r� rB � is_nullabler� r0 r r� r r� ) rU � filter_exprr� r� r� r� r� r� r� � condition�clause�argr� r� r_ �reffed_expression�
used_joinsr? r� r� r� �erH � join_list� num_lookupsr6 � lookup_type�
require_outerr� r9 r� r: � build_filter� s�
�
�
�
��
(
� zQuery.build_filterc C s$ | � tdi |d |d i��� d S )Nr r� r9 )�add_qr )rU �
filter_clauser9 r9 r: �
add_filter� s $zQuery.add_filterc sF � fdd�� j D �}� �|� j�\}}|r � j�|t� � �|� dS )zo
A preprocessor for the internal _add_q(). Responsible for doing final
join promotion.
c s h | ] }� j | jtkr|�qS r9 r/ )r7 r rd r9 r: r� � s z Query.add_q.<locals>.<setcomp>N)r� r� r� r� r; r' r} )rU �q_object�existing_innerr r� r9 rd r: r � s
z Query.add_qc C s | j |dd�d S )NFr� r )r
)rU r r9 r9 r: � build_where� rZ zQuery.build_wherec
C s� |j }||jA }|p |j}| j||jd�} t|j t|j�|�}
|jD ] } | j| ||||||d�\} }
|
�|
� | r?| �| |� q"|
� | �}
| |
fS )z%Add a Q-object to the current filter.�rC �negated)r� r� r� r� r� r� )
rC r r� r9 r� rA r
r: r; r> )rU r r� r� r� r� r� r� rC �
target_clauserE rE � child_clause� needed_innerr9 r9 r: r� � s&
�
�
�
z Query._add_qc
C s� |j }||jN }|p |j}| j||jd�}|jD ]%}t|t�r)| j||||d�}n| j||||dddd�\}} |�||� q|S )z4Add a FilteredRelation object to the current filter.r )r2 r� r� TF)r� r� r� r� r� r� ) rC r r� rA rB r/ �build_filtered_relation_qr
r; )
rU r r2 r� r� rC r rE r r� r9 r9 r: r � s$
�
�z Query.build_filtered_relation_qc C s� ||_ tt|j��}| �|j�\}}}|r td|j ��t|�D ]>}| �|�\}} }|s.dnd}
| d |
� } t| �D ]"\} }
t |�| krU|| |
krTtd|j|f ��q;td||jf ��q || j
|j < d S )NzAFilteredRelation's relation_name cannot contain lookups (got %r).r. r� zOFilteredRelation's condition doesn't support relations outside the %r (got %r).zlFilteredRelation's condition doesn't support nested relations deeper than the relation_name (got %r for %r).) r� ro rC r r� rN r� r r� r� r� )rU rl r� r� �relation_lookup_parts�relation_field_partsr� r� r� �lookup_field_parts�shift�lookup_field_path�idx�lookup_field_partr9 r9 r: �add_filtered_relation� s: �� ������zQuery.add_filtered_relationc
C s� g g }}t |�D �];\}}|g f} |dkr|jj}d}
d} z|�|�}
W nJ tyo || jv r8| j| j}
n5|| jv rm|dkrm| j| } t| j v rg| j �
t�} | � | |||�\}
}
}}|� |
dd� � n|�| j �}
Y nw |
dur�|
j
r�|
js�td| ��z|
jjj}W n0 ty� d}Y n&w |d8 }|dks�|r�tg t|��| j�| j��}td|d�|�f �� n�||jur�|�|�}|r�|� |� | d � |� |d j}t|
d ��r(|
�| �}|�s t |�D ]!\}}|j�r| d � |d|d � � |� | � t |d |��q�|d }|� |� |j }|j}|j }| d � |� |� | � q |
}|
f}|�rE|d t |�k�rEtd
||d |f �� |||||d d� fS ) a�
Walk the list of names and turns them into PathInfo tuples. A single
name in 'names' can generate multiple PathInfos (m2m, for example).
'names' is the path of names to travel, 'opts' is the model Options we
start the name resolving from, 'allow_many' is as for setup_joins().
If fail_on_missing is set to True, then a name that can't be resolved
will generate a FieldError.
Return a list of PathInfo tuples. In addition return the final field
(the last used join field) and target (which is a field guaranteed to
contain the same value as the final field). Finally, return those names
that weren't found (which are likely transforms and the final lookup).
r� Nr rK z�Field %r does not generate an automatic reverse relation and therefore cannot be used for reverse querying. If it is a GenericForeignKey, consider adding a GenericRelation.r� z7Cannot resolve keyword '%s' into field. Choices are: %s�, �
get_path_infozACannot resolve keyword %r into field. Join on '%s' not permitted.)!r� r� r4 rO r
rT r� r� r rN rM r� rx r� rQ r r� r� rL r� �sortedr@ r) �get_path_to_parent�to_optsr� r# �m2mr� r& r� �
target_fieldsr� )rU �namesr? r� �fail_on_missingrJ r� r� r4 �cur_names_with_pathr� rl r_ �filtered_relation_pathr� r� � available�path_to_parent� pathinfos� inner_pos�p�lastrG rH r9 r9 r: r� � s�
� ��
�� � ��� �
�
��zQuery.names_to_pathc sn |g}�fdd�}d�t t|�dd�D ]5} z�j|d| � ||dd�\}
� } } W n tyA }
z
| dkr5� |
�W Y d}
~
qd}
~
ww || d� } |D ]}� ��fd d
�}tj|||d �}qK|
D ]M}|jrn|j�� }|j}nd}d}|j }|j
r�� |j �}nd}t
|j||t|j ||d �}|js�|r�|nd}�j|||d
�}|�|� |r�|dd� |_q`t� | |||
|�S )a
Compute the necessary table joins for the passage through the fields
given in 'names'. 'opts' is the Options class for the current model
(which gives the table we are starting from), 'alias' is the alias for
the table to start the joining from.
The 'can_reuse' defines the reverse foreign key joins we can reuse. It
can be None in which case all joins are reusable or a set of aliases
that can be reused. Note that non-reverse foreign keys are always
reusable when using setup_joins().
The 'reuse_with_filtered_relation' can be used to force 'can_reuse'
parameter and force the relation on the given connections.
If 'allow_many' is False, then any reverse foreign key seen will
generate a MultiJoin exception.
Return the final field involved in the joins, the target field (used
for any 'where' constraint), the final 'opts' value, the joins, the
field path traveled to generate the joins, and a transform function
that takes a field and alias and is equivalent to `field.get_col(alias)`
in the simple case but wraps field transforms if they were included in
names.
The target field is the field containing the concrete value. Final
field can be something different, for example foreign key pointing to
that value. Final field is needed for example in some value
conversions (convert 'obj' in fk__id=obj to pk val using the foreign
key field for example).
c s � j sd }| �|�S r2 r� )r� r� rd r9 r: �final_transformerm s
z,Query.setup_joins.<locals>.final_transformerNr rK T)r* r� c s< z || |�}�� ||�W S ty t� t�r �r ��� w r2 )r� r rB r )r� r� r4 �previous�wrapped�rG �last_field_exceptionrU r9 r: � transform� s
�z$Query.setup_joins.<locals>.transform)r4 r4 )rl )r2 r� )�ranger� r� r � functools�partialrl rX r� r& �directr r� r% r� r r' r) r� rJ rF )rU r) r? r� r� r� r� rI r3 �pivotrJ rH �rest�excr� r4 r8 r) rl rn rv r~ r2 r9 r6 r: r� G sV ���
��
�zQuery.setup_joinsc s� |dd� }t t|��D ]H\}}t|�dks|js n:|jr n5dd� |jjD �}dd� |D �� � �|�s7 n � fdd�|jjD ��t �fdd �|D ��}| �
|� � � q ||d
|fS ) a�
The 'target' parameter is the final field being joined to, 'joins'
is the full list of join aliases. The 'path' contain the PathInfos
used to create the joins.
Return the final target field and table alias and the new active
joins.
Always trim any direct join if the target column is already in the
previous table. Can't trim reverse joins as it's unknown if there's
anything on the other side of the join.
Nr� c S � h | ]}|j �qS r9 ��columnr� r9 r9 r: r� � r� z#Query.trim_joins.<locals>.<setcomp>c S r@ r9 rA r� r9 r9 r: r� � r� c s* i | ]}|d j � v r|d j |d �qS )r� r rA �r7 �r)� cur_targetsr9 r: rx � s * z$Query.trim_joins.<locals>.<dictcomp>c 3 s � | ]}� |j V qd S r2 rA r� )� targets_dictr9 r: r; � � � z#Query.trim_joins.<locals>.<genexpr>rK ) r� �reversedr� r< rl r� �foreign_related_fields�issubset�related_fieldsrp r= ru )rU rH rI rJ r� �info� join_targetsr9 )rE rF r: r � s
zQuery.trim_joinsc c s^ � |D ])}t |t�r|V q|r tt|dd ��r |�� E d H q| j|�� |d�E d H qd S )Nr� r� )rB r �callabler� r� r� r� )�clsr� r� r� r9 r9 r: r� � s �
��zQuery._gen_colsc c s � dd� | � |�D �E d H d S )Nc s r
r2 �r� )r7 r� r9 r9 r: r; � r z)Query._gen_col_aliases.<locals>.<genexpr>)r� )rO r� r9 r9 r: �_gen_col_aliases� s � zQuery._gen_col_aliasesc
C s: | j �|�}|d ur8|s!| �|g�D ]}t| j| t�r td��q|r6|| jvr.td| ��t|| j| �S |S |� t
�}| j �|d �}|d urZ|dd � D ]}| � ||�}qO|S | j || �
� | �� |d�} | �| j| j| j�\}
} } |s�t| �dkr�td��t|
�dkr�td��| �|
d | �}|d ur�|�| � |S )Nr� zCCannot aggregate over the '%s' alias. Use annotate() to promote it.r r� )r� z?Referencing multicolumn fields with F() objects isn't supported)r� rh rQ rB r� r% r rT r rM r r� r� r� r� r rH rI rJ r� rK rA )
rU r4 r� r2 r� r� r� �
field_listr8 r� rH � final_aliasr r9 r9 r: � resolve_ref� sD ��
��
zQuery.resolve_refc C sN |\}}t |t�r|t|�f}n t |t�r |t|j�f}t| j�}| j|_|�|� |jdd� |� |�\}}|j
d } | j }
| j } | |v rp|
jj
j} |�| � |
�d�}
|
| �|j
d j �| �| ��}|j�|t� d|j| < |
�d�}
|
| t|��}|j�|t� | �t|��\}}|r�| jd| dfdd|d�\}}|�|t� ||fS )a�
When doing an exclude against any kind of N-to-many relation, we need
to use a subquery. This method constructs the nested query, given the
original exclude filter (filter_expr) and the portion up to the first
N-to-many relation field.
For example, if the origin filter is ~Q(child__name='foo'), filter_expr
is ('child__name', 'foo') and can_reuse is a set of joins usable for
filters in the original query.
We will turn this into equivalent of:
WHERE NOT EXISTS(
SELECT 1
FROM child
WHERE name = 'foo' AND child.parent_id = parent.id
LIMIT 1
)
Tr� r r� z
%s__isnull)r� r� r� )rB r r r4 r0 r� r� r r� �
trim_startr� r� r� r� r� r� r� r� r� r; r' r� r r
r r( )rU r r� r� �
filter_lhs�
filter_rhsr� �trimmed_prefix�contains_louterr6 � select_fieldr� r� r� r� r r �or_null_conditionr� r9 r9 r: r� sB
�
� zQuery.split_excludec C s( | j �t� t� | jD ]}|�� q d S r2 )r� r; r* r' r� � set_empty)rU r� r9 r9 r: r\ K s
�zQuery.set_emptyc C s t dd� | jjD ��S )Nc s s � | ]}t |t�V qd S r2 )rB r* )r7 �cr9 r9 r: r; Q rG z!Query.is_empty.<locals>.<genexpr>)r� r� rA rd r9 r9 r: �is_emptyP s zQuery.is_emptyc C s� |dur| j durt| j | j| �| _ n| j| | _ |dur4| j dur.t| j | j| �| _n| j| | _| j| j kr@| �� dS dS )a�
Adjust the limits on the rows retrieved. Use low/high to set these,
as it makes it more Pythonic to read and write. When the SQL query is
created, convert them to the appropriate offset and limit values.
Apply any limits passed in here to the existing constraints. Add low
to the current low value and clamp both to any existing high value.
N)rR �minrQ r\ )rU �lowr r9 r9 r: r S s
�zQuery.set_limitsc C s d\| _ | _dS )zClear any existing limits.rL N�rQ rR rd r9 r9 r: r� j � zQuery.clear_limitsc C s | j dkp | jd uS )Nr ra rd r9 r9 r: r� n s zQuery.is_slicedc C s | j d uo | j | j dkS )Nr� )rR rQ rd r9 r9 r: �
has_limit_oner s zQuery.has_limit_onec C s | j S )z�
Return True if adding filters to this instance is still possible.
Typically, this means no limits or offsets have been put on the results.
)r� rd r9 r9 r: �
can_filteru r� zQuery.can_filterc C s* d| _ d| _d| _| �d� | �d� dS )z%Remove all fields from SELECT clause.r9 FN)r� r� r� r" r� rd r9 r9 r: r } s
zQuery.clear_select_clausec C s d| _ d| _dS )z�
Clear the list of fields to select (but not extra_select columns).
Some queryset types completely replace any existing list of select
columns.
r9 N�r� r� rd r9 r9 r: �clear_select_fields� s
zQuery.clear_select_fieldsc C s$ | j |f7 _ | j|f7 _d S r2 re )rU r6 r4 r9 r9 r: �add_select_col� s zQuery.add_select_colc C s d| _ t|�| _d S �NF)r� rp r� )rU �colsr9 r9 r: r@ � s zQuery.set_selectc G s || _ d| _dS )zW
Add and resolve the given fields to the query's "distinct on" clause.
TN)r� r� )rU rY r9 r9 r: �add_distinct_fields� s
zQuery.add_distinct_fieldsc
C s | � � }| �� }z;g }|D ])}| j|�t�|||d�}| �|j|j|j�\}} }
|D ] } |� |�
| | �� q*q
|rA| � |� W dS W dS t yP t
d| �� t
y� t|v r[� || jv rft
d| ��tg t|��| j�| j�| j��} t
d|d�| �f ��w )zu
Add the given (model) fields to the select set. Add the field names in
the order specified.
)r� zInvalid field name: '%s'z;Cannot select the '%s' alias. Use annotate() to promote it.z5Cannot resolve keyword %r into field. Choices are: %sr" N)r� r� r� rM r r rH rI rJ r� rK r@ r& r r� r$ r@ r� rT r� r) )
rU rY � allow_m2mr� r? ri r4 r� rH rS rI r� r) r9 r9 r: r � sR
���
������ ��zQuery.add_fieldsc G s� g }|D ]\}t |t�rJd|v r t�|�r tjd| tdd� q|dkr$q|�d�r/|dd� }|| jv r5q| j r>|| j v r>q| �
|� t �| j
j� n
t|d �sT|�|� t|d
d �r`td | ��q|ritd
| ��|rt| j|7 _dS d | _dS )a8
Add items from the 'ordering' sequence to the query's "order by"
clause. These items are either field names (not column names) --
possibly with a direction prefix ('-' or '?') -- or OrderBy
expressions.
If 'ordering' is empty, clear all ordering from the query.
r% z~Passing column raw column aliases to order_by() is deprecated. Wrap %r in a RawSQL expression before passing it to order_by().� )�category�
stacklevel�?�-r� Nr� r� Fz[Using an aggregate in order_by() without also including it in annotate() is not allowed: %sz Invalid order_by arguments: %s)rB �strr! �match�warnings�warnr, �
startswithr� r� r� rM r r� r� r� r� r� r r� r� )rU �ordering�errors�itemr9 r9 r: � add_ordering� sF
��
���
zQuery.add_orderingc C s8 |s
| j s | js | jr
dS d| _d| _|rd| _dS dS )a
Remove any ordering settings if the current query allows it without
side effects, set 'force' to True to clear the ordering regardless.
If 'clear_default' is True, there will be no ordering in the resulting
query (not even the model's default).
Nr9 F)r� r� r� r� r� r� )rU r� �
clear_defaultr9 r9 r: r� � s
�zQuery.clear_orderingc
C s� |r/t � }t � }t| j�� �dd� D ]}|jj}||vr.|�dd� |jjD �� |� |� qt| j
�}| j rv| j � � D ]9\}}t
�|j�} d| jvrb|j}
d|
j|
jf } tj| td� |�� } n|rh||v rjd}|j|d�} |�| � q<t|�| _dS ) a?
Expand the GROUP BY clause required by the query.
This will usually be the set of all non-aggregate fields in the
return data. If the database backend supports grouping by the
primary key, and the query would be equivalent, the optimization
will be made automatically.
r� Nc S r@ r9 rA )r7 r� r9 r9 r: r� s ��z%Query.set_group_by.<locals>.<setcomp>r� zI`alias=None` must be added to the signature of %s.%s.get_group_by_cols().)rm rP )r< rh r� r� r� rQ rA r� �local_concrete_fieldsr; r� rT r{ �inspect� signaturer� �
parametersrl r r� rs rt r, rx rp r� )
rU r � column_names� seen_modelsr) r� r� r� r� r} �annotation_class�msg�
group_by_colsr9 r9 r: r s6
�
�
�
zQuery.set_group_byc C sL t | jt�r i }n| j}|D ]}|}|�t�D ]}|�|i �}qq|| _dS )z�
Set up the select_related data structure so that we only select
certain related models (as opposed to all models, when
self.select_related=True).
N)rB r� r� rM r rW )rU �fields�
field_dictr� �d�partr9 r9 r: �add_select_related- s �
zQuery.add_select_relatedc
C s� |rWi }|r t |�}nt g �}|�� D ]=\} }
| �| � t|
�}
g } |
�d�} | dkrJ| dks7|
| d dkr>| �t|�� |
�d| d �} | dks+|
| f|| < q| j�|� |s[|re| j �
t ||�t � |rp| j
t|�7 _
|rw|| _dS dS )zm
Add data to the various extra_* attributes for user-created additions
to the query.
z%srK r r� �%r. N)ri r{ r� rq �findr� r� r� rA r� r; r) r' r� rp r� )
rU r� �
select_paramsr� rM �tablesr� � select_pairs�
param_iterr4 �entry� entry_paramsr� r9 r9 r: r! = s0
�
�zQuery.add_extrac C s t � df| _dS )z0Remove any fields from the deferred loading set.TN)r� r� rd r9 r9 r: �clear_deferred_loading^ rb z Query.clear_deferred_loadingc C s6 | j \}}|r|�|�df| _ dS |�|�df| _ dS )aj
Add the given list of model field names to the set of fields to
exclude from loading from the database when automatic column selection
is done. Add the new field names to any existing field names that
are deferred (or removed from any existing field names that are marked
as the only ones for immediate loading).
TFN)r� r r� �rU rY �existingrZ r9 r9 r: �add_deferred_loadingb s
zQuery.add_deferred_loadingc C s` | j \}}t|�}d|v r|�d� |�| �� jj� |r'|�|�df| _ dS t|�df| _ dS )a
Add the given list of model field names to the set of fields to
retrieve when the SQL is executed ("immediate loading" fields). The
field names replace any existing immediate loading field names. If
there are field names already specified for deferred loading, remove
those names from the new field_names before storing the new names
for immediate loading. (That is, immediate loading overrides any
existing immediate values, but respects existing deferrals.)
r� FN) r� r< r� r; r� r� r4 r� r� r� r9 r9 r: �add_immediate_loadingv s
zQuery.add_immediate_loadingc C s8 z| j W S ty i }| �|| j� || _ | Y S w )aF
If any fields are marked to be deferred, return a dictionary mapping
models to a set of names in those fields that will be loaded. If a
model is not in the returned dictionary, none of its fields are
deferred.
If no fields are marked for deferral, return an empty dictionary.
)�_loaded_field_names_cacher� rf �get_loaded_field_names_cb)rU �
collectionr9 r9 r: �get_loaded_field_names� s �z Query.get_loaded_field_namesc C s dd� |D �||< dS )z,Callback used by get_deferred_field_names().c S r@ r9 r r6 r9 r9 r: r� � r� z2Query.get_loaded_field_names_cb.<locals>.<setcomp>Nr9 )rU r� r� r� r9 r9 r: r� � r� z Query.get_loaded_field_names_cbc C �$ |du rd| _ nt|�| _ d| _dS )z@Set the mask of annotations that will be returned by the SELECT.N)r� r< r� �rU r) r9 r9 r: r� � s
zQuery.set_annotation_maskc C s$ | j d ur| �| j �|�� d S d S r2 )r� r� r r� r9 r9 r: r� � s
�z Query.append_annotation_maskc C r� )z�
Set the mask of extra select items that will be returned by SELECT.
Don't remove them from the Query since they might be used later.
N)r� r< r� r� r9 r9 r: r" � s
zQuery.set_extra_maskc
C sx d| _ | �� | �� |r^|D ]}| �|� qg }g }g }| js(| js(t|�}n#d| _|D ] }|| jv r:|� |� q-|| j
v rE|� |� q-|� |� q-| � |� | � |� t
|| | �}ndd� | jjjD �}t
|�}| jdu r�| �dd� | jjjD �d� | jdd� | �� n%| jr�g }| jD ]} t| t�r�| j|vr�| j| j } |� | � q�t|�| _t|�| _| �|d� d S )NFc S s g | ]}|j �qS r9 r r6 r9 r9 r: r_ � r� z$Query.set_values.<locals>.<listcomp>Tc s r
r2 r r6 r9 r9 r: r; � r z#Query.set_values.<locals>.<genexpr>r )r� r� rf r� r� r� rh r� rS r� rT r" r� r� r� r� r r� r r rB r �refsrp r� )
rU r� r� rY � extra_names�annotation_namesr8 �selectedr� r� r9 r9 r: �
set_values� sH
zQuery.set_valuesc sJ � j dur� j S � js
i S � jdur"� fdd�� j�� D �� _ � j S � jS )z�
Return the dictionary of aggregate columns that are not masked and
should be used in the SELECT clause. Cache this result for performance.
Nc � i | ] \}}|� j v r||�qS r9 )r� r� rd r9 r: rx � �
�z+Query.annotation_select.<locals>.<dictcomp>)r� r� r� r{ rd r9 rd r: rT � s
�zQuery.annotation_selectc sJ � j d ur� j S � js
i S � jd ur"� fdd�� j�� D �� _ � j S � jS )Nc r� r9 )r� r� rd r9 r: rx r� z&Query.extra_select.<locals>.<dictcomp>)r� r� r� r{ rd r9 rd r: rS s
�zQuery.extra_selectc s� g }|D ] \}}|� |� qd}�fdd��jD �}t|�D ] \}}|jr' n�j||d jtkr5d}|| } ��| � q |jj}
|} g } |D ]\}
}| t |� dk rW n | �
|
� | t |�8 } qI| �
|
j d j � t
�| �} �j||d }|jtkr�|js�dd� |
jD �}||d � ��|| � |
��jd||d �}|r��j�|t� n d d� |
jD �}|| � �jD ]}�j| dkr�t�j| j|��j|< nq���� fd
d�|D �� | |fS ) a�
Trim joins from the start of the join path. The candidates for trim
are the PathInfos in names_with_path structure that are m2m joins.
Also set the select column so the start matches the join.
This method is meant to be used for generating the subquery joins &
cols in split_exclude().
Return a lookup usable for doing outerq.filter(lookup=self) and a
boolean indicating if the joins in the prefix contain a LEFT OUTER join.
_Fc s$ g | ]}|� j v s|� jkr|�qS r9 )r� r� r� rd r9 r: r_ % s
�z$Query.trim_start.<locals>.<listcomp>r� Tr c S � g | ]}|d �qS r[ r9 rC r9 r9 r: r_ E r� Nc S r� r� r9 rC r9 r9 r: r_ P r� c r3 r9 )r� r6 )� select_aliasr9 r: r_ X r8 )rx r� r� r' r0 r r= r� r� r� r� rI r4 r r) rl rK �get_extra_restrictionr� r� r; r' r� r# rj r@ )rU r� � all_pathsr� �pathsrY �
lookup_tables�
trimmed_pathsrJ r� r� �paths_in_prefixrX r4 �
first_join�
select_fields�extra_restrictionr� r9 )r� rU r: rU s\
�
�
��
�zQuery.trim_startc C s t t jjo|jp |jS )a
Check if the given field should be treated as nullable.
Some backends treat '' as null and Django treats such fields as
nullable for those backends. In such situations field.null can be
False even if we should treat the field as nullable.
)r r rf r� �empty_strings_allowed�null)rU r� r9 r9 r: r [ s
��zQuery.is_nullable)NNr2 )T)FNr� rh )FT)FFNTTFT)FFTTT)FF)TF)NTF)F)TNF)hrm r r� r� ri r� r� r� r+ rV r� r� r� r- r� rr r� r� r� r� rX r r� r� r� r r r r r$ r- rJ rf rn rp r= r{ r} r� r� r� r� r� r) r� r� r r� r� r� r� r� r� r� r� r� r� r� r
r r r r� r r! r� r� r � classmethodr� rQ rT r� r\ r^ r r� r� rc rd r rf rg r@ rj r ry r� r r� r! r� r� r� r� r� r� r� r" r� rT rS rU r r9 r9 r9 r: r0 � s�
X
34X
i
V
" '1
0!
-
�
�
g
�h
,C
+
.
)! 3
J�ASCc C s4 t | }| d dkr| dd� |d fS | |d fS )a
Return the field name and direction for an order specification. For
example, '-foo' is returned as ('foo', 'DESC').
The 'default' param is used to indicate which way no prefix (or a '+'
prefix) should sort. The '-' prefix always sorts the opposite way.
r rp r� N)r )r� �default�dirnr9 r9 r: �
get_order_dirn s r� c C s( || v r
| | � |� dS |h| |< dS )z^
Add "value" to the set of values for "key", whether or not "key" already
exists.
N)r; )�datarw r� r9 r9 r: rS | s rS c C s | j o | jo | j S )z�
Check if the given field is reverse-o2o. The field is expected to be some
sort of relation field or related object.
)r� �
one_to_oner3 )r� r9 r9 r: rP � s rP c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) r9 z]
A class to abstract away join promotion problems for complex filter
conditions.
c C sD || _ || _| jr|tkrt| _nt| _n| j | _|| _t� | _d S r2 )rC r r' r( �effective_connector� num_childrenr �votes)rU rC r� r r9 r9 r: rV � s zJoinPromoter.__init__c C s | j �|� dS )z`
Add single vote per item to self.votes. Parameter can be any
iterable.
N)r� rA )rU r� r9 r9 r: r: � s zJoinPromoter.add_votesc C s~ t � }t � }| j�� D ]'\}}| jdkr || jk r |�|� | jdks-| jdkr2|| jkr2|�|� q |�|� |�|� |S )a
Change join types so that the generated query is as efficient as
possible, but still correct. So, change as many joins as possible
to INNER, but don't make OUTER joins INNER if that could remove
results from the query.
r( r' )r< r� r{ r� r� r; r{ r} )rU r� �
to_promote� to_demoter� r� r9 r9 r: r> � s
�
z JoinPromoter.update_join_typesN)rm r r� r� rV r: r> r9 r9 r9 r: r9 � s
r9 )r� )Ur� r� r� r: r| r� rs � collectionsr r �collections.abcr r � itertoolsr r r �stringr �django.core.exceptionsr
r � django.dbr r
r �django.db.models.aggregatesr �django.db.models.constantsr � django.db.models.expressionsr r r r r r r �django.db.models.fieldsr �'django.db.models.fields.related_lookupsr �django.db.models.lookupsr � django.db.models.query_utilsr r r � django.db.models.sql.constantsr r r r! r" �#django.db.models.sql.datastructuresr# r$ r% r& �django.db.models.sql.wherer' r( r) r* r+ �django.utils.deprecationr, �django.utils.functionalr- �django.utils.regex_helperr. �django.utils.treer/ �__all__r� r' r@ rC rF r1 r0 r� rS rP r9 r9 r9 r9 r: �<module> sv $ �J
f