OwlCyberSecurity - MANAGER
Edit File: query.cpython-39.pyc
a kH�f�� � @ s� d Z ddlZddlZddlZddlZddlmZmZ ddlm Z m Z ddl m Z m Z mZ ddlmZ ddlmZmZ ddlmZmZmZ dd lmZ dd lmZ dd l m Z 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. ddl/m0Z0m1Z1m2Z2m3Z3 ddl4m5Z5m6Z6m7Z7m8Z8 ddl9m:Z:m;Z;m<Z<m=Z=m>Z> ddl?m@Z@ ddlAmBZB ddlCmDZD ddgZEeBd�ZFeBd�ZGdd� ZHd d � ZIed d �ZJG d d� d�ZKed!d"�ZLG d#d� de �ZMd)d%d&�ZNG d'd(� d(�ZOdS )*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�Value)�Field)�MultiColSource)�Lookup)�Q� check_rel_lookup_compatibility�refs_expression)�INNER�LOUTER� ORDER_DIR�SINGLE)� BaseTable�Empty�Join� MultiJoin)�AND�OR� ExtraWhere� NothingNode� WhereNode)�cached_property)�_lazy_re_compile)�Node�Query�RawQueryz['`\"\]\[;\s]|--|/\*|\*/z[\w\-]+c C s* | d u rt � S t t�dd� | �� D ���S )Nc s s( | ] }|j r|j|jfn|jfV qd S �N)Zconcrete�name�attname��.0�f� r7 �\/home/gouroczh/virtualenv/test/3.9/lib/python3.9/site-packages/django/db/models/sql/query.py� <genexpr>> s z,get_field_names_from_opts.<locals>.<genexpr>)�setr � from_iterableZ get_fields)�optsr7 r7 r8 �get_field_names_from_opts: s ��r= c c s0 | j D ]$}t|t�r$t|�E d H q|V qd S r1 )�children� isinstancer. �get_children_from_q)�q�childr7 r7 r8 r@ D s r@ �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 )r0 zA single raw SQL query.r7 c C s4 || _ || _|| _d | _d\| _| _i | _i | _d S )N�r N)�params�sql�using�cursor�low_mark� high_mark� extra_select�annotation_select)�selfrK rL rJ r7 r7 r8 �__init__U s zRawQuery.__init__c C s | � |�S r1 ��clone�rR rL r7 r7 r8 r a s zRawQuery.chainc C s t | j|| jd�S )N)rJ )r0 rK rJ rV r7 r7 r8 rU d s zRawQuery.clonec s6 | j d u r| �� t| j jj� � fdd�| j jD �S )Nc s g | ]}� |d ��qS �r r7 )r5 Z column_meta�� converterr7 r8 � <listcomp>k � z(RawQuery.get_columns.<locals>.<listcomp>)rM �_execute_queryr rL Z introspectionZidentifier_converter� description�rR r7 rX r8 � get_columnsg s zRawQuery.get_columnsc C s0 | � � t| j jjs"t| j�}n| j}t|�S r1 )r\ r rL �featuresZcan_use_chunked_reads�listrM �iter)rR �resultr7 r7 r8 �__iter__m s zRawQuery.__iter__c C s d| j j| f S )Nz<%s: %s>)� __class__�__name__r^ r7 r7 r8 �__repr__y s zRawQuery.__repr__c C s" | j d u rd S t| j t�r tS tS r1 )rJ r? r �dict�tupler^ r7 r7 r8 � params_type| s zRawQuery.params_typec C s" | j d u r| jS | j| � | j� S r1 )rj rK rJ r^ r7 r7 r8 �__str__� s zRawQuery.__str__c s� t | j }| j}|jj� |tu r:t� fdd�| jD ��}n<|tu r\� fdd�| j�� D �}n|d u rjd }n t d| ��|� � | _ | j � | j |� d S )Nc 3 s | ]}� |�V qd S r1 r7 )r5 �val��adapterr7 r8 r9 � r[ z*RawQuery._execute_query.<locals>.<genexpr>c s i | ]\}}|� |��qS r7 r7 )r5 �keyrl rm r7 r8 � <dictcomp>� r[ z+RawQuery._execute_query.<locals>.<dictcomp>zUnexpected params type: %s) r rL rj �opsZadapt_unknown_valueri rJ rh �items� RuntimeErrorrM �executerK )rR � connectionrj rJ r7 rm r8 r\ � s zRawQuery._execute_queryN)r7 )rf � __module__� __qualname__�__doc__rS r rU r_ rd rg �propertyrj rk r\ r7 r7 r7 r8 r0 R s � ExplainInfo)�format�optionsc @ s� e Zd ZdZdZdZeeg�ZdZe Z e Z dZ dZdZdZdZdZdZdZdZdZdZdZdZdZdZdZ dZ dZ dZ d Z dZ!dZ"dZ#dZ$dZ%dZ&dZ'dZ(dZ)dZ*e� dfZ+dZ,d�d d �Z-e.d d � �Z/e0dd� �Z1dd� Z2dd� Z3dd� Z4d�dd�Z5dd� Z6dd� Z7d�d d �Z8d d � Z9d d!� Z:d"d#� Z;d$d%� Z<d&d'� Z=d�d(d)�Z>d*d+� Z?d�d,d-�Z@d.d/� ZAd�d0d1�ZBd�d2d3�ZCd4d5� ZDd�d6d7�ZEd8d9� ZFd�d;d<�ZGd=d>� ZHd?d@� ZIdAdB� ZJdCdD� ZKd�dEdF�ZLdGdH� ZMdIdJ� ZNd�dKdL�ZOdMdN� ZPdOdP� ZQd�dQdR�ZRdSdT� ZSdUdV� ZTd�dWdX�ZUdYdZ� ZVd�d[d\�ZWd�d]d^�ZXd_d`� ZYdadb� ZZdcdd� Z[dedf� Z\dgdh� Z]d�didj�Z^dkdl� Z_dmdn� Z`dodp� Zadqdr� Zbd�dsdt�Zcd�dudv�Zddwdx� Zed�dydz�Zfd�d{d|�Zgd}d~� Zheid�dd���Zjeid�d�� �Zkd�d�d��Zld�d�� Zmd�d�� Znd�d�� Zod�d�d��Zpd�d�� Zqe.d�d�� �Zrd�d�� Zsd�d�� Ztd�d�� Zud�d�� Zvd�d�� Zwd�d�� Zxd�d�� Zyd�d�d��Zzd�d�� Z{d�d�d��Z|d�d�d��Z}d�d�� Z~d�d�� Zd�d�� Z�d�d�� Z�d�d�� Z�d�d�� Z�d�d�� Z�d�d�� Z�d�d�� Z�e.d�d�� �Z�e.d�d�� �Z�d�d�� Z�d�d�� Z�dS )�r/ zA single SQL query.�TNZ SQLCompilerTFr7 r � c C sJ || _ i | _i | _|| _i | _i | _t� | _t� | _ i | _ i | _ i | _ d S r1 ) �model�alias_refcount� alias_map� alias_cols�external_aliases� table_mapr: � used_aliasesr+ �where� annotations�extra�_filtered_relations)rR r r� r7 r7 r8 rS � s zQuery.__init__c C sP t | j�dkr*| jd }t|dd �p(|jS t | j�dkrLtt| j�� ��jS d S )N� r �target) �len�select�getattr�fieldrQ �nextrb �values� output_field)rR r� r7 r7 r8 r� s zQuery.output_fieldc C s | j D ] }| S d S r1 )r� �rR �aliasr7 r7 r8 � 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)rR rK rJ r7 r7 r8 rk 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_sqlr^ r7 r7 r8 r� s zQuery.sql_with_paramsc C s | � � }||t| �< |S )z4Limit the amount of work when a Query is deepcopied.)rU �id)rR �memorc r7 r7 r8 � __deepcopy__" s zQuery.__deepcopy__c C s< |d u r|d u rt d��|r$t| }|j�| j�| |||�S )Nz Need either using or connection)� ValueErrorr rq �compiler)rR rL ru � elide_emptyr7 r7 r8 r� ( s �zQuery.get_compilerc C s | j r| j jS dS )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. N)r �_metar^ r7 r7 r8 �get_meta1 s zQuery.get_metac C s, t � }| j|_| j�� |_| j�� |_| j�� |_| j�� |_| j�� |_| j� � |_| j �� |_ | j durx| j �� |_ | j r�t dd� | j D ��|_ d|_| j�� |_| jdur�| j�� |_| jdur�| j�� |_| jdur�t�|j�|_d| jv �r| j�� |_| j�� |_| j�� |_|j�dd� |S )zf Return a copy of the current Query. A lightweight alternative to deepcopy(). Nc S s g | ] }|� � �qS r7 rT )r5 �queryr7 r7 r8 rZ N r[ z Query.clone.<locals>.<listcomp>F� subq_aliasesr� )r$ re �__dict__�copyr� r� r� r� r� rU r� �annotation_select_mask�combined_queriesri �_annotation_select_cacher� �extra_select_mask�_extra_select_cache�select_related�deepcopyr� r� r� �pop)rR �objr7 r7 r8 rU : s: � z Query.clonec C sF | � � }|r |j|kr ||_|js*t� |_d|_t|d�rB|�� |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)rU re �filter_is_stickyr: r� �hasattrr� )rR �klassr� r7 r7 r8 r g s z Query.chainc C s | � � }|�|� |S r1 )rU �change_aliases)rR � change_maprU r7 r7 r8 �relabeled_clonev s zQuery.relabeled_clonec C s | j s d }|�||�S r1 �r� �get_col)rR r� r� r� r7 r7 r8 �_get_col{ s zQuery._get_colc s |si S d}d}i � �j }|�� D ]�\}}��|� |j�dddd�}|jsXtd| ����|g� |t�fdd�|�� D ��O }|t�fdd�|�� D ��O }|� � �}|�j |< |� t ||�< q"�fd d �|D �} �� |� �j �� \} } } td d� �j �� D ���p | } t�jt��sL�j�sL| �sL|�sL|�sL| �sL�j�sL�j�r d d lm} ��� }d|_|�j|�}d|_d|_ |� �j � |j dd� |j�sN|j �r�| �rĈjj j!�"|�#� �f|_d|_ | �sNt$� }t�jt��r��jD ]}||�� O }�q�| �� D ]}||�� O }�q�j �� D ] \}}|�%� �r$|�&|� �q$|� |� i }| �� D ]�\}}i � �j'|gdd�D ]\}|�(|� }�s�t)|�d }d|� �}t ||�}|||< ||j |< |�|g� |� |< �qv|� � �|j |< �qZ|j*dk�rz|j �sz|j �sz�jj j!�"|�#� �f|_*n\�}d�_*d�_ i �_+�j �rjdd � �j �� D �� � fdd �| �� D ��_ n| �_ �� | � dd� |j �� D �}tdd� |D �� }|j dd� |�,� d|_d|_ |j-||d�} | �.t/�} | du �r�|} n"| �0|j �� �} t1| �2| f| ��} t3t4|j | ��S )zU Return the dictionary with the values of the existing aggregations. FTN)� allow_joins�reuse� summarizez!%s is not an aggregate expressionc 3 s | ]}t � j| d d�V qdS )Zcontains_subqueryFN�r� r� �r5 �refr^ r7 r8 r9 � s �z(Query.get_aggregation.<locals>.<genexpr>c 3 s | ]}t � j| d d�V qdS )Zcontains_over_clauseTNr� r� r^ r7 r8 r9 � s �c s i | ]}|� j �|��qS r7 )r� r� )r5 r� r^ r7 r8 rp � r[ z)Query.get_aggregation.<locals>.<dictcomp>c s s | ]}t |d d�V qdS )�contains_aggregateTN)r� )r5 � annotationr7 r7 r8 r9 � s �r )�AggregateQuery��force)� resolve_refsr� Z__colr7 c S s i | ]\}}t ||�|�qS r7 )r )r5 r� r� r7 r7 r8 rp s �c s i | ]\}}||� � ��qS r7 )�replace_expressions)r5 r� � aggregate)� replacementsr7 r8 rp s �c S s g | ] }|j �qS r7 )�empty_result_set_value)r5 � expressionr7 r7 r8 rZ s �z)Query.get_aggregation.<locals>.<listcomp>c s s | ]}|t u V qd S r1 )�NotImplemented)r5 rc r7 r7 r8 r9 $ r[ )r� )5r� rr � check_alias�resolve_expressionr� � TypeError�append_annotation_mask�anyZget_refsr� r� r �set_annotation_maskr� Zsplit_having_qualifyr� r? �group_byri � is_sliced�distinct� combinatorZ django.db.models.sql.subqueriesr� rU �subqueryr �select_for_updater� rQ �clear_ordering� default_colsr� �pkr� �get_initial_aliasr: �get_group_by_cols�add� _gen_cols�getr� r� r� � clear_limitsr� Z execute_sqlr" Zget_convertersr� Zapply_convertersrh �zip) rR rL Zaggregate_exprsZ refs_subqueryZ refs_windowr� r� Zaggregate_exprr� Z aggregates�_ZhavingZqualifyZhas_existing_aggregationr� Z inner_queryZ outer_queryZannotation_mask�exprZannotation_aliasr� Zcol_refs�colZcol_ref�indexZ col_aliasZempty_set_resultr� r� rc � convertersr7 )r� rR r8 �get_aggregation� s� � � � � � �������� � ���� �� � � zQuery.get_aggregationc C s | � � }|�|dtd�i�d S )zO Perform a COUNT() query using the current filter constraints. Z__count�*)rU r� r )rR rL r� r7 r7 r8 � get_count3 s zQuery.get_countc C s | j S r1 )r� r^ r7 r7 r8 � has_filters: s zQuery.has_filtersc C s� | � � }|jr|jsN|jdu rF|�dd� | jjjD �d� |jdd� |� � |j rt|j dkrtt dd� |j D ��|_ |j dd� |r�|jd d � |�td �d � |S ) NTc s s | ] }|j V qd S r1 �r3 r4 r7 r7 r8 r9 B r[ z Query.exists.<locals>.<genexpr>F�� allow_aliases�unionc s s | ]}|j d d�V qdS )F)�limitN)�exists�r5 Zcombined_queryr7 r7 r8 r9 I s �r� r� )�high�a)rU r� r� r� � add_fieldsr r� �concrete_fields� set_group_by�clear_select_clauser� r� ri r� � set_limits�add_annotationr )rR r� rA r7 r7 r8 r� = s" � � z Query.existsc C s | � |�}|j|d�}|�� S )N�rL )r� r� � has_results)rR rL rA r� r7 r7 r8 r� S s zQuery.has_resultsc K sZ | � � }|D ]&}t�|�r"d|v r td|�d���q t||�|_|j|d�}d�|�� �S )Nz--zInvalid option name: �.r� � ) rU �EXPLAIN_OPTIONS_PATTERN� fullmatchr� rz � explain_infor� �joinZ explain_query)rR rL r{ r| rA Z option_namer� r7 r7 r8 �explainX s �� z Query.explainc sJ �j |j krtd���jr"td���j|jkr6td���j|jkrJtd����� }|j�|hd� i � |tk}|rxt� nt�j �}t |dd�}|� �fdd ��j D �� t� }t |j �d d � }|D ]j} |j | } | � � �} �j| |d �} | jtkr�|�| � |�| � | | k�r| � | < |j| sĈ�| � q�|� |� |��� � j|jO _|j�� } | �� � �j�| |� |j�r���� fd d�|jD �� nd�_|t k�rj �r�|j �r�t d���j � |j � t� } �j d u�r�| � �j � |j d u�r| � |j � | �r��!| � � j"|j"7 _"|j#�p2�j#�_#|j$�pB�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.)�exclude� Fc 3 s" | ]}� j | jtkr|V qd S r1 �r� � join_typer )r5 �jr^ r7 r8 r9 � s z Query.combine.<locals>.<genexpr>r� N)r� c s g | ]}|� � ��qS r7 �r� �r5 r� �r� r7 r8 rZ � r[ z!Query.combine.<locals>.<listcomp>r7 zSWhen merging querysets using 'or', you cannot have extra(select=...) on both sides.)%r r� r� r� �distinct_fieldsr� � bump_prefixr' r: r� � JoinPromoter� add_votesra r� r� r r r� �discardr� � unref_alias�update_join_typesr� r� rU �relabel_aliasesr� � set_selectr( r� r� �updater� �set_extra_mask� extra_tables�order_by�extra_order_by)rR �rhs� connectorZ initial_aliasZ conjunctionr� � joinpromoterZ rhs_votesZ rhs_tablesr� r� � new_alias�wr� r7 )r� rR r8 �combined sn � � z Query.combinec C s* |d u r i }i ||j < |jD ]�}|�|jd �}|�|jd �}|d u rZ|d u rZ|�|i � q |r |jstttt |����|�|i �}|j j j j }| �|j ||� q |�� D ]~\} }| j�| � } r�|�| j�} |�| | fi �}| j}n(|�| �} t| d�s�q�| j}|�|i �}|j j j }| �|j ||� q�|S )Nr� )r� r� r� r2 r3 � setdefault� is_relationr r� rb � remote_fieldr r� �concrete_model�_get_defer_select_maskrr r� r� � get_field� relation_namer� r� ) rR r< �mask� select_maskr� � field_maskZfield_att_mask�field_select_mask� related_model� field_name�filtered_relationZrelationZ reverse_relr7 r7 r8 r! � s> � �z Query._get_defer_select_maskc C s� |d u r i }i ||j < |�� D ]j\}}|�|�}||jv rB|j}n|}|�|i �}|r |jslttt |����|j j j j } | �| j ||� q |S r1 )r� rr r" Zrelated_objectsr� r r r r� rb r r r� r �_get_only_select_mask) rR r< r$ r% r) r& r� Z field_keyr' r( r7 r7 r8 r+ s" �zQuery._get_only_select_maskc C sd | j \}}|si S i }|D ]$}|}|�t�D ]}|�|i �}q,q| �� }|rX| �||�S | �||�S )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. )�deferred_loading�splitr r r� r! r+ )rR � field_names�deferr$ r) Z part_mask�partr< r7 r7 r8 �get_select_mask s zQuery.get_select_maskc C s� | j �|�}|s6|r6|d }| j| d7 < |dfS |r^d| jt| j�d f }|�|� n |durl|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� r� r� � alias_prefixr� r� �appendr� )rR � table_name�creater* Z alias_listr� r7 r7 r8 � table_alias2 s � zQuery.table_aliasc C s | j | d7 < dS )z-Increases the reference count for this alias.r� N�r� r� r7 r7 r8 � ref_aliasM s zQuery.ref_aliasr� c C s | j | |8 < dS )z-Decreases the reference count for this alias.Nr8 )rR r� �amountr7 r7 r8 r Q s zQuery.unref_aliasc s� t ����r���d�� �j� jdu r(q�j� jdus<J ��j� j}|oZ�j| jtk}�j� jtk}�j� js||r|s�j� �� �j� < ��� ��fdd��jD �� qdS )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 r1 )r� � parent_alias)r5 r� �r� �aliasesrR r7 r8 r9 s s �z&Query.promote_joins.<locals>.<genexpr>) ra r� r� r r; r �nullableZpromote�extend)rR r= r; Z parent_louterZalready_louterr7 r< r8 � promote_joinsU s ��zQuery.promote_joinsc C sf t |�}|rb|�d�}| j| jtkr| j| �� | j|< | j| j}| j| jtkr|�|� qdS )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) ra r� r� r r Zdemoter; r r4 )rR r= r� r; r7 r7 r8 � demote_joinsz 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� rr r� r )rR Z to_countsr� Z cur_refcountZ unref_amountr7 r7 r8 �reset_refcounts� s zQuery.reset_refcountsc s* t � ��� �� �sJ �| j�� � t| jt�rHt� fdd�| jD ��| _t� fdd�| jD ��| _| j o~� fdd�| j � � D �| _ � � � D ]�\}}|| j vr�q�| j | � � �}|| j |< | j | | j |< | j |= | j |= | j|j }t|�D ] \}}||kr�|||< q�q�q�� 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 s g | ]}|� � ��qS r7 r r r r7 r8 rZ � r[ z(Query.change_aliases.<locals>.<listcomp>c s g | ]}|� � ��qS r7 r r r r7 r8 rZ � r[ c s i | ]\}}||� � ��qS r7 r )r5 ro r� r r7 r8 rp � s �z(Query.change_aliases.<locals>.<dictcomp>c s& i | ] \}}� � ||�|p |� v �qS r7 �r� )r5 r� �aliasedr r7 r8 rp � s �N)r: � isdisjointr� r� r r? r� ri r� r� rr r� r� r� r� r5 � enumerater� )rR r� Z old_aliasr Z alias_dataZ table_aliases�posr� r7 r r8 r� � s4 �� �zQuery.change_aliasesc s� �fdd�}�j |j kr dS t�� d }t|� �D ],\}}|�jvrN|�_ q`||kr2td��q2�j��j g��_|j��j�|_� du r�i � ��� �fdd�t�j�D �� dS )a; Change the alias prefix to the next letter in the alphabet in a way that the other 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. To prevent changing aliases use the exclude parameter. c 3 sj t } tt� j�d �}|V td�D ]@}|r>| | �|�d� n| }t||d�D ]}d�|�V qNd}q$dS )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�ordr3 r r� r r� )�alphabet�prefix�n�seq�sr^ r7 r8 � prefix_gen� s z%Query.bump_prefix.<locals>.prefix_genN� z6Maximum recursion depth exceeded: too many subqueries.c s( i | ] \}}|� vr|d �j |f �qS )r2 )r3 )r5 rG r� �r rR r7 r8 rp � s �z%Query.bump_prefix.<locals>.<dictcomp>) r3 �sys�getrecursionlimitrF r� �RecursionErrorr� r� r� )rR Z other_queryr rQ Zlocal_recursion_limitrG rM r7 rS r8 r � s* � ��zQuery.bump_prefixc C s@ | j r| j}| �|� n$| jr8| �| �| �� jd��}nd}|S )zf Return the first alias for this query, after increasing its reference count. N)r� r� r9 r r� �base_table_classr� �db_tabler� r7 r7 r8 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� r7 )r5 r r7 r7 r8 rZ r[ z-Query.count_active_tables.<locals>.<listcomp>)r� r� r� r^ r7 r7 r8 �count_active_tables s zQuery.count_active_tablesc s� |r$�r$� �fdd�| j �� D �}n� �fdd�| j �� D �}|rj� j|v rT� j}n|d }| �|� |S | j� jd� jd�\}}� jr�| j � j jtks�� j r�t}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 base_table_class or join_class. 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|� � �r|�qS r7 )�equals�r5 r� r �r� r� r7 r8 rZ ! s z Query.join.<locals>.<listcomp>c s, g | ]$\}}�d u s |�v r|� kr|�qS r1 r7 r\ r] r7 r8 rZ % s ����T)r6 r* ) r� rr r7 r9 r5 r* r r; r r> r ) rR r� r� � reuse_with_filtered_relationZ reuse_aliasesZ reuse_aliasr� r� r r7 r] r8 r� s0 � � � z Query.joinc C s� ||v r|| S |� |�}|s"|S |}|D ]b}||v rF|j}|| }q*|j| sX|j}q*|�|�}| �|jg||�} |j}| jd }||< q*|p�|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. r^ N)Zget_base_chainr� �parentsZget_ancestor_link� setup_joinsr2 rF ) rR r< r r� �seenr Z curr_optsZ int_modelZ link_field� join_infor7 r7 r8 �join_parent_modelB s& zQuery.join_parent_modelc C s t �|�rtd��d S )NzbColumn aliases cannot contain whitespace characters, quotation marks, semicolons, or SQL comments.)�FORBIDDEN_ALIAS_PATTERN�searchr� r� r7 r7 r8 r� c s �zQuery.check_aliasc C sR | � |� |j| ddd�}|r,| �|g� n| �t| j��|h�� || j|< dS )z0Add a single annotation expression to the Query.TN)r� r� )r� r� r� r� r: rQ � differencer� )rR r� r� r� r7 r7 r8 r� j s zQuery.add_annotationc s� | � � }|��� d|_|jj�g� �R i ��� |jrVt� ��fdd�|jD ��|_|j� � D ]B\}}|j�g� �R i ���}t |d�r�|j � |j � ||j|< q`�j � � D ]>\}} t| t�r�| jjjj|kp�t| t�o�| j| jk|j |< q�|S )NTc s$ g | ] }|j �g� �R i ����qS r7 )r� r� ��args�kwargsr� r7 r8 rZ } s �z,Query.resolve_expression.<locals>.<listcomp>r� )rU r r� r� r� r� ri r� r� rr r� r� r r� r? r% � join_fieldr( r� rX r# r5 r7 ) rR r� ri rj rU ro �value�resolvedr� �tabler7 rh r8 r� t s, �� �� zQuery.resolve_expressionc s0 t � j�� � jj�}� fdd�� j|dd�D �S )Nc s g | ]}|j � jv r|�qS r7 )r� r� r r^ r7 r8 rZ � s �z+Query.get_external_cols.<locals>.<listcomp>T)�include_external)r r� r� r� r> r� )rR �exprsr7 r^ r8 �get_external_cols� s �zQuery.get_external_colsc C s( | � � }tdd� |D ��r$|p | gS |S )Nc s s | ] }|j V qd S r1 )Zpossibly_multivaluedr r7 r7 r8 r9 � r[ z*Query.get_group_by_cols.<locals>.<genexpr>)rq r� )rR �wrapperZ external_colsr7 r7 r8 r� � s zQuery.get_group_by_colsc C s\ | j r2|jjs2| jdd� | jD ]}|jdd� q | j|d��� \}}| j rTd| }||fS )NFr� )ru z(%s))r� r` Z*ignores_unnecessary_order_by_in_subqueriesr� r� r� r� )rR r� ru r� rK rJ r7 r7 r8 r� � s �� z Query.as_sqlc sh t |d�r |j��� |d�}nFt|ttf�rd� ��fdd�|D �}t|�}t |d�r\||� S ||�S |S )Nr� )r� r� r� c 3 s | ]}�� |�� �V qd S r1 )�resolve_lookup_value)r5 Z sub_value�r� � can_reuserR r7 r8 r9 � s �z-Query.resolve_lookup_value.<locals>.<genexpr>�_make)r� r� r? ra ri �type)rR rl ru r� r� r� �type_r7 rt r8 rs � s �� zQuery.resolve_lookup_valuec C s� |� t�}| jrFt|| j�\}}|rF| j| }|r<t||�}|d|fS | �|| �� �\}}}} |dt|�t| � � } t| �dkr�| s�td|| �� j j f ��| | dfS )zX Solve the lookup type from the lookup (e.g.: 'foobar__id__icontains'). r7 r r� z"Invalid lookup "%s" for model %s".F) r- r r� r r � names_to_pathr� r� r r rf ) rR �lookupr� Zlookup_splittedr� Zexpression_lookupsr� r� r� � lookup_partsZ field_partsr7 r7 r8 �solve_lookup_type� s& � ��zQuery.solve_lookup_typec C s0 t |d�r,t|jj||�s,td||jf ��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)rR rl r< r� r7 r7 r8 �check_query_object_type� s ��z Query.check_query_object_typec C s~ |j rzt|t�r>|js>t|j||�s>td|jjj|jf ��n<t |d�rX| � |||� n"t |d�rz|D ]}| � |||� qfdS )z3Check the type of object passed to query relations.z6Cannot use QuerySet for "%s": Use a QuerySet for "%s".r� rd N) r r? r/ �has_select_fieldsr r r� r� r} r� r~ )rR r� rl r< �vr7 r7 r8 �check_related_objects� s" �� ��� zQuery.check_related_objectsc C sL t |d�r&t|dd�s&t|jjd ��t |d�rH|�� D ]}| �|� q8dS )z>Raise an error if expression cannot be used in a WHERE clause.r� Z filterableTz$ is disallowed in the filter clause.�get_source_expressionsN)r� r� r re rf r� �check_filterable)rR r� r� r7 r7 r8 r� s � � zQuery.check_filterablec C s� |pdg�^ }}|D ]}| � ||�}q|�|�}|sV| � ||�}d}|�|�}|sVdS |||�}|jdu r�|js�|dvr�td��|�d�|d�S |dkr�|jdkr�tt jjr�|�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(). �exactN)r� Ziexactz Cannot use None as a query value�isnullTrI ) � try_transform� get_lookupr Zcan_use_none_as_rhsr� r r r` �!interprets_empty_strings_as_nulls) rR �lookups�lhsr � transforms� lookup_namer2 � lookup_classrz r7 r7 r8 � build_lookup s. �� �zQuery.build_lookupc C s` |� |�}|r||�S |jj}t�||j�� �}|rDdd�|� }nd}td||j|f ��dS )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%sN) Z get_transformr� re �difflib�get_close_matchesZ get_lookupsr� r rf )rR r� r2 Ztransform_classr� Zsuggested_lookupsZ suggestionr7 r7 r8 r� < s � ��zQuery.try_transformc s� t |t�rtd��t |t�r6| j|||||||| d�S t|d�r�t|dd�sTtd��|j| || d�} t | t �s~| � dg| d �} t | gt d �g fS |\} } | s�td | ��| � | | �\} }}|r�| �|� |s�t|�d kr�td ��| j�� � | �| ||| �} � fdd�| j�� D �}|�r"| �| � |�rH| � | || �} t | gt d �g fS | �� }| �� }| �pd| }zH| j||||||d�}t | t��r�t| �} | �|j| |j� |j | _ W n6 t �y� } z | � |||j �W Y d}~S d}~0 0 |�!|j � | �"|j#|j |j$�\}}}|du�r |�!|� |jj%�rbt|�d k�rN| �&|d |j|�}nt'|||j#|j�}n| �&|d |j|�}| � | || �} | j(}t | gt d �}|dk�o�| j)d u �o�| }|�r�|dk�s�| j)du �r�| j)du�r�d }|dk�r�| �*|d ��s| j+|d j,t-k�rH|d �.d�} | �&|d |j#d |�}|�/| |d�t � t | t0��r�| �*| j1��r�| j1�.d�} |�/| | d�t � ||�s�|ndfS )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� r� Z conditionalFz3Cannot filter against a non-conditional expression.)r� r� r� T)r z Cannot parse keyword query %rr� �7Joined field references are not permitted in this queryc s$ h | ] \}}|� � |d �kr|�qS rW rC �r5 �kr� �Z pre_joinsr7 r8 � <setcomp>� s z%Query.build_filter.<locals>.<setcomp>)ru � allow_manyr_ Nr r� r^ r7 )2r? rh r r �_add_qr� r� r� r� r r� r+ r' r| r� r� r� r� rs rr r� r� ra r ra r� rD r< rF � _lookup_joinsr& � split_exclude�names_with_pathr � trim_joinsrE rG r r� r r� r � is_nullabler� r r r� r� r r� ) rR � filter_exprr� r� ru r� r� r_ r� r� � condition�argrl r� �partsZreffed_expressionZ used_joinsr< r� r� rc �erE � join_listr� Z lookup_type�clauseZ require_outerr� r7 r� r8 � build_filterR s� ( � � � � & � ������ �� zQuery.build_filterc C s | � t||f�� d S r1 )�add_qr )rR � filter_lhs� filter_rhsr7 r7 r8 � add_filter� s zQuery.add_filterc sF � fdd�� j D �}� �|� j�\}}|r8� j�|t� � �|� dS )zo A preprocessor for the internal _add_q(). Responsible for doing final join promotion. c s h | ]}� j | jtkr|�qS r7 r )r5 r� r^ r7 r8 r� s z Query.add_q.<locals>.<setcomp>N)r� r� r� r� r� r' rA )rR �q_objectZexisting_innerr� r� r7 r^ r8 r� � s �z Query.add_qc C s | j |dd�d S )NF)r� r )r� )rR r� r7 r7 r8 � build_where s zQuery.build_wherec C s t � | _d S r1 )r+ r� r^ r7 r7 r8 � clear_where s zQuery.clear_wherec C s� |j } ||jN }|p|j}t| |jd�} t|j t|j�|�} |jD ]<} | j| |||||||d�\} }| �|� | rB| �| | � qB| � | �}| |fS )z%Add a Q-object to the current filter.�r �negated)ru r� r� r� r� r� r� ) r r� r+ r r� r> r� r r� r )rR r� r� r� r� r� r� r� r� r � target_clauser rB � child_clause� needed_innerr7 r7 r8 r� s. � � z Query._add_qc C s~ |j }||jN }|p|j}t||jd�}|jD ]J}t|t�rP| j||||d�}n | j||||dddd�\}} |�||� q.|S )z4Add a FilteredRelation object to the current filter.r� )r� r� r� TF)ru r� r� r� r� r_ ) r r� r+ r> r? r. �build_filtered_relation_qr� r� ) rR r� r� r� r� r r� rB r� r� r7 r7 r8 r� 9 s. �� z Query.build_filtered_relation_qc C s� ||_ tt|j��}| �|j�\}}}|r8td|j ��t|�D ]~}| �|�\}} }|s\dnd} | d | � } t| �D ]F\} } t |�| kr�|| | kr�td|j|f ��qvtd||jf ��qvq@|| 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� rh r@ r� r| r# r� r rF r� r� )rR r* r� r� Zrelation_lookup_partsZrelation_field_partsr� rz r{ Zlookup_field_parts�shiftZlookup_field_path�idxZlookup_field_partr7 r7 r8 �add_filtered_relationV s: � �� ����zQuery.add_filtered_relationc C s� g g }}t |�D �]�\}}|g f} |dkr4|jj}d} d} z|du rJt�|�|�} W n� ty� || jv r|| j| j} nj|| jv r�|dkr�| j| } t| j v r�| j � t�} | � | |||�\} } }}|� | dd� � n |�| j �} Y n0 | du�r<| j �r| j�std| ��z| jjj}W n t�y8 d}Y n0 nP|d8 }|dk�sT|�r�tg t|��| j�| j��}td|d�|�f �� �q�|du�r�||ju�r�|�|�}|�r�|� |� | d � |� |d j}t| d ��r�| �r�| �| �}n| j}|�sLt |�D ]D\}}|j �r| d � |d|d � � |� | � t |d |���q|d }|� |� |j }|j}|j }| d � |� |� | � q| }| f}|�r�|d t!|�k�r�td ||d |f �� �q�q|||||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 r^ 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�, � path_infoszACannot resolve keyword %r into field. Join on '%s' not permitted.)"rF r� r2 r r" rQ r� r� r r# r- ry r? r r( r r r� r �AttributeError�sortedr= r� Zget_path_to_parent�to_optsr� Z get_path_infor� �m2mr4 r& rk Z target_fieldsr� )rR �namesr< r� �fail_on_missingrG r� rG r2 Zcur_names_with_pathr� r* r� Zfiltered_relation_pathr� r � availableZpath_to_parentZ pathinfosZ inner_pos�p�lastrD rE r7 r7 r8 ry u s� � �� ���� �� ��zQuery.names_to_pathc s� |g}�fdd�}d�t t|�dd�D ]p} z&�j|d| � ||dd�\} � } } W n4 ty� } z | dkrl� n| �W Y d} ~ q&d} ~ 0 0 || d� } q�q&|D ]*}� ��fd d �}tj|||d �}d|_q�| D ]�}|jr�|j�� }|j }nd}d}|j }|j �r �� |j �}nd}�j|j||t|j ||d �}|j�s:|�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 s d }| �|�S r1 r� )r� r� r^ r7 r8 �final_transformer s z,Query.setup_joins.<locals>.final_transformerNr r^ T)r� r� c sF z|| |�}�� ||�W S ty@ t� t�r:�r:��n� Y n0 d S r1 )r� r r? r )r� r� r2 �previous�wrapped�rD Zlast_field_exceptionrR r7 r8 � transform4 s z$Query.setup_joins.<locals>.transform)r2 r� )r* )r� r_ )�ranger� ry r � functools�partialZhas_transformsr* rU r� r� �directr� rk � join_classrX r r� r� r4 rG rC )rR r� r< r� ru r� r_ rF r� ZpivotrG rE �rest�excr� r2 r� r� r* r7 r> ru r� r7 r� r8 ra � sh ' � � � � zQuery.setup_joinsc s� |dd� }t t|��D ]�\}}t|�dks2|js6 q�|jr@ q�dd� |jjD �}dd� |D �� � �|�sn q�� 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 s h | ] }|j �qS r7 ��column�r5 �tr7 r7 r8 r� y r[ z#Query.trim_joins.<locals>.<setcomp>c S s h | ] }|j �qS r7 r� r� r7 r7 r8 r� z r[ c s* i | ]"}|d j � v r|d j |d �qS )r� r r� �r5 �r)� cur_targetsr7 r8 rp } s �z$Query.trim_joins.<locals>.<dictcomp>c 3 s | ]}� |j V qd S r1 r� r� )� targets_dictr7 r8 r9 � r[ z#Query.trim_joins.<locals>.<genexpr>r^ ) rF �reversedr� r� r* rk �foreign_related_fields�issubset�related_fieldsri r r� )rR rE rF rG rG �infoZ join_targetsr7 )r� r� r8 r� f s �zQuery.trim_joinsc c sx |D ]n}t |t�r|V q|r>tt|dd ��r>|�� E d H qt|d�r|sXt |t�rXq| j|�� ||d�E d H qd S )Nrq r� )ro r� ) r? r �callabler� rq r� r r� r� )�clsrp ro r� r� r7 r7 r8 r� � s � �zQuery._gen_colsc c s dd� | � |�D �E d H d S )Nc s s | ] }|j V qd S r1 )r� )r5 r� r7 r7 r8 r9 � r[ z)Query._gen_col_aliases.<locals>.<genexpr>)r� )r� rp r7 r7 r8 �_gen_col_aliases� s zQuery._gen_col_aliasesc C sH | j �|�}|d urr|sB| �|g�D ] }t| j| t�r$td��q$|rl|| jvr\td| ��t|| j| �S |S n�|� t �}| j �|d �}|d ur�|dd � D ]}| � ||�}q�|S | j || � � | �� |d�} | �| j| j| j�\} } } |�st| �dk�rtd��t| �dk�r td��| �| d | �}|d u�r@|�| � |S d S )Nr� zCCannot aggregate over the '%s' alias. Use annotate() to promote it.r r� )ru z?Referencing multicolumn fields with F() objects isn't supported)r� r� r� r? r� r% r rQ r r- r r� ra r� r� r� rE rF rG r� rH r ) rR r2 r� r� r� r� r� � field_listr� rc rE � final_aliasr� r7 r7 r8 � resolve_ref� sR � �� � � �� zQuery.resolve_refc C sL | � | j�}| j|_|\}}t|t�r0t|�}nt|t�rDt|j�}|�||� |jdd� |� |�\}}|j d } | j } | j } | |v r�| jj j} |�| � | �d�} | | �|j d j �| �| ��}|j�|t� d|j| < | �d�} | | t|��}|j�|t� | �t|��\}}|�rD| 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� ru )re r r� r? r r r2 r� r� � trim_startr� r� r� r� r� r r� r� r� r� r' r� r r� r r( )rR r� ru r� r� r� r� �trimmed_prefix�contains_louterr� Z select_fieldr� r� r� rz r� r� Zor_null_conditionr� r7 r7 r8 r� � sB � zQuery.split_excludec C s( | j �t� t� | jD ] }|�� qd S r1 )r� r� r* r' r� � set_empty)rR r� r7 r7 r8 r� s zQuery.set_emptyc C s t dd� | jjD ��S )Nc s s | ]}t |t�V qd S r1 )r? r* )r5 �cr7 r7 r8 r9 r[ z!Query.is_empty.<locals>.<genexpr>)r� r� r> r^ r7 r7 r8 �is_empty s zQuery.is_emptyc C s� |dur4| j dur(t| j | j| �| _ n | j| | _ |durh| j dur\t| j | j| �| _n | j| | _| j| j kr|| �� 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)rO �minrN r� )rR �lowr� r7 r7 r8 r� s zQuery.set_limitsc C s d\| _ | _dS )zClear any existing limits.rI N�rN rO r^ r7 r7 r8 r� 2 s zQuery.clear_limitsc C s | j dkp| jd uS )Nr r� r^ r7 r7 r8 r� 6 s zQuery.is_slicedc C s | j d uo| j | j dkS )Nr� )rO rN r^ r7 r7 r8 � has_limit_one: 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� r^ r7 r7 r8 � can_filter= s zQuery.can_filterc C s* d| _ d| _d| _| �d� | �d� dS )z%Remove all fields from SELECT clause.r7 FN)r� r� r� r r� r^ r7 r7 r8 r� E 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. r7 N�r� � values_selectr^ r7 r7 r8 �clear_select_fieldsM s zQuery.clear_select_fieldsc C s$ | j |f7 _ | j|f7 _d S r1 r� )rR r� r2 r7 r7 r8 �add_select_colV s zQuery.add_select_colc C s d| _ t|�| _d S )NF)r� ri r� )rR �colsr7 r7 r8 r Z 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� )rR r. r7 r7 r8 �add_distinct_fields^ s zQuery.add_distinct_fieldsc C s | � � }| �� }zng }|D ]R}| j|�t�|||d�}| �|j|j|j�\}} } |D ]} |� |� | | �� qTq|r|| � |� W n� t y� t d| ��Y np t �y t|v r�� nP|| jv r�t d| ��n8tg t|��| j�| j�| j��} t d|d�| �f ��Y n0 dS )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� ra r- r r� rE rF rG r4 rH r r& r r� r� r= r� rQ r� r� ) rR r. Z allow_m2mr� r< r� r2 rc rE r� rF r� r� r7 r7 r8 r� e sX �� ������� ��zQuery.add_fieldsc G s� g }|D ]�}t |t�rl|dkr q|�d�r6|dd� }|| jv rBq| jrT|| jv rTq| �|�t�| jj � nt |d�s�|� |� t |dd�rt d| ��q|r�t d | ��|r�| j|7 _nd| _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� Nr� r� Fz[Using an aggregate in order_by() without also including it in annotate() is not allowed: %sz Invalid order_by arguments: %s)r? �str� startswithr� r� ry r- r r r� r� r4 r� r r �default_ordering)rR Zordering�errors�itemr7 r7 r8 � add_ordering� s2 �� zQuery.add_orderingc C s4 |s| j s| js| jrdS d| _d| _|r0d| _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). Nr7 F)r� r r� r r r� )rR r� Z clear_defaultr7 r7 r8 r� � s ���zQuery.clear_orderingc C s� |rx| j rxi }i }t| j | j�D ]$\}}t|t�r<|||< q |||< q i |�| j�| _| �|� t|�� �| _t|�| _ t | j�}| j � � D ]<\}}|� � }s�q�|r�|j s�|�t||�� q�|�|� 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. N)r� r� r� r? r r� r� ri r� ra rQ rr r� r� r4 r r? r� ) rR r� Zgroup_by_annotationsr� r� r� r� r� Z group_by_colsr7 r7 r8 r� � s& zQuery.set_group_byc C sL t | jt�ri }n| j}|D ]$}|}|�t�D ]}|�|i �}q.q || _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)r? r� �boolr- r r )rR �fieldsZ field_dictr� �dr0 r7 r7 r8 �add_select_related� s zQuery.add_select_relatedc C s� |r�i }|rt |�}nt g �}|�� D ]t\} } | �| � t| �} g } | �d�} | dkr�| dksn| | d dkr|| �t|�� | �d| d �} qN| | f|| < q&| j�|� |s�|r�| j � t ||�t � |r�| j t|�7 _ |r�|| _dS )zm Add data to the various extra_* attributes for user-created additions to the query. z%sr^ r r� �%r N)rb rr r� r� �findr4 r� r� r r� r� r) r' r ri r ) rR r� Z select_paramsr� rJ Ztablesr Z select_pairsZ param_iterr2 �entryZ entry_paramsrG r7 r7 r8 � add_extra� s, zQuery.add_extrac C s t � df| _dS )z0Remove any fields from the deferred loading set.TN)� frozensetr, r^ r7 r7 r8 �clear_deferred_loading s z Query.clear_deferred_loadingc C sb | j \}}|r |�|�df| _ n>|�|� }r:|df| _ n$| �� t|��|� }r^|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� rg r r: )rR r. �existingr/ Z new_existingZnew_onlyr7 r7 r8 �add_deferred_loading# s zQuery.add_deferred_loadingc C s^ | j \}}t|�}d|v r6|�d� |�| �� jj� |rL|�|�df| _ nt|�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: �remover� r� r� r2 rg r )rR r. r r/ r7 r7 r8 �add_immediate_loading< s zQuery.add_immediate_loadingc C s$ |du rd| _ n t|�| _ d| _dS )z@Set the mask of annotations that will be returned by the SELECT.N)r� r: r� �rR r� r7 r7 r8 r� T s zQuery.set_annotation_maskc C s | j d ur | �| j �|�� d S r1 )r� r� r� r r7 r7 r8 r� \ s z Query.append_annotation_maskc C s$ |du rd| _ n t|�| _ d| _dS )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 r7 r7 r8 r ` s zQuery.set_extra_maskc C st d| _ | �� | �� d| _|r�g }g }g }| jsB| jsBt|�}nFd| _|D ]:}|| jv rf|� |� qL|| j v r||� |� qL|� |� qL| � |� | � |� t || | �}n dd� | jjjD �}t |�}| jdu �r| �dd� | jjjD �d� | jdd� | �� nR| j�rZg }| jD ]4}t|t��rB|j|v�rB| j|j }|� |� �qt|�| _t|�| _| �|d� d S )NFTc S s g | ] }|j �qS r7 r� r4 r7 r7 r8 rZ � r[ z$Query.set_values.<locals>.<listcomp>c s s | ] }|j V qd S r1 r� r4 r7 r7 r8 r9 � r[ z#Query.set_values.<locals>.<genexpr>r� )r� r r� r r� r� ra r� rP r4 rQ r r� r r r� r� r� r� r� r? r �refsri r� ) rR r� r. Z extra_namesZannotation_namesr6 �selectedr� r� r7 r7 r8 � set_valuesk sJ � zQuery.set_valuesc sN � j dur� j S � jsi S � jdurD� fdd�� j�� D �� _ � j S � jS dS )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 s i | ]\}}|� j v r||�qS r7 )r� r� r^ r7 r8 rp � s �z+Query.annotation_select.<locals>.<dictcomp>)r� r� r� rr r^ r7 r^ r8 rQ � s �zQuery.annotation_selectc sN � j d ur� j S � jsi S � jd urD� fdd�� j�� D �� _ � j S � jS d S )Nc s i | ]\}}|� j v r||�qS r7 )r� r� r^ r7 r8 rp � s z&Query.extra_select.<locals>.<dictcomp>)r� r� r� rr r^ r7 r^ r8 rP � s �zQuery.extra_selectc s� g }|D ]\}}|� |� qd}�fdd��jD �}t|�D ]@\}}|jrN q~�j||d jtkrjd}|| } ��| � q<|jj} |} g } |D ]2\} }| t |� dk r� q�| � | � | t |�8 } q�| � | j d j � t �| �} �j||d }|jtk�r\|j�s\dd� | jD �}||d � ��|| � | �d||d �}|�rt�j�|t� nd d� | jD �}|| � �jD ]6}�j| dk�rz���j| j|��j|< �q��qz��� 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 r7 )r� r� r� r^ r7 r8 rZ � s z$Query.trim_start.<locals>.<listcomp>r� Tr c S s g | ] }|d �qS rW r7 r� r7 r7 r8 rZ � r[ Nc S s g | ] }|d �qS rY r7 r� r7 r7 r8 rZ � r[ c s g | ]}|� � ��qS r7 )r� r4 )� select_aliasr7 r8 rZ r[ )r? r� rF r� r r r rk r� r� r4 r� r2 r r� r* r� Zget_extra_restrictionr� r� r' r� rW r5 r )rR r� Z all_pathsr� �pathsr� Z lookup_tablesZ trimmed_pathsrG r� rk Zpaths_in_prefixr� r2 Z first_joinZ select_fieldsZextra_restrictionrn r7 )r rR r8 r� � sZ � � � zQuery.trim_startc C s |j p|jott jjS )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. )�nullZempty_strings_allowedr r r` r� )rR r� r7 r7 r8 r� s �zQuery.is_nullable)T)NNT)N)T)N)N)N)FN)r� )N)NF)T)N)F)F)FFNTTFTF)FFTTTF)FF)TF)NTF)FT)TNF)NN)T)FT)T)�rf rv rw rx r3 r� r r� r� r# rW r% r� r� r� Zstandard_orderingr� r� r� r� r rN rO r� r r� Zselect_for_update_nowaitZ select_for_update_skip_lockedZselect_for_update_ofZselect_for_no_key_updater� r � max_depthr� r� r� r� Zcombinator_allr� r� r� r r r, r� rS ry r� r, r� rk r� r� r� r� rU r r� r� r� r� r� r� r� r r r! r+ r1 r7 r9 r r@ rA rB r� r r� rZ r� rd r� r� r� rq r� r� rs r| r~ r� r� r� r� r� r� r� r� r� r� r� r� ry ra r� � classmethodr� 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 rQ rP r� r� r7 r7 r7 r8 r/ � s: - 4 s . % - 7 2! . � ( � % � y � } 2E 3% !! 4 M�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 r� r� N)r! )r� �defaultZdirnr7 r7 r8 � get_order_dir! s r c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) r z] A class to abstract away join promotion problems for complex filter conditions. c C sD || _ || _| jr*|tkr"t| _q2t| _n| j | _|| _t� | _d S r1 )r r� r' r( �effective_connector� num_childrenr �votes)rR r r r� r7 r7 r8 rS 5 s zJoinPromoter.__init__c C s& | j j� d| j�d| j�d| j�d�S )Nz (connector=z, num_children=z , negated=�))re rw r r r� r^ r7 r7 r8 rg D s ���zJoinPromoter.__repr__c C s | j �|� dS )z` Add single vote per item to self.votes. Parameter can be any iterable. N)r r )rR r r7 r7 r8 r J s zJoinPromoter.add_votesc C s~ t � }t � }| j�� D ]N\}}| jtkr<|| jk r<|�|� | jtksZ| jtkr|| jkr|�|� 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 rr r r( r r� r' r@ rA )rR r� Z to_promoteZ to_demotern r r7 r7 r8 r Q s �� z JoinPromoter.update_join_typesN)rf rv rw rx rS rg r r r7 r7 r7 r8 r / s r )r )Prx r� r� r� rT � collectionsr r �collections.abcr r � itertoolsr r r �stringr Zdjango.core.exceptionsr r Z django.dbr r r Zdjango.db.models.aggregatesr Zdjango.db.models.constantsr Z django.db.models.expressionsr r r r r r r r Zdjango.db.models.fieldsr Z'django.db.models.fields.related_lookupsr Zdjango.db.models.lookupsr Z django.db.models.query_utilsr r r Z django.db.models.sql.constantsr r r! r" Z#django.db.models.sql.datastructuresr# r$ r% r& Zdjango.db.models.sql.wherer' r( r) r* r+ Zdjango.utils.functionalr, Zdjango.utils.regex_helperr- Zdjango.utils.treer. �__all__re r� r= r@ rC r0 rz r/ r r r7 r7 r7 r8 �<module> sp ( �I