File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/sql.tar
Back
datastructures.py 0000644 00000016201 15030124302 0010161 0 ustar 00 """ Useful auxiliary data structures for query construction. Not useful outside the SQL domain. """ from django.core.exceptions import FullResultSet from django.db.models.sql.constants import INNER, LOUTER class MultiJoin(Exception): """ Used by join construction code to indicate the point at which a multi-valued join was attempted (if the caller wants to treat that exceptionally). """ def __init__(self, names_pos, path_with_names): self.level = names_pos # The path travelled, this includes the path to the multijoin. self.names_with_path = path_with_names class Empty: pass class Join: """ Used by sql.Query and sql.SQLCompiler to generate JOIN clauses into the FROM entry. For example, the SQL generated could be LEFT OUTER JOIN "sometable" T1 ON ("othertable"."sometable_id" = "sometable"."id") This class is primarily used in Query.alias_map. All entries in alias_map must be Join compatible by providing the following attributes and methods: - table_name (string) - table_alias (possible alias for the table, can be None) - join_type (can be None for those entries that aren't joined from anything) - parent_alias (which table is this join's parent, can be None similarly to join_type) - as_sql() - relabeled_clone() """ def __init__( self, table_name, parent_alias, table_alias, join_type, join_field, nullable, filtered_relation=None, ): # Join table self.table_name = table_name self.parent_alias = parent_alias # Note: table_alias is not necessarily known at instantiation time. self.table_alias = table_alias # LOUTER or INNER self.join_type = join_type # A list of 2-tuples to use in the ON clause of the JOIN. # Each 2-tuple will create one join condition in the ON clause. self.join_cols = join_field.get_joining_columns() # Along which field (or ForeignObjectRel in the reverse join case) self.join_field = join_field # Is this join nullabled? self.nullable = nullable self.filtered_relation = filtered_relation def as_sql(self, compiler, connection): """ Generate the full LEFT OUTER JOIN sometable ON sometable.somecol = othertable.othercol, params clause for this join. """ join_conditions = [] params = [] qn = compiler.quote_name_unless_alias qn2 = connection.ops.quote_name # Add a join condition for each pair of joining columns. for lhs_col, rhs_col in self.join_cols: join_conditions.append( "%s.%s = %s.%s" % ( qn(self.parent_alias), qn2(lhs_col), qn(self.table_alias), qn2(rhs_col), ) ) # Add a single condition inside parentheses for whatever # get_extra_restriction() returns. extra_cond = self.join_field.get_extra_restriction( self.table_alias, self.parent_alias ) if extra_cond: extra_sql, extra_params = compiler.compile(extra_cond) join_conditions.append("(%s)" % extra_sql) params.extend(extra_params) if self.filtered_relation: try: extra_sql, extra_params = compiler.compile(self.filtered_relation) except FullResultSet: pass else: join_conditions.append("(%s)" % extra_sql) params.extend(extra_params) if not join_conditions: # This might be a rel on the other end of an actual declared field. declared_field = getattr(self.join_field, "field", self.join_field) raise ValueError( "Join generated an empty ON clause. %s did not yield either " "joining columns or extra restrictions." % declared_field.__class__ ) on_clause_sql = " AND ".join(join_conditions) alias_str = ( "" if self.table_alias == self.table_name else (" %s" % self.table_alias) ) sql = "%s %s%s ON (%s)" % ( self.join_type, qn(self.table_name), alias_str, on_clause_sql, ) return sql, params def relabeled_clone(self, change_map): new_parent_alias = change_map.get(self.parent_alias, self.parent_alias) new_table_alias = change_map.get(self.table_alias, self.table_alias) if self.filtered_relation is not None: filtered_relation = self.filtered_relation.clone() filtered_relation.path = [ change_map.get(p, p) for p in self.filtered_relation.path ] else: filtered_relation = None return self.__class__( self.table_name, new_parent_alias, new_table_alias, self.join_type, self.join_field, self.nullable, filtered_relation=filtered_relation, ) @property def identity(self): return ( self.__class__, self.table_name, self.parent_alias, self.join_field, self.filtered_relation, ) def __eq__(self, other): if not isinstance(other, Join): return NotImplemented return self.identity == other.identity def __hash__(self): return hash(self.identity) def equals(self, other): # Ignore filtered_relation in equality check. return self.identity[:-1] == other.identity[:-1] def demote(self): new = self.relabeled_clone({}) new.join_type = INNER return new def promote(self): new = self.relabeled_clone({}) new.join_type = LOUTER return new class BaseTable: """ The BaseTable class is used for base table references in FROM clause. For example, the SQL "foo" in SELECT * FROM "foo" WHERE somecond could be generated by this class. """ join_type = None parent_alias = None filtered_relation = None def __init__(self, table_name, alias): self.table_name = table_name self.table_alias = alias def as_sql(self, compiler, connection): alias_str = ( "" if self.table_alias == self.table_name else (" %s" % self.table_alias) ) base_sql = compiler.quote_name_unless_alias(self.table_name) return base_sql + alias_str, [] def relabeled_clone(self, change_map): return self.__class__( self.table_name, change_map.get(self.table_alias, self.table_alias) ) @property def identity(self): return self.__class__, self.table_name, self.table_alias def __eq__(self, other): if not isinstance(other, BaseTable): return NotImplemented return self.identity == other.identity def __hash__(self): return hash(self.identity) def equals(self, other): return self.identity == other.identity constants.py 0000644 00000001025 15030124302 0007116 0 ustar 00 """ Constants specific to the SQL storage portion of the ORM. """ # Size of each "chunk" for get_iterator calls. # Larger values are slightly faster at the expense of more storage space. GET_ITERATOR_CHUNK_SIZE = 100 # Namedtuples for sql.* internal use. # How many results to expect from a cursor.execute call MULTI = "multi" SINGLE = "single" CURSOR = "cursor" NO_RESULTS = "no results" ORDER_DIR = { "ASC": ("ASC", "DESC"), "DESC": ("DESC", "ASC"), } # SQL join types. INNER = "INNER JOIN" LOUTER = "LEFT OUTER JOIN" __pycache__/where.cpython-310.pyc 0000644 00000025007 15030124302 0012561 0 ustar 00 o �h�1 � @ s� d Z ddlZddlmZ ddlmZmZ ddlmZm Z ddl m Z ddl m Z ddlmZ d Zd Zd ZG d d � d e j�ZG dd� d�ZG dd� d�ZG dd� d�ZdS )zG Code to manage the creation and SQL rendering of 'where' constraints. � N)�reduce)�EmptyResultSet� FullResultSet��Case�When)�Exact)�tree)�cached_property�AND�OR�XORc @ s e Zd ZdZeZdZdZd5dd�Zdd� Z dd � Z d d � Z d d � Z dd� Z dd� Zdd� Zdd� Zdd� Zedd� �Zedd� �Zed d � �Zed d � �Zed d!� �Zed"d#� �Zed$d%� �Z d&d'� Z ed(d)� �Z ed*d+� �Z d,d-� Z d.d/� Z!d0d1� Z"d2d3� Z#d4S )6� WhereNodea� An SQL WHERE clause. The class is tied to the Query class that created it (in order to create the correct SQL). A child is usually an expression producing boolean values. Most likely the expression is a Lookup instance. However, a child could also be any class with as_sql() and either relabeled_clone() method or relabel_aliases() and clone() methods and contains_aggregate attribute. FTc C s~ | j s | js | ddfS || jA }|r| jtkp#| o | jtkp#| jtk}|r1| j r1| js1d| dfS g }g }g }| jD ]C}t|d�rf|� ||�\} } } | durS|� | � | dur\|� | � | dure|� | � q:|jro|� |� q:|j rx|� |� q:|� |� q:|r�|r�|r�|r�|s�dd| fS |r�t d��|r�| � || j| j�nd} |r�| � || j| j�nd} |r�| � || j| j�nd}| | |fS )a Return three possibly None nodes: one for those parts of self that should be included in the WHERE clause, one for those parts of self that must be included in the HAVING clause, and one for those parts that refer to window functions. N�split_having_qualifyzzHeterogeneous disjunctive predicates against window functions are not implemented when performing conditional aggregation.) �contains_aggregate�contains_over_clause�negated� connectorr r r �children�hasattrr �append�NotImplementedError�create)�selfr � must_group_by� in_negated�must_remain_connected� where_parts� having_parts� qualify_parts�c� where_part� having_part� qualify_part� where_node� having_node� qualify_node� r' �P/usr/local/CyberPanel/lib/python3.10/site-packages/django/db/models/sql/where.pyr & sn ����� � � ������� z WhereNode.split_having_qualifyc C s� g }g }| j tkrt| j�d}}ndt| j�}}| j tkrI|jjsI| �| jt�}t t j dd� | jD ��}t d|�} | �|| gt| j ��||�S | jD ]L} z |�| �\} } W n tyd |d8 }Y n typ |d8 }Y nw | r~|�| � |�| � n|d8 }|dkr�| j r�t�t�|dkr�| j r�t�t�qLd| j } | �|�}|s�t�| j r�d| }||fS t|�dks�| jr�d| }||fS )a Return the SQL version of the where clause and the value to be substituted in. Return '', [] if this node matches everything, None, [] if this node is empty, and raise EmptyResultSet if this node can't match anything. � c s s$ � | ] }t t|d d�dd�V qdS )r) )�thenr )�defaultNr ��.0r r' r' r( � <genexpr>� s �" z#WhereNode.as_sql.<locals>.<genexpr>r z %s zNOT (%s)�(%s))r r �lenr r �features�supports_logical_xor� __class__r r �operator�addr r �as_sql�compiler r r �extend�join�resolved)r �compiler� connection�result� result_params� full_needed� empty_needed�lhs�rhs_sum�rhs�child�sql�params�conn� sql_stringr' r' r( r6 r s\ � � � � �zWhereNode.as_sqlc C s" g }| j D ] }|�|�� � q|S �N)r r8 �get_group_by_cols)r �colsrD r' r' r( rJ � s zWhereNode.get_group_by_colsc C s | j d d � S rI )r �r r' r' r( �get_source_expressions� s z WhereNode.get_source_expressionsc C s t |�t | j�ks J �|| _d S rI )r0 r )r r r' r' r( �set_source_expressions� s z WhereNode.set_source_expressionsc C sH t | j�D ] \}}t|d�r|�|� qt|d�r!|�|�| j|< qdS )z� Relabel the alias values of any children. 'change_map' is a dictionary mapping old (current) alias values to the new values. �relabel_aliases�relabeled_cloneN)� enumerater r rO rP )r � change_map�posrD r' r' r( rO � s ��zWhereNode.relabel_aliasesc C s@ | j | j| jd�}| jD ]}t|d�r|�� }|j�|� q |S )N�r r �clone)r r r r r rU r )r rU rD r' r' r( rU � s zWhereNode.clonec C s | � � }|�|� |S rI )rU rO )r rR rU r' r' r( rP � s zWhereNode.relabeled_clonec C sF |� | � }r |S | j| j| jd�}| jD ] }|j�|�|�� q|S )NrT )�getr r r r r �replace_expressions)r � replacements� replacementrU rD r' r' r( rW � s z WhereNode.replace_expressionsc C s" t � }| jD ]}||�� O }q|S rI )�setr �get_refs)r �refsrD r' r' r( r[ � s zWhereNode.get_refsc �* t |tj�rt� fdd�|jD ��S |jS )Nc 3 � � | ]}� � |�V qd S rI ��_contains_aggregater, ��clsr' r( r. � � � z0WhereNode._contains_aggregate.<locals>.<genexpr>)� isinstancer �Node�anyr r �rb �objr' ra r( r` � � z WhereNode._contains_aggregatec C � | � | �S rI r_ rL r' r' r( r � � z WhereNode.contains_aggregatec r] )Nc 3 r^ rI ��_contains_over_clauser, ra r' r( r. � rc z2WhereNode._contains_over_clause.<locals>.<genexpr>)rd r re rf r r rg r' ra r( rm � ri z WhereNode._contains_over_clausec C rj rI rl rL r' r' r( r � rk z WhereNode.contains_over_clausec C s t dd� | jD ��S )Nc s s � | ]}|j V qd S rI )� is_summary)r- rD r' r' r( r. s � z'WhereNode.is_summary.<locals>.<genexpr>)rf r rL r' r' r( rn s zWhereNode.is_summaryc O s& t | d�r| j|g|�R i |��} | S )N�resolve_expression)r ro )�expr�query�args�kwargsr' r' r( � _resolve_leaf s zWhereNode._resolve_leafc O s� t |d�r|jD ]}| j||g|�R i |�� qt |d�r,| j|j|g|�R i |��|_t |d�rB| j|j|g|�R i |��|_d S d S )Nr rA rC )r r � _resolve_nodert rA rC )rb �noderq rr rs rD r' r' r( ru s "�zWhereNode._resolve_nodec O s* | � � }|j|g|�R i |�� d|_|S )NT)rU ru r: )r rr rs rU r' r' r( ro s z WhereNode.resolve_expressionc C s ddl m} |� S )Nr )� BooleanField)�django.db.modelsrw )r rw r' r' r( � output_field s zWhereNode.output_fieldc C s | j S rI )ry rL r' r' r( �_output_field_or_none s z WhereNode._output_field_or_nonec C s |j jjs d|� d�}||fS )Nz CASE WHEN z THEN 1 ELSE 0 END)r< r1 �&supports_boolean_expr_in_select_clause)r r; rE rF r' r' r( � select_format$ s zWhereNode.select_formatc C � | j �|�S rI )ry �get_db_converters)r r< r' r' r( r~ , � zWhereNode.get_db_convertersc C r} rI )ry � get_lookup)r �lookupr' r' r( r� / r zWhereNode.get_lookupc c s2 � | j D ]}t|t�r|�� E d H q|V qd S rI )r rd r �leaves)r rD r' r' r( r� 2 s � �zWhereNode.leavesN)FF)$�__name__� __module__� __qualname__�__doc__r r+ r: � conditionalr r6 rJ rM rN rO rU rP rW r[ � classmethodr` r r rm r �propertyrn � staticmethodrt ru ro ry rz r| r~ r� r� r' r' r' r( r sL LF r c @ s" e Zd ZdZdZdZddd�ZdS )� NothingNodez A node that matches nothing.FNc C s t �rI )r )r r; r< r' r' r( r6 @ s zNothingNode.as_sql�NN)r� r� r� r� r r r6 r' r' r' r( r� : s r� c @ s& e Zd ZdZdZdd� Zddd�ZdS )� ExtraWhereFc C s || _ || _d S rI )�sqlsrF )r r� rF r' r' r( �__init__I s zExtraWhere.__init__Nc C s( dd� | j D �}d�|�t| jpd�fS )Nc S s g | ]}d | �qS )r/ r' )r- rE r' r' r( � <listcomp>N s z%ExtraWhere.as_sql.<locals>.<listcomp>z AND r' )r� r9 �listrF )r r; r< r� r' r' r( r6 M s zExtraWhere.as_sqlr� �r� r� r� r r r� r6 r' r' r' r( r� D s r� c @ s$ e Zd ZdZdZdd� Zdd� ZdS )�SubqueryConstraintFc C s( || _ || _|| _|jdd� || _d S )NT)� clear_default)�alias�columns�targets�clear_ordering� query_object)r r� r� r� r� r' r' r( r� X s zSubqueryConstraint.__init__c C s0 | j }|�| j� |j|d�}|�| j| j|�S )N)r< )r� � set_valuesr� � get_compiler�as_subquery_conditionr� r� )r r; r< rq �query_compilerr' r' r( r6 _ s zSubqueryConstraint.as_sqlNr� r' r' r' r( r� R s r� )r� r4 � functoolsr �django.core.exceptionsr r � django.db.models.expressionsr r �django.db.models.lookupsr � django.utilsr �django.utils.functionalr r r r re r r� r� r� r' r' r' r( �<module> s" ) __pycache__/subqueries.cpython-310.pyc 0000644 00000014147 15030124302 0013641 0 ustar 00 o �h/ � @ s| d Z ddlmZ ddlmZmZmZ ddlmZ g d�Z G dd� de�Z G dd � d e�Z G d d � d e�Z G d d � d e�Z dS )zR Query subclasses which provide extra functionality beyond simple data retrieval. � )� FieldError)�CURSOR�GET_ITERATOR_CHUNK_SIZE� NO_RESULTS)�Query)� DeleteQuery� UpdateQuery� InsertQuery�AggregateQueryc @ s$ e Zd ZdZdZdd� Zdd� ZdS )r zA DELETE SQL query.�SQLDeleteCompilerc C sX || j | i| _ || _| �|��t�}|r*|� |jW d � S 1 s%w Y dS )Nr )� alias_map�where� get_compiler� execute_sqlr �rowcount)�self�tabler �using�cursor� r �U/usr/local/CyberPanel/lib/python3.10/site-packages/django/db/models/sql/subqueries.py�do_query s �zDeleteQuery.do_queryc C sl d}| � � j}tdt|�t�D ]$}| �� | �|j� d�|||t � � || j| � � j | j |d�7 }q|S )z� Set up and execute delete queries for all the objects in pk_list. More than one physical query may be executed if there are a lot of values in pk_list. r �__in)r ) �get_meta�pk�range�lenr � clear_where� add_filter�attnamer �db_tabler )r �pk_listr � num_deleted�field�offsetr r r � delete_batch s � �zDeleteQuery.delete_batchN)�__name__� __module__� __qualname__�__doc__�compilerr r% r r r r r s r c s` e Zd ZdZdZ� fdd�Zdd� Z� fdd�Zd d � Zd d � Z d d� Z dd� Z dd� Z � Z S )r zAn UPDATE SQL query.�SQLUpdateCompilerc s t � j|i |�� | �� d S �N)�super�__init__� _setup_query)r �args�kwargs�� __class__r r r. 5 s zUpdateQuery.__init__c C s g | _ d| _i | _dS )z� Run on initialization and at the end of chaining. Any attributes that would normally be set in __init__() should go here instead. N)�values� related_ids�related_updates)r r r r r/ 9 s zUpdateQuery._setup_queryc s t � �� }| j�� |_|S r, )r- �cloner6 �copy)r �objr2 r r r7 B s zUpdateQuery.clonec C sT | � |� tdt|�t�D ]}| �� | �d|||t � � | �|��t� q d S )Nr �pk__in) �add_update_valuesr r r r r r r r )r r! r4 r r$ r r r � update_batchG s ��zUpdateQuery.update_batchc C s� g }|� � D ]A\}}| �� �|�}|jo|j p |j }|jjj}|r*|jr0|j r0t d| ��|| �� jur?| � |||� q|� |||f� q| � |�S )z� Convert a dictionary of field name to value mappings into an update query. This is the entry point for the public update() method on querysets. zMCannot update model field %r (only non-relations and foreign keys permitted).)�itemsr � get_field� auto_created�concrete�model�_meta�concrete_model� is_relation� many_to_manyr �add_related_update�append�add_update_fields)r r4 � values_seq�name�valr# �directrA r r r r; P s" � �� z UpdateQuery.add_update_valuesc C s@ |D ]\}}}t |d�r|j| ddd�}| j�|||f� qdS )z� Append a sequence of (field, model, value) triples to the internal list that will be used to generate the UPDATE query. Might be more usefully called add_update_targets() to hint at the extra information here. �resolve_expressionFT)� allow_joins�for_saveN)�hasattrrM r4 rG )r rI r# rA rK r r r rH h s �z UpdateQuery.add_update_fieldsc C s | j �|g ��|d|f� dS )z� Add (name, value) to an update query for an ancestor model. Update are coalesced so that only one update query per ancestor is run. N)r6 � setdefaultrG )r rA r# �valuer r r rF t s z UpdateQuery.add_related_updatec C sZ | j sg S g }| j �� D ] \}}t|�}||_| jdur%|�d| j| � |�|� q |S )z� Return a list of query objects: one for each update required to an ancestor model. Each query will have the same filtering conditions as the current query but will only update a single table. Nr: )r6 r= r r4 r5 r rG )r �resultrA r4 �queryr r r �get_related_updates| s z UpdateQuery.get_related_updates)r& r' r( r) r* r. r/ r7 r< r; rH rF rU � __classcell__r r r2 r r 0 s r c s4 e Zd ZdZdddd�� fdd� Zd dd�Z� ZS ) r �SQLInsertCompilerN)� on_conflict� update_fields� unique_fieldsc s< t � j|i |�� g | _g | _|| _|pg | _|pg | _d S r, )r- r. �fields�objsrX rY rZ )r rX rY rZ r0 r1 r2 r r r. � s zInsertQuery.__init__Fc C s || _ || _|| _d S r, )r[ r\ �raw)r r[ r\ r] r r r � insert_values� s zInsertQuery.insert_values)F)r& r' r( r* r. r^ rV r r r2 r r � s � r c s$ e Zd ZdZdZ� fdd�Z� ZS )r zu Take another query as a parameter to the FROM clause and only select the elements in the provided list. �SQLAggregateCompilerc s || _ t� �|� d S r, )� inner_queryr- r. )r rA r` r2 r r r. � s zAggregateQuery.__init__)r& r' r( r) r* r. rV r r r2 r r � s r N)r) �django.core.exceptionsr � django.db.models.sql.constantsr r r �django.db.models.sql.queryr �__all__r r r r r r r r �<module> s $^ __pycache__/__init__.cpython-310.pyc 0000644 00000000634 15030124302 0013205 0 ustar 00 o �h� � @ s< d dl T d dl mZ d dlT d dlmZmZmZ g d�ZdS )� )�*)�Query)�AND�OR�XOR)r r r r N)�django.db.models.sql.queryr � django.db.models.sql.subqueries�django.db.models.sql.wherer r r �__all__� r r �S/usr/local/CyberPanel/lib/python3.10/site-packages/django/db/models/sql/__init__.py�<module> s __pycache__/constants.cpython-310.pyc 0000644 00000000746 15030124302 0013466 0 ustar 00 o �h � @ s. d Z dZdZdZdZdZddd�ZdZd Zd S ) z; Constants specific to the SQL storage portion of the ORM. �d �multi�single�cursorz no results)�ASC�DESC)r r z INNER JOINzLEFT OUTER JOINN) �__doc__�GET_ITERATOR_CHUNK_SIZE�MULTI�SINGLE�CURSOR� NO_RESULTS� ORDER_DIR�INNER�LOUTER� r r �T/usr/local/CyberPanel/lib/python3.10/site-packages/django/db/models/sql/constants.py�<module> s � __pycache__/compiler.cpython-310.pyc 0000644 00000145157 15030124302 0013272 0 ustar 00 o �h,\ � @ sz d dl Z d dlZd dlZd dlmZ d dlmZ d dlmZm Z m Z d dl m Z m Z d dlmZ d dlmZmZmZmZmZ d dlmZmZ d d lmZ d d lm Z d d l m Z m Z m Z m!Z!m"Z"m#Z# d d l$m%Z%m&Z& d d l'm(Z( d dl)m*Z* d dl+m,Z, d dl-m.Z. d dl/m0Z0 G dd� de�Z1G dd� d�Z2G dd� de2�Z3G dd� de2�Z4G dd� de2�Z5G d d � d e2�Z6d d � Z7dS ) � N)�partial)�chain)�EmptyResultSet� FieldError� FullResultSet)� DatabaseError�NotSupportedError)� LOOKUP_SEP)�F�OrderBy�RawSQL�Ref�Value)�Cast�Random)�Lookup)�select_related_descend)�CURSOR�GET_ITERATOR_CHUNK_SIZE�MULTI� NO_RESULTS� ORDER_DIR�SINGLE)�Query� get_order_dir)�AND)�TransactionManagementError)�cached_property)� make_hashable)�_lazy_re_compilec s$ e Zd Z� fdd�Zdd� Z� ZS )� PositionRefc s || _ t� �||� d S �N)�ordinal�super�__init__)�selfr" �refs�source�� __class__� �S/usr/local/CyberPanel/lib/python3.10/site-packages/django/db/models/sql/compiler.pyr$ s zPositionRef.__init__c C s t | j�dfS )Nr* )�strr" )r% �compiler� connectionr* r* r+ �as_sql# s zPositionRef.as_sql)�__name__� __module__� __qualname__r$ r/ � __classcell__r* r* r( r+ r s r c @ s6 e Zd ZedejejB �ZdAdd�Zdd� Z dBdd �Z dBd d �Z d d � Z dd� Z dBdd�Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � ZdCd d!�Z "dDd#d$�Zd%d&� Z "dEd(d)�Zd*d+� Zd,d-� Z " " . " "dFd/d0�Z d1d2� Z d3d4� Z d5d6� Z d"dde fd7d8�Z!d9d:� Z"e#de fd;d<�Z$d=d>� Z%d?d@� Z&d"S )G� SQLCompilerz^(.*)\s(?:ASC|DESC).*Tc C s> || _ || _|| _|| _ddi| _d | _d | _d | _d | _d S )N�*) �queryr. �using� elide_empty� quote_cache�select�annotation_col_map� klass_info�_meta_ordering)r% r6 r. r7 r8 r* r* r+ r$ . s zSQLCompiler.__init__c C s, d| j j� d| jjj� d| j�d| j�d� S )N�<z model=z connection=z using=�>)r) r2 r6 �modelr. r7 �r% r* r* r+ �__repr__? s ����zSQLCompiler.__repr__Fc sL t � fdd�� jjD ��r� j�� � j|d�\� _� _� _t� j�� _ d S )Nc 3 s � | ] }� j j| d kV qdS �r N�r6 �alias_refcount)�.0�arA r* r+ � <genexpr>G � � z*SQLCompiler.setup_query.<locals>.<genexpr>��with_col_aliases) �allr6 � alias_map�get_initial_alias� get_selectr: r< r; �len� col_count)r% rK r* rA r+ � setup_queryF s �zSQLCompiler.setup_queryc C sl | j |d� | �� }| jjj| jjdud�\| _| _| _| �|| j �}t |�| _ | � | j | |�}|||fS )z� Do any necessary class setup immediately prior to producing SQL. This is for things that can't necessarily be done in __init__ because we might not have all the pieces in place at that time. rJ N)� must_group_by) rR � get_order_byr6 �where�split_having_qualify�group_by�having�qualify�get_extra_selectr: �bool�has_extra_select� get_group_by)r% rK �order_by� extra_selectrW r* r* r+ � pre_sql_setupN s � zSQLCompiler.pre_sql_setupc C s� | j jdu rg S g }t� }| j jdurA| j jD ])}t|d�s$| j �|�}t|t�r;|j|vr:|�|j� |� |j � q|� |� qi }t |dd�D ]\}\}}} | rV|||< | |v r[qI|� |� � � qI| jsy|D ]\}\} } } | sx|� |� � � qh| jr�| j� � nd} | D ]}|� |� q�g }t� }| �|| �}| jjj}|D ]K}z | �|�\} } W n ttfy� Y q�w |r�|�|� }dur�t|�d} } n |�| | | �\} } t| �}| |f|vr�|� | | f� |�| |f� q�|S )z� Return a list of 2-tuples of form (sql, params). The logic of what exactly the GROUP BY clause contains is hard to describe in other words than "if it passes the test suite, then it is correct". NTr/ � ��startr* )r6 rW �set�hasattr� resolve_ref� isinstancer r& �add�appendr' � enumerate�extend�get_group_by_colsr= rX �collapse_group_byr. �features� allows_group_by_select_index�compiler r �getr, � select_formatr )r% r: r^ � expressions� group_by_refs�expr�selected_expr_indices�index�_�alias�sql�params�is_ref�having_group_by�result�seenro � select_index� params_hashr* r* r+ r] ^ sf & � � ��� �zSQLCompiler.get_group_byc sD �j jjr �fdd�|D ��dd� �D �� � ��fdd�|D �}|S )Nc s4 h | ]}t |d �r|jjr� jj�|jj�r|�qS )�target)re r� � primary_keyr. rn �%allows_group_by_selected_pks_on_modelr@ �rF ru rA r* r+ � <setcomp>� s �����z0SQLCompiler.collapse_group_by.<locals>.<setcomp>c S s h | ]}|j �qS r* )ry r� r* r* r+ r� � s c s0 g | ]}|�v s|�v st |d d�� vr|�qS )ry N)�getattrr� )�aliasesrX �pksr* r+ � <listcomp>� s �z1SQLCompiler.collapse_group_by.<locals>.<listcomp>)r. rn � allows_group_by_selected_pks)r% rs rX r* )r� rX r� r% r+ rm � s � �z SQLCompiler.collapse_group_byc s g }d}i }d}| j j�� D ]\}\}}|||< |�t||�|f� |d7 }q| j jr1| j jr1J �| j �� } | j jr@| �| �} n| j j} | rdg } | D ]} | �|� |�| df� |d7 }qJ| j j | d�}| j j �� D ]\}} |||< |�| |f� |d7 }qj| j j r�| � || �}||d< � fdd�� � |� g }d}|D ]b\} }z | � | �\}}W n2 ty� t| dt�}|tu r�d \}}n | � t|��\}}Y n ty� | � td ��\}}Y n w | �| ||�\}}|du r�|r�d |� �}|d7 }|�| ||f|f� q�|||fS ) a� Return three values: - a list of 3-tuples of (expression, (sql, params), alias) - a klass_info structure, - a dictionary of annotations The (sql, params) is what the expression will produce, and alias is the "AS alias" for the column (possibly None). The klass_info structure contains the following information: - The base model of the query. - Which columns for that model are present in the query (by position of the select clause). - related_klass_infos: [f, klass_info] to descent into The annotations is a dictionary of {'attname': column position} values. Nr ra )r@ � select_fields�related_klass_infosc s6 | d D ]}|d r| d |d |d< � |� qd S )Nr� � from_parentr� r* )r< �ki��get_select_from_parentr* r+ r� s � �z6SQLCompiler.get_select.<locals>.get_select_from_parent�empty_result_set_value)�0r* T�col)r6 r_ �itemsri r r: � default_cols�get_select_mask�get_default_columnsr@ �annotation_select�select_related�get_related_selectionsrp r r� �NotImplementedr r rr )r% rK r: r< � annotations� select_idxry rz r{ � select_mask�cols� select_listr� � annotationr� �ret�col_idxr� r* r� r+ rO � sj � � � � zSQLCompiler.get_selectc c s^ � | j jr | j j}n%| j js| j j}n | j jr | j j}n| j �� }r-|jr-|j}|| _ng }| j jr:td \}}ntd \}}i }|rg| j }rgt |dd�D ]\}\}}} t || |�} | rb| || < | ||< qO|D �]B} t | d�r�t | t�r|t| | j�} t | t�s�| �� } | j js�| �� } | �� |�| j�} | s�t | jt�r�|�| jj� } r�| jd u r�| jd u s�| jj j r�| �� } | | _n| j j r�| �� } t | j | j!�| _| | d ufV qi| dkr�tt"� �dfV qit#| |�\} }|dk}|�| � } �rt| |d�d fV qi| | j j$v �r2| j j �r| j �rt| �}n| j j$| }t |t��r(t||j�}t||d�dfV qid | v �rS| �%d d�\}} tt&d | �'|�| f g �|d�dfV qi| j j(�r�| | j j(v �r�| | j j)v �rytt | t&| j j(| � �|d�d fV qitt&| j j(| � |d�dfV qi| j j �r�| j �r�tt| �|d�dfV qi| j*| | j �� |d �E d H qid S ) N�ASC�DESCra rb �resolve_expression�?F�� descendingT�.�%s.%s)� default_order)+r6 �extra_order_by�default_orderingr^ �get_meta�orderingr= �standard_orderingr r: rj r re rg r r � output_fieldr �asc�copy�reverse_orderingrq � expressionr �name� nulls_first� nulls_lastr. rn � supports_order_by_nulls_modifier� combinatorr r& r' r r r� �splitr �quote_name_unless_alias�extrar_ �find_ordering_name)r% r� �metar� rx �selected_exprsr: r" ru ry �pos_expr�field� select_refr� �orderr� �tabler* r* r+ �_order_by_pairs< s� � ����� ��� �� ���zSQLCompiler._order_by_pairsc C sn g }t � }| �� D ]�\}}|j| jddd�}|s�| jjr�| jr�|j}|j}| jD ]/\}} } ||krW| jjrF| | jjv rFt |t �rE| |j ksFq(|� t | rM| n|jj|�g� n2q(t| jj�d } d| � �} | jjD ]} | jrrtd��| �|| � qi| j�|| � |� t | |�g� | �|�\} }| j�| �d }t|�}||f|v r�q |�||f� |�|| ||ff� q |S )a/ Return a list of 2-tuples of the form (expr, (sql, params, is_ref)) for the ORDER BY clause. The order_by clause can alter the select clause (for example it can add aliases to clauses that do not yet have one, or it can add totally new select clauses). TN)� allow_joins�reusera � __orderbycolz:ORDER BY term does not match any column in the result set.)rd r� r� r6 r� r: r� �has_select_fieldsr� rg r r� �set_source_expressionsr r� �columnrP �combined_queriesr �add_annotation�add_select_colrp �ordering_parts�searchr rh ri )r% r~ r ru r| �resolved�src�expr_src�sel_exprrx � col_alias� order_by_idx�qrz r{ �without_orderingr� r* r* r+ rT � sN � � �� � zSQLCompiler.get_order_byc C sn g }| j jr5| j js5dd� |D �}|D ]!\}\}}}| j�|�d } |s4| |f|vr4|�|| |fd f� q|S )Nc S � g | ]}|d �qS )ra r* �rF �tr* r* r+ r� � z0SQLCompiler.get_extra_select.<locals>.<listcomp>ra )r6 �distinct�distinct_fieldsr� r� ri ) r% r^ r: r_ � select_sqlru rz r{ r| r� r* r* r+ rZ � s �z SQLCompiler.get_extra_selectc C s| || j v r | j | S || jjv r|| jjvs)|| jjv s)| jj�|�r0|| jjvr0|| j |< |S | jj� |�}|| j |< |S )z� A wrapper around connection.ops.quote_name that doesn't quote aliases for table names. This avoids problems with some SQL dialects that treat quoted strings specially (e.g. PostgreSQL). ) r9 r6 rM � table_mapr_ �external_aliasesrq r. �ops� quote_name)r% r� �rr* r* r+ r� s � z#SQLCompiler.quote_name_unless_aliasc C sJ t |d| jj d �}|r|| | j�\}}||fS |�| | j�\}}||fS )N�as_)r� r. �vendorr/ )r% �node� vendor_implrz r{ r* r* r+ rp s �zSQLCompiler.compilec s� �j j}�fdd��jjD �}|js(|D ]}|jjr td��|�� r&td��qn�jjr8|dkr8|D ]}d|_q2d}|D ]n}zX|jj s`�jj r`|j� � |_|j� g �jj ��jj ��jj �R � |jdd �\}}|jjr�|jsud �|�}n�jjs||js�d �|�}n �jjr�|jr�d �|�}|||ff7 }W q< ty� |dks�|d kr�|r�Y q<� w |s�t��j jj| } |r�|dkr�| d 7 } d� �jjs�|jr�d � t� fdd�|D �� \} } d�| ��| �g} g } | D ]}| �|� q�| | fS )Nc s g | ] }|� � j� j� j��qS r* )� get_compilerr7 r. r8 )rF r6 rA r* r+ r� ' � ��z2SQLCompiler.get_combinator_sql.<locals>.<listcomp>z>LIMIT/OFFSET not allowed in subqueries of compound statements.z:ORDER BY not allowed in subqueries of compound statements.�unionFr* TrJ zSELECT * FROM ({})z({})� differencez ALLz{}c 3 s" � | ] \}}� � |�|fV qd S r! )�format)rF rz �args)�bracesr* r+ rH m s � z1SQLCompiler.get_combinator_sql.<locals>.<genexpr>z {} )r. rn r6 r� �%supports_slicing_ordering_in_compound� is_slicedr rT r8 � values_select�clone� set_valuesr_ r� r/ r� � supports_parentheses_in_compoundr� �subqueryr r� � set_operators�zip�joinrk )r% r� rL rn � compilersr- �parts�part_sql� part_args�combinator_sql� sql_parts� args_partsr~ r{ �partr* )r� r% r+ �get_combinator_sql% s� ����� ���� �� ��� � � z SQLCompiler.get_combinator_sqlc s� g }�j r |��j � �jr|��j� �j�� � d� _� j �|�� _ dd� �jdd�d D ��t�� � ��t� �i �� ����fdd�}|t �j � � �� �j � dd� ��� D ���_ g }��� D ]^}}||�� � |�|� d d� ��� D ��� qb� j�j�j�jd �}|jd dd �\}}���j �\} } d |d�jj�d�d| g} �rŇfdd��� � D �} dd�| �dg| �d��jj�d��} t |�| } |r�g }|D ]}��|�\}}|�|� | �|� q�| �dd�|�g� | | fS )NTc S s i | ]\}}}||�qS r* r* )rF ru rx ry r* r* r+ � <dictcomp>� s �z/SQLCompiler.get_qualify_sql.<locals>.<dictcomp>rJ r c s� | rR| � � }|�v r q ��|� }r|�|< n7t|t�r$| �|�� � n*t|t�r6|j�vr5| �|�� � nt��}d|� �}�� |� � � ||� |�|< | sd S d S )N�qual) �poprq rg r rk �get_source_expressionsr r& rP rh r� )rs ru � select_alias�num_qual_alias)� inner_query� qual_aliases� replacementsr: �select_aliasesr* r+ �collect_replacements� s$ � �z9SQLCompiler.get_qualify_sql.<locals>.collect_replacementsc S � i | ] \}}|t ||��qS r* �r �rF ru ry r* r* r+ r � � c S r r* r r r* r* r+ r � r )r. r8 F)� with_limitsrK �SELECT * FROM (�)rY �WHEREc s g | ] }� j j�|��qS r* )r. r� r� )rF ry rA r* r+ r� � � z/SQLCompiler.get_qualify_sql.<locals>.<listcomp>�SELECT�, zFROM (� qualify_maskzORDER BY)rU ri rX r6 r� r� r) rO rd �values�listrY �leaves�replace_expressionsr� rT r r� r7 r. r8 r/ rp r� r� r� rk )r% � where_partsr r^ � order_by_exprrx �inner_query_compiler� inner_sql� inner_params� qualify_sql�qualify_paramsr~ r� r{ � ordering_sqlsr� � ordering_sql�ordering_paramsr* )r r r r: r r% r+ �get_qualify_sqlu s~ � � �� � � ���� � zSQLCompiler.get_qualify_sqlc - C s� | j j�� }�z�| j j}| j|pt|�d�\}}}d}|o | j j} | j j}| jj} |rFt | d� |��s:t d� |���| � || j j �\} } �n�| jrS| �� \} } d}�n�| �� \} }| �� \}}z| jdurk| �| j�ndg f\}}W n ty� | jr}� dg }}Y n ty� dg }}Y nw z| jdur�| �| j�ndg f\}}W n ty� dg }}Y nw dg} g } | j jr�| jj�| |�\}}| |7 } | |7 } g }| j| D ] \}\}}}|r�d|| jj� |�f }| � |� |� |� q�| d � |�g7 } |�r| d g|�7 } n| jjj �r| | jjj g7 } | � |� | j j!�r�| j"�r�| j�#� �r2| j$�r2t%d ��| �r=| j&�s=t d ��| j j'}| j j(} | j j)} | j j*} |�rX| j+�sXt d ��| �rc| j,�sct d��| �rn| j-�snt d��| �ry| j.�syt d��| jjj/|| | �0� | d�}|�r�| j1�r�| � |� |�r�| � d| � | � |� g } |D ]\} }!| � | � | � |!� �q�| �r�| �r�t2d��|�p�| jj�3� }| � dd � | � � | j4�r�d}|�r�| � d| � | � |� | j j5�r| �6d| jjj7| j j5j fi | j j5j8��� |�r8g }"|D ]\}\}#}$}|"� |#� | � |$� �qdd � |"� }%|�r3| j9�r3dg| �d�|%�} n| � |%� | �rJ| � | jj�:| j j;| j j<�� |�rV| j1�sV| � |� | j j=�r�|�r�g }&g }'t>| jdd�D ];\}(\})}}|�r�|&� d | jj� d �| jj� |�f � �qi|)�?|)j@d i�}*|*�A| | j�\}+},|&� |+� |'� |,� �qid d � |&�d � | �f tB|'| �fW | j �C|� S d � | �tB| �fW | j �C|� S | j �C|� w ) z� Create the SQL for this query. Return the SQL string and list of parameters. If 'with_limits' is False, any limit/offset information is not included in the query. rJ Nzsupports_select_{}z-{} is not supported on this database backend.� z0 = 1r z%s AS %sr �FROMz:select_for_update cannot be used outside of a transaction.zNLIMIT/OFFSET is not supported with select_for_update on this database backend.z1NOWAIT is not supported on this database backend.z6SKIP LOCKED is not supported on this database backend.z8FOR UPDATE OF is not supported on this database backend.z<FOR NO KEY UPDATE is not supported on this database backend.)�nowait� skip_locked�of�no_key�WHERE %sz1annotate() + distinct(fields) is not implemented.z GROUP BY %sz HAVING %sr z ORDER BY %sr r ra rb r� r� � SELECT %s FROM (%s) subquery� )Dr6 rE r� r� r` r[ r� r. rn r� r� r r �combinator_allrY r+ � get_distinct�get_from_clauserU rp r r8 r rX r� r� � distinct_sqlr: r� rk ri r� �bare_select_suffix�select_for_update�has_select_for_update�get_autocommit�supports_transactionsr �%supports_select_for_update_with_limit�select_for_update_nowait� select_for_update_skip_locked�select_for_update_of�select_for_no_key_update� has_select_for_update_nowait�!has_select_for_update_skip_locked�has_select_for_update_of� has_select_for_no_key_update�for_update_sql�"get_select_for_update_of_arguments�for_update_after_from�NotImplementedError�force_no_orderingr= � explain_info�insert�explain_query_prefix�options�#requires_compound_order_by_subquery�limit_offset_sql�low_mark� high_markr� rj �relabeled_clonery r/ �tuple�reset_refcounts)-r% r rK �refcounts_beforer� r_ r^ rW �for_update_part�with_limit_offsetrn r~ r{ r� �distinct_params�from_�f_paramsrU �w_paramsrX �h_params�distinct_result�out_colsrx �s_sql�s_paramsry r. r/ r0 r1 �grouping�g_sql�g_paramsr� �o_sql�o_params� order_by_sql� sub_selects� sub_paramsrw r: � select_clone� subselect� subparamsr* r* r+ r/ � sp � �� � � � � � �� � ����������� � ��� �� ����� � �� zSQLCompiler.as_sqlNc C s� g }|du r| j �� }du r|S |p| j �� }d|i}|jD ]8}|jjj}||jkr-d}|r=|dur=t|jj|jj�r=q |rD||vrDq | j �||||�} |� | �} |� | � q |S )aT Compute the default columns for selecting every field in the base model. Will sometimes be called to pull in related models (e.g. via select_related), in which case "opts" and "start_alias" will be given to provide a starting point for the traversal. Return a list of strings, quoted appropriately for use in SQL directly, as well as a set of aliases used in the select statement (if 'as_pairs' is True, return a list of (alias, col_name) pairs instead of strings as the first component and None as the second component). N) r6 r� rN �concrete_fieldsr@ �_meta�concrete_model� issubclass�join_parent_model�get_colri ) r% r� � start_alias�optsr� r~ � seen_modelsr� r@ ry r� r* r* r+ r� � s0 � �� z SQLCompiler.get_default_columnsc C s� g }g }| j �� }| j jD ]J}|�t�}| �||d�\}}}} } }} | j �|| | �\}}}|D ]'} || j jv rB|�| j j � |�� q/| � | | |��\} }|�| � |�|� q/q ||fS )z� Return a quoted list of fields to use in DISTINCT ON part of the query. This method can alter the tables in the query, and thus it must be called before get_from_clause(). N) r6 r� r� r� r � _setup_joins� trim_joinsr� ri r. r� r� rp )r% r~ r{ ru r� r� rx �targetsry �joins�path�transform_functionr� r� �pr* r* r+ r6 � s" � �zSQLCompiler.get_distinctr� c s` t �|�\�}|dk���t�}��||� �\}} � } } }�|jr�|jr�t|dd�|d kr��dkr�t�dd�s�|p<t� }t�fdd �| D ��} | |v rPt d ��|� | � g } |jD ]=}t |d �rpt |t �sp�rl|�� n|�� }t |t �r�| �|��� t� ��df� qZ| ��fd d ���||� ||�D �� qZ| S �j�| | | �\} � }� ��fd d�| D �S )z� Return the table alias (the name might be ambiguous, the alias will not be) and column name for ordering by the given 'name' parameter. The 'name' is of the form 'field1__field2__...__fieldN'. r� �attnameN����pk�has_transformsFc 3 s$ � | ] }t � jj| d d�V qdS )� join_colsN)r� r6 rM )rF �jrA r* r+ rH $ s � �z1SQLCompiler.find_ordering_name.<locals>.<genexpr>z!Infinite loop caused by ordering.r� c 3 s* � | ]\}}|� � � t� ��|fV qd S r! )�prefix_referencesr )rF ru r| )r� r* r+ rH 6 s � � �c s" g | ] }t �|� ��d �df�qS )r� F)r r� )ry r� r| r* r+ r� > s ��z2SQLCompiler.find_ordering_name.<locals>.<listcomp>)r r� r rw � is_relationr� r� rd rU r rh re rg r �descr� ri r� rk r� r6 rx )r% r� ru ry r� � already_seenr� �piecesr� ry rz r{ � join_tuple�results�itemrx r* )ry r� r� r% r| r+ r� s` ��� � � � � � ��z SQLCompiler.find_ordering_namec C sD |p| j �� }| j �|||�\}}}}}}|d }|||||||fS )a$ Helper method for get_order_by() and get_distinct(). get_ordering() and get_distinct() must produce same target columns on same input, as the prefixes of get_ordering() and get_distinct() must match. Executing SQL where this is not true is an error. r )r6 rN � setup_joins) r% r� ru ry r� ry rz r{ r| r* r* r+ rw C s �zSQLCompiler._setup_joinsc C s� g }g }t | jj�D ],}| jj| sq z| jj| }W n ty$ Y q w | �|�\}}|�|� |�|� q | jjD ]"}| j� |�\}}|| jjvsS| jj| dkr]|�d| � |� � q;||fS )a� Return a list of strings that are joined together to go after the "FROM" part of the query, as well as a list any extra parameters that need to be included. Subclasses, can override this to create a from-clause via a "select". This should only be called after any SQL construction methods that might change the tables that are needed. This means the select columns, ordering, and distinct must be done first. ra z, %s) rU r6 rM rE �KeyErrorrp ri rk � extra_tables� table_aliasr� ) r% r~ r{ ry � from_clause� clause_sql� clause_paramsr� rx r* r* r+ r7 R s( � �zSQLCompiler.get_from_clausera c ' s� � �fdd�}g } |s|�j jkr| S � s �j �� � �j �� }t� } |du r3t�j jt�}|r3�j j}dd� } � jD ]�} | � | j � |re|� | j i �} | j sd| sU| j |v rdt d| j d�|� �p`df ��nd } t| |||�soq:|� | �pui }| jj| d | j| jr�| jjnd d � d d �}| �|� g }�j �| j g� |�\}}}}}}|d }�j||| jjjd�}|D ]}|�t|�� |�|df� q�||d< ��||| jjj||d | |�}| ||� q:|�rHdd� � jD �}|D ]�\}}|� |�p�i }t||||dd��sq�|�� }| � |� �j �|g� |�}|j d }t |� j��o#|� ju} ||d|jj|j| d �}| �|� g }�j|||j� jd�}|D ]}|�t|�� |�|df� �qD||d< |� |�� i �} ��|||j||d | |�}| ||� q�dd� } dd� } dd� } t |�D ]�} |dk�r� n�| �j j v �r#| � | � �j �| g� |�\}!}}"}}}|"j}|d }t |� j��o�|� ju} ||!dt|�d k�r�t | |!�n| t | | �| d �}| �|� g }|� | |!f��p�i }#�j|#||j� jd�}|D ]}|�t|�� |�|df� �q�||d< |� | i �}$�j||#|j||d |$|d �}| ||� �q�t|��!| �}%|%�rHd d � |%D �}&t d d�|&�d�|� ��pDdf ��| S )!a Fill in the information needed for a select_related query. The current depth is measured as the number of connections away from the root model (for example, cur_depth=1 means we are looking at models with direct connections to the root model). c s0 dd� � j D �} dd� � jD �}t| |�jj�S )Nc s s � | ] }|j r|jV qd S r! )r� r� �rF �fr* r* r+ rH � s � zQSQLCompiler.get_related_selections.<locals>._get_field_choices.<locals>.<genexpr>c s s" � | ] }|j jr|j �� V qd S r! )r� �unique�related_query_namer� r* r* r+ rH � s � � �)�fields�related_objectsr r6 �_filtered_relations)�direct_choices�reverse_choices�ru r% r* r+ �_get_field_choices� s � �z>SQLCompiler.get_related_selections.<locals>._get_field_choicesNc S s || d< d S )Nr� r* )r< r� r* r* r+ �get_related_klass_infos� s zCSQLCompiler.get_related_selections.<locals>.get_related_klass_infoszCNon-relational field given in select_related: '%s'. Choices are: %sr z(none)Fc S � d S r! r* )�x�yr* r* r+ �<lambda>� s z4SQLCompiler.get_related_selections.<locals>.<lambda>)r@ r� �reverse� local_setter� remote_setterr� r )rt ru r� ra c S s& g | ]}|j jr|js|j |jf�qS r* )r� r� � many_to_many� related_model)rF �or* r* r+ r� � s �� �z6SQLCompiler.get_related_selections.<locals>.<listcomp>T)r� )rt ru r� c S s |r | j �||� d S d S r! )� remote_field�set_cached_value)� final_field�obj�from_objr* r* r+ r� s �z8SQLCompiler.get_related_selections.<locals>.local_setterc S r� r! r* )r� r� r* r* r+ �local_setter_noop s z=SQLCompiler.get_related_selections.<locals>.local_setter_noopc S s t || |� d S r! )�setattr)r� r� r� r* r* r+ r� s z9SQLCompiler.get_related_selections.<locals>.remote_setter� )ru � root_alias� cur_depth� requested� restrictedc s s � | ]}d | V qdS )z'%s'Nr* �rF �sr* r* r+ rH V � � z5SQLCompiler.get_related_selections.<locals>.<genexpr>zBInvalid field name(s) given in select_related: %s. Choices are: %s)"r6 � max_depthr� rN rd rg r� �dictr� rh r� rq r� r r� r r� r@ r� r� ri r� r� ro rP r� r� r� rz rq r r� r r� )'r% r: r� ru r� r� r� r� r� r� � fields_foundr� r� �next�related_select_maskr< r� rx rz ry �columnsr� �next_klass_infos�related_fields� related_fieldr@ �related_field_name� join_infor� r� r� r� r� r� � join_opts�field_select_mask�next_requested�fields_not_found�invalid_fieldsr* r� r+ r� w sX ���� �� �� � � � � �� �� �� � � ����z"SQLCompiler.get_related_selectionsc s> �fdd�� �fdd�}� �fdd�}�j sg S g }g }�jjD ]k}�j }|dkr.||�}n@|�t�D ],}g |�dg ��� |��R } | D ]} | d } | d rQ| j} | j|krZ| } nqDd } nq3|d u rj|�|� q ||�}|d ur��j j j r�|��� |�d � q |��� |j�� q |r�td d�|�d�|� �f ��|S )zk Return a quoted list of arguments for the SELECT FOR UPDATE OF part of the query. c 3 sX � | d j j}|j j�� D ] \�}�j �� � �|d� ��fdd�| d D �d�V q d S )Nr@ Fc s< g | ]}�j | d jj�ks�j | d jj� v r|�qS �r )r: r� r@ )rF r� )� parent_list� parent_modelr% r* r+ r� o s �zbSQLCompiler.get_select_for_update_of_arguments.<locals>._get_parent_klass_info.<locals>.<listcomp>r� )r@ r� r� r� )ro rp �parentsr� �get_parent_list)r< rp � parent_linkrA )r� r� r+ �_get_parent_klass_infog s � � ��zNSQLCompiler.get_select_for_update_of_arguments.<locals>._get_parent_klass_infoc sF | d j j}| d D ]}� j| d jj|kr � j| d S q dS )z� Find the first selected column from a model. If it doesn't exist, don't lock a model. select_fields is filled recursively, so it also contains fields from the parent models. r@ r� r N)ro rp r: r� r@ )r< rp r� rA r* r+ �"_get_first_selected_col_from_modelz s ��zZSQLCompiler.get_select_for_update_of_arguments.<locals>._get_first_selected_col_from_modelc 3 s� � t �d�jfg�} | rU| �� \}}|du r g � dV n|d }|d r'|j}||jg � t�� �V | �� fdd��|�D �� | �� fdd�|� dg �D �� | s dS dS ) z<Yield all allowed field paths in breadth-first search order.Nr% r� r� c 3 � � | ]}� |fV qd S r! r* �rF r< �r{ r* r+ rH � � � � �z]SQLCompiler.get_select_for_update_of_arguments.<locals>._get_field_choices.<locals>.<genexpr>c 3 r� r! r* r� r� r* r+ rH � r� r� ) � collections�dequer< �popleftr� r� r r� rk rq )�queue� parent_pathr< r� �r� r% r� r+ r� � s& � � � �zJSQLCompiler.get_select_for_update_of_arguments.<locals>._get_field_choicesr% r� r� r� Nr z�Invalid field name(s) given in select_for_update(of=(...)): %s. Only relational fields followed in the query are allowed. Choices are: %s.r )r< r6 rA r� r rq r� r� ri r. rn �select_for_update_of_columnrp r� ry r r� ) r% r� r� r~ � invalid_namesr� r< r� r � klass_infos�related_klass_infor� r* r� r+ rH a s\ �� �� � ��� z.SQLCompiler.get_select_for_update_of_argumentsc C sP i }t |�D ] \}}|r%| jj�|�}|�| j�}|s |r%|| |f||< q|S r! )rj r. r� �get_db_converters)r% rs � converters�ir� �backend_converters�field_convertersr* r* r+ �get_converters� s �zSQLCompiler.get_convertersc c sf � | j }t|�� �}tt|�D ]!}|D ]\}\}}|| }|D ]} | |||�}q |||< q|V qd S r! )r. r r� �map) r% �rowsr� r. �row�pos�convsr� �value� converterr* r* r+ �apply_converters� s � �z SQLCompiler.apply_convertersc C sh |du r | j t||d�}dd� | jd| j� D �}| �|�}t�|�}|r2| �||�}|r2tt |�}|S )z>Return an iterator over the results from executing this query.N)� chunked_fetch� chunk_sizec S r� r� r* r� r* r* r+ r� � r� z,SQLCompiler.results_iter.<locals>.<listcomp>r ) � execute_sqlr r: rQ r� r � from_iterabler� r� rU )r% r� �tuple_expectedr� r� r� r� r� r* r* r+ � results_iter� s � zSQLCompiler.results_iterc C s t | �t��S )z� Backends (e.g. NoSQL) can override this in order to use optimized versions of "query has any results." )r[ r� r rA r* r* r+ � has_results� s zSQLCompiler.has_resultsc C s. |pt }z | �� \}}|st�W n ty$ |tkr!tg � Y S Y dS w |r-| j�� }n| j�� }z|�||� W n t yF |� � � w |t krM|S |t krpz|� � }|rd|d| j� W |� � S |W |� � S |� � w |t krz|� � dS t|| jjj| jr�| jnd|�}|r�| jjjs�t|�S |S )a� Run the query against the database and return the result(s). The return value is a single data item if result_type is SINGLE, or an iterator over the results if the result_type is MULTI. result_type is either MULTI (use fetchmany() to retrieve all rows), SINGLE (only retrieve a single row), or None. In this last case, the cursor is returned if any query is executed, since it's used by subclasses such as InsertQuery). It's possible, however, that no query is needed, as the filters describe an empty set. In that case, None is returned, to avoid any unnecessary database interaction. Nr )r r/ r r �iterr. �chunked_cursor�cursor�execute� Exception�closer r �fetchonerQ � cursor_iterrn �empty_fetchmany_valuer\ �can_use_chunked_readsr ) r% � result_typer� r� rz r{ r� �valr~ r* r* r+ r� � sT � � � ��zSQLCompiler.execute_sqlc C s� |j }| jjj}t| jj�D ]&\}}| �|�\}} d||�||| �f } | jj� t d|| f | �t � q| � � \} } d| | fS )Nr� �%s = %sz EXISTS (%s)) r� r. r� r� rj r6 r: rp rU rh r r r/ ) r% ry r� r- �qn�qn2rw � select_col�lhs_sql� lhs_params�rhsrz r{ r* r* r+ �as_subquery_condition> s z!SQLCompiler.as_subquery_conditionc # sp � t | �� �}| jjj}|r|�� dkrtjnt� |d D ]}t |t�s2d� � fdd�|D ��V q |V q d S )N�jsonr r4 c 3 s � | ]}� |�V qd S r! r* )rF �c��output_formatterr* r+ rH R r� z,SQLCompiler.explain_query.<locals>.<genexpr>) r r� r6 rL r� �lowerr �dumpsr, rg r� )r% r~ �format_r� r* r r+ � explain_queryJ s � �zSQLCompiler.explain_query)T)F)TF)NNN)Nr� N)NNra NN)'r0 r1 r2 r �re� MULTILINE�DOTALLr� r$ rB rR r` r] rm rO r� rT rZ r� rp r r+ r/ r� r6 r� rw r7 r� rH r� r� r r� r� r r� r r r* r* r* r+ r4 ' sb � g W = P ` c �2 �A) � kj � �B r4 c @ sF e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd d � Z dd d�Z dS )�SQLInsertCompilerNr* c C sv |du r |g }}n%t |d�r| �|�\}}nt |d�r)|�|| | j�|g}}nd|g}}| jj�||�}||fS )at Take a field and a value intended to be saved on that field, and return placeholder SQL and accompanying params. Check for raw values, expressions, and fields with get_placeholder() defined in that order. When field is None, consider the value raw and use it as the placeholder, with no corresponding parameters returned. Nr/ �get_placeholder�%s)re rp r r. r� �modify_insert_params)r% r� r� rz r{ r* r* r+ � field_as_sql[ s z SQLInsertCompiler.field_as_sqlc C sr t |d�r1|j| jddd�}|jrtd||f ��|jr%td|j|f ��|jr1td|j|f ��|j || j d�S ) z� Prepare a value to be used in a query by resolving it if it is an expression and otherwise calling the field's get_db_prep_save(). r� FT�r� �for_savezbFailed to insert expression "%s" on %s. F() expressions can only be used to update, not to insert.�:Aggregate functions are not allowed in this query (%s=%r).�9Window expressions are not allowed in this query (%s=%r).�r. ) re r� r6 �contains_column_references� ValueError�contains_aggregater r� �contains_over_clause�get_db_prep_saver. )r% r� r� r* r* r+ � prepare_value{ s. �������z SQLInsertCompiler.prepare_valuec C s" | j jr t||j�S |j|dd�S )z� Get the given field's value off the given obj. pre_save() is used for things like auto_now on DateTimeField. Skip it if this is a raw query. T)rh )r6 �rawr� r~ �pre_save)r% r� r� r* r* r+ � pre_save_val� s z SQLInsertCompiler.pre_save_valc sP |sg g fS � �fdd�|D �}dd� |D �}t |� \}}dd� |D �}||fS )a+ Take a sequence of N fields and a sequence of M rows of values, and generate placeholder SQL and parameters for each field and value. Return a pair containing: * a sequence of M rows of N SQL placeholder strings, and * a sequence of M rows of corresponding parameter values. Each placeholder string may contain any number of '%s' interpolation strings, and each parameter row will contain exactly as many params as the total number of '%s's in the corresponding placeholder row. c 3 s( � | ]}�fd d�t � |�D �V qdS )c 3 s � | ] \}}� � ||�V qd S r! )r )rF r� �vrA r* r+ rH � rI z>SQLInsertCompiler.assemble_as_sql.<locals>.<genexpr>.<genexpr>N�r� �rF r� �r� r% r* r+ rH � s � � �z4SQLInsertCompiler.assemble_as_sql.<locals>.<genexpr>c s s � | ]}t |� V qd S r! r& r' r* r* r+ rH � r� c S s g | ] }d d� |D ��qS )c S s g | ] }|D ]}|�qqS r* r* �rF �psr} r* r* r+ r� � r z@SQLInsertCompiler.assemble_as_sql.<locals>.<listcomp>.<listcomp>r* r' r* r* r+ r� � r z5SQLInsertCompiler.assemble_as_sql.<locals>.<listcomp>r& )r% r� � value_rows�rows_of_fields_as_sql�sql_and_param_pair_rows�placeholder_rows� param_rowsr* r( r+ �assemble_as_sql� s � z!SQLInsertCompiler.assemble_as_sqlc s �j jj��j�� }�j jj�jjd�}d|�|j�f g��jjp%|j g� �� dd� �fdd�� D �� � �jjrH� �fdd��jj D �}n�fd d��jj D �}d g� �j o^�j jj}��� |�\}}�j j�� �jjd d� �jjD �d d� �jjD ��}�j rوj jjrوj jjr��� �j j�� |�� |}n�� d d� |d � � |d g}|r��� |� �j j��j �\} �_| r̈� | � |�jg7 }d� ��tt�|��fgS |r��� �j j�� |�� |r�� |� d� ��tdd� |D ��fgS |�r�� |� �fdd�t ||�D �S )N)� on_conflictz%s %sz(%s)r c 3 s � | ]}� |j �V qd S r! �r� r� )r r* r+ rH � s � z+SQLInsertCompiler.as_sql.<locals>.<genexpr>c s g | ] � � �fd d��D ��qS )c s g | ] }�� |��|� ���qS r* )r! r$ �rF r� )r� r% r* r+ r� � r� z7SQLInsertCompiler.as_sql.<locals>.<listcomp>.<listcomp>r* )rF r( )r� r+ r� � s ���z,SQLInsertCompiler.as_sql.<locals>.<listcomp>c s g | ] }� j j�� g�qS r* )r. r� �pk_default_value)rF rx rA r* r+ r� � s �c s � � | ]}|j V qd S r! r2 r� r* r* r+ rH � � � c s r5 r! r2 r� r* r* r+ rH � r6 � VALUES (%s)r r4 c s s � | ] }|D ]}|V qqd S r! r* r) r* r* r+ rH s � c s. g | ]\}}d � � dd� |� g �|f�qS )r4 r7 r )r� )rF r} �vals)r~ r* r+ r� s ��) r. r� r� r6 r� �insert_statementr1 �db_tabler� r� ri r� �objs�returning_fieldsrn �has_bulk_insertr0 �on_conflict_suffix_sql� update_fields� unique_fields� can_return_columns_from_insert� can_return_rows_from_bulk_insert�bulk_insert_sql�return_insert_columns�returning_paramsrU r r� r� ) r% ru r9 r+ �can_bulkr. r/ r> r{ �r_sqlr* )r� r r~ r% r+ r/ � sn �" � ����� � � �zSQLInsertCompiler.as_sqlc sB |rt | jj�dkr| jjjsJ �| j�� � || _| j�� �`}| � � D ] \}}|� ||� q#| js:g W d � S | jjjrOt | jj�dkrO| jj � |�}n(| jjj rit | jj�dks^J �| jj �|| j�g}n| jj �|� j� jj�fg}W d � n1 s�w Y � fdd�| jD �}| �|�}|r�t| �||��}|S )Nra c s g | ]}|� � j��qS r* )rs r: r3 �ru r* r+ r� 8 � z1SQLInsertCompiler.execute_sql.<locals>.<listcomp>)rP r6 r; r. rn rB r� r< r� r/ r� r� �fetch_returned_insert_rowsrA � fetch_returned_insert_columnsrE �last_insert_idr: r� r� r� r r� )r% r< r� rz r{ r� r� r� r* rH r+ r� sL �� �� �� ���� � z SQLInsertCompiler.execute_sqlr! ) r0 r1 r2 r< rE r r! r$ r0 r/ r� r* r* r* r+ r W s #Pr c @ s@ e Zd Zedd� �Zedd� �Zedd� �Zdd� Zd d � Z d S ) �SQLDeleteCompilerc s( � j �� t� fdd�� j jD ��dkS )Nc 3 s � | ] }� j j| d kV qdS rC rD r� rA r* r+ rH D rI z1SQLDeleteCompiler.single_alias.<locals>.<genexpr>ra )r6 rN �sumrM rA r* rA r+ � single_alias@ s z SQLDeleteCompiler.single_aliasc s> t |t�r |j� kS t|d�sdS t� �fdd�|�� D ��S )Nr Fc 3 s � | ] }�� |� �V qd S r! )�_expr_refs_base_model)rF � source_expr�� base_model�clsr* r+ rH L s � � �z:SQLDeleteCompiler._expr_refs_base_model.<locals>.<genexpr>)rg r r@ re �anyr )rT ru rS r* rR r+ rP F s �z'SQLDeleteCompiler._expr_refs_base_modelc s* t � fdd�t� jj�� � jjj�D ��S )Nc 3 s � | ] }� � |� jj�V qd S r! )rP r6 r@ r� rA r* r+ rH S s � � �zESQLDeleteCompiler.contains_self_reference_subquery.<locals>.<genexpr>)rU r r6 r� r rU �childrenrA r* rA r+ � contains_self_reference_subqueryQ s ��z2SQLDeleteCompiler.contains_self_reference_subqueryc C sV d| � |j� }z | �|j�\}}W n ty |df Y S w |� d|� �t|�fS )NzDELETE FROM %sr* z WHERE )r� � base_tablerp rU r rU )r% r6 �deleterU r{ r* r* r+ �_as_sqlZ s �zSQLDeleteCompiler._as_sqlc C s� | j r | js | �| j�S | j�� }t|_|�� | jjj j }|� | j� � �g|_ t| jj�}| jjjsE|j| jd��� \}}td| |�}|�d|� | �|�S )�f Create the SQL for this query. Return the SQL string and list of parameters. r zSELECT * FROM (%s) subquery�pk__in)rO rW rZ r6 r� r r) �clear_select_clauser@ ro r� rs rN r: r. rn �update_can_self_selectr� r/ r � add_filter)r% �innerqr� �outerqrz r{ r* r* r+ r/ b s zSQLDeleteCompiler.as_sqlN) r0 r1 r2 r rO � classmethodrP rW rZ r/ r* r* r* r+ rM ? s rM c s0 e Zd Zdd� Z� fdd�Z� fdd�Z� ZS )�SQLUpdateCompilerc C s� | � � | jjs dS | j}g g }}| jjD ]�\}}}t|d�rB|j| jddd�}|jr5td|j|f ��|j rAtd|j|f ��nt|d�r[|j rP|� |�}n t d |||j jf ��|j|| jd �}t|d �rq|�|| | j�}nd }|j}t|d �r�| �|�\} } |�d||�|| f � |�| � q|dur�|�d||�|f � |�|� q|�d||� � q| jj} d|| � d�|�g} z | �| jj�\} } W n ty� g } Y nw | �d| � d�| �t|| �fS )r[ )r, r* r� FTr r r �prepare_database_savezSTried to update field %s with a model instance, %r. Use a value compatible with %s.r r r r/ r� Nz %s = NULLz UPDATE %s SETr r2 r4 )r` r6 r r� re r� r r r� r r� rd � TypeErrorr) r0 r r. r r� rp ri rk rX r� rU r rU )r% r r � update_paramsr� r@ r� � placeholderr� rz r{ r� r~ rU r* r* r+ r/ y sn ������ �� � �zSQLUpdateCompiler.as_sqlc sz t � �|�}z|r |jnd}|du }W |r|�� n|r!|�� w w | j�� D ]}|�| j��|�}|r:|r:|}d}q'|S )a Execute the specified update. Return the number of rows affected by the primary update query. The "primary update query" is the first non-empty query that is executed. Row counts for any subsequent, related queries are not available. r NF)r# r� �rowcountr� r6 �get_related_updatesr� r7 )r% r� r� r� �is_emptyr6 �aux_rowsr( r* r+ r� � s" �� ��z SQLUpdateCompiler.execute_sqlc s� | j j�� }| j �� | j �� }| j js|dkrdS | j jtd�}d|_|j dd� i |_ g |_ |� � }|j jg}g }| j jD ]'}tdd� |�|�D ��rU|�|d f� q?|�|t|�f� |�|jj j� q?|�|� t� �� |dkoz| jjj }| j �� | j js�|r�g } t� t �} |� | j �� t!�D ]!} | �"d d� | D �� |D ]\} � | | �"� fd d�| D �� q�q�| j �#d | � | | j _$n| j �#d |� | j �%|� dS ) aO If the update depends on results from other tables, munge the "where" conditions to match the format required for (portable) SQL updates. If multiple updates are required, pull out the id values to update at this point so that they don't change as a result of the progressive updates. ra N)�klassFT)�forcec s s � | ]}|j jV qd S r! )� join_fieldr� )rF r{ r* r* r+ rH � s � �z2SQLUpdateCompiler.pre_sql_setup.<locals>.<genexpr>r c s s � | ]}|d V qdS rC r* �rF r� r* r* r+ rH r� c 3 s � | ]}|� V qd S r! r* ro �rw r* r+ rH r� r\ )&r6 rE r� rN �count_active_tables�related_updatesr r r� �clear_orderingr� r: r� r� r� rL �get_path_to_parentri rP ro � add_fieldsr# r` r. rn r^ � clear_wherer� � defaultdictr r� r7 r� r rk r_ � related_idsrV ) r% rW �countr6 r� r� �related_ids_index�related�must_pre_select�identsrx r� �parentr( rp r+ r` � sJ � � � z SQLUpdateCompiler.pre_sql_setup)r0 r1 r2 r/ r� r` r3 r* r* r( r+ rc x s @rc c @ s e Zd Zdd� ZdS )�SQLAggregateCompilerc C s� g g }}| j j�� D ] }| �|�\}}|�| ||�\}}|�|� |�|� q t| j j�| _d� |�}t |�}| j j j | j | jd�jdd�\}}d||f }||7 }||fS )r[ r )r8 TrJ r3 )r6 r� r rp rr ri rk rP rQ r� rU r r� r7 r8 r/ )r% rz r{ r� �ann_sql� ann_params�inner_query_sql�inner_query_paramsr* r* r+ r/ s$ � � zSQLAggregateCompiler.as_sqlN)r0 r1 r2 r/ r* r* r* r+ r s r c # sV � z$t ��fdd�|�D ]}� du r|n� fdd�|D �V q W ��� dS ��� w )z[ Yield blocks of rows from a cursor and ensure the cursor is closed when done. c s � � ��S r! )� fetchmanyr* )r� �itersizer* r+ r� - s z cursor_iter.<locals>.<lambda>Nc s g | ]}|d � � �qS r! r* ro )rQ r* r+ r� . rI z cursor_iter.<locals>.<listcomp>)r� r� )r� �sentinelrQ r� r� r* )rQ r� r� r+ r� ' s �"�r� )8r� r r � functoolsr � itertoolsr �django.core.exceptionsr r r � django.dbr r �django.db.models.constantsr � django.db.models.expressionsr r r r r �django.db.models.functionsr r �django.db.models.lookupsr � django.db.models.query_utilsr � django.db.models.sql.constantsr r r r r r �django.db.models.sql.queryr r �django.db.models.sql.wherer �django.db.transactionr �django.utils.functionalr �django.utils.hashabler �django.utils.regex_helperr r r4 r rM rc r r� r* r* r* r+ �<module> sP < i9 __pycache__/datastructures.cpython-310.pyc 0000644 00000014250 15030124302 0014522 0 ustar 00 o �h� � @ s^ d Z ddlmZ ddlmZmZ G dd� de�ZG dd� d�ZG dd � d �Z G d d � d �Z d S ) z] Useful auxiliary data structures for query construction. Not useful outside the SQL domain. � )� FullResultSet)�INNER�LOUTERc @ s e Zd ZdZdd� ZdS )� MultiJoinz� Used by join construction code to indicate the point at which a multi-valued join was attempted (if the caller wants to treat that exceptionally). c C � || _ || _d S �N)�level�names_with_path)�self� names_pos�path_with_names� r �Y/usr/local/CyberPanel/lib/python3.10/site-packages/django/db/models/sql/datastructures.py�__init__ s zMultiJoin.__init__N)�__name__� __module__� __qualname__�__doc__r r r r r r s r c @ s e Zd ZdS )�EmptyN)r r r r r r r r s r c @ s` e Zd ZdZ ddd�Zdd� Zdd� Zed d � �Zd d � Z d d� Z dd� Z dd� Z dd� Z dS )�Joina� Used by sql.Query and sql.SQLCompiler to generate JOIN clauses into the FROM entry. For example, the SQL generated could be LEFT OUTER JOIN "sometable" T1 ON ("othertable"."sometable_id" = "sometable"."id") This class is primarily used in Query.alias_map. All entries in alias_map must be Join compatible by providing the following attributes and methods: - table_name (string) - table_alias (possible alias for the table, can be None) - join_type (can be None for those entries that aren't joined from anything) - parent_alias (which table is this join's parent, can be None similarly to join_type) - as_sql() - relabeled_clone() Nc C s8 || _ || _|| _|| _|�� | _|| _|| _|| _d S r ) � table_name� parent_alias� table_alias� join_type�get_joining_columns� join_cols� join_field�nullable�filtered_relation)r r r r r r r r r r r r - s z Join.__init__c C s8 g }g }|j }|jj}| jD ]\}}|�d|| j�||�|| j�||�f � q| j�| j| j�} | rF|� | �\} } |�d| � |� | � | j riz |� | j �\} } W n t y\ Y n w |�d| � |� | � |szt | jd| j�} td| j ��d�|�} | j| jkr�dnd| j }d| j|| j�|| f }||fS ) z� Generate the full LEFT OUTER JOIN sometable ON sometable.somecol = othertable.othercol, params clause for this join. z %s.%s = %s.%sz(%s)�fieldzaJoin generated an empty ON clause. %s did not yield either joining columns or extra restrictions.z AND � � %sz%s %s%s ON (%s))�quote_name_unless_alias�ops� quote_namer �appendr r r �get_extra_restriction�compile�extendr r �getattr� ValueError� __class__�joinr r )r �compiler� connection�join_conditions�params�qn�qn2�lhs_col�rhs_col� extra_cond� extra_sql� extra_params�declared_field� on_clause_sql� alias_str�sqlr r r �as_sqlG s\ ��� � � �� ��z Join.as_sqlc sr � � | j| j�}� � | j| j�}| jd ur'| j�� }� fdd�| jjD �|_nd }| j| j||| j| j | j |d�S )Nc s g | ]}� � ||��qS r )�get)�.0�p�� change_mapr r � <listcomp>� s �z(Join.relabeled_clone.<locals>.<listcomp>)r ) r= r r r �clone�pathr+ r r r r )r rA �new_parent_alias�new_table_aliasr r r@ r �relabeled_clone� s" ��zJoin.relabeled_clonec C s | j | j| j| j| jfS r )r+ r r r r �r r r r �identity� s �z Join.identityc C � t |t�stS | j|jkS r )� isinstancer �NotImplementedrI �r �otherr r r �__eq__� � z Join.__eq__c C � t | j�S r ��hashrI rH r r r �__hash__� � z Join.__hash__c C s | j d d� |j d d� kS )N����rI rM r r r �equals� s z Join.equalsc C � | � i �}t|_|S r )rG r r �r �newr r r �demote� � z Join.demotec C rY r )rG r r rZ r r r �promote� r] z Join.promoter )r r r r r r< rG �propertyrI rO rT rX r\ r^ r r r r r s �; r c @ sX e Zd ZdZdZdZdZdd� Zdd� Zdd� Z e d d � �Z d d � Z d d� Z dd� ZdS )� BaseTablez� The BaseTable class is used for base table references in FROM clause. For example, the SQL "foo" in SELECT * FROM "foo" WHERE somecond could be generated by this class. Nc C r r )r r )r r �aliasr r r r � s zBaseTable.__init__c C s2 | j | jkrdnd| j }|�| j�}|| g fS )Nr r! )r r r" )r r- r. r: �base_sqlr r r r< � s � zBaseTable.as_sqlc C s | � | j|�| j| j��S r )r+ r r= r )r rA r r r rG � s �zBaseTable.relabeled_clonec C s | j | j| jfS r )r+ r r rH r r r rI � s zBaseTable.identityc C rJ r )rK r` rL rI rM r r r rO � rP zBaseTable.__eq__c C rQ r rR rH r r r rT � rU zBaseTable.__hash__c C s | j |j kS r rW rM r r r rX � s zBaseTable.equals)r r r r r r r r r< rG r_ rI rO rT rX r r r r r` � s r` N) r �django.core.exceptionsr � django.db.models.sql.constantsr r � Exceptionr r r r` r r r r �<module> s __pycache__/query.cpython-310.pyc 0000644 00000206563 15030124302 0012624 0 ustar 00 o �h�� � @ 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)�concrete�name�attname��.0�f� r8 �P/usr/local/CyberPanel/lib/python3.10/site-packages/django/db/models/sql/query.py� <genexpr>> s � �z,get_field_names_from_opts.<locals>.<genexpr>)�setr � from_iterable� get_fields)�optsr8 r8 r9 �get_field_names_from_opts: s ��r? c c s2 � | j D ]}t|t�rt|�E d H q|V qd S r1 )�children� isinstancer. �get_children_from_q)�q�childr8 r8 r9 rB D s � �rB �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.r8 c C s4 || _ || _|| _d | _d\| _| _i | _i | _d S )N�r N)�params�sql�using�cursor�low_mark� high_mark� extra_select�annotation_select)�selfrM rN rL r8 r8 r9 �__init__U s zRawQuery.__init__c C s | � |�S r1 ��clone�rT rN r8 r8 r9 r a s zRawQuery.chainc C s t | j|| jd�S )N)rL )r0 rM rL rX r8 r8 r9 rW d � zRawQuery.clonec s6 | j d u r | �� t| j jj� � fdd�| j jD �S )Nc s g | ]}� |d ��qS �r r8 )r6 � column_meta�� converterr8 r9 � <listcomp>k s z(RawQuery.get_columns.<locals>.<listcomp>)rO �_execute_queryr rN � introspection�identifier_converter� description�rT r8 r\ r9 � get_columnsg s zRawQuery.get_columnsc C s6 | � � t| j jjst| j�}t|�S | j}t|�S r1 )r_ r rN �features�can_use_chunked_reads�listrO �iter)rT �resultr8 r8 r9 �__iter__m s �zRawQuery.__iter__c C s d| j j| f S )Nz<%s: %s>)� __class__�__name__rc r8 r8 r9 �__repr__y s zRawQuery.__repr__c C s" | j d u rd S t| j t�rtS tS r1 )rL rA r �dict�tuplerc r8 r8 r9 � params_type| s zRawQuery.params_typec C s" | j d u r| jS | j| � | j� S r1 )rp rM rL rc r8 r8 r9 �__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 r1 r8 )r6 �val��adapterr8 r9 r: � � � z*RawQuery._execute_query.<locals>.<genexpr>c s i | ] \}}|� |��qS r8 r8 )r6 �keyrr rs r8 r9 � <dictcomp>� � z+RawQuery._execute_query.<locals>.<dictcomp>zUnexpected params type: %s) r rN rp �ops�adapt_unknown_valuero rL rn �items� RuntimeErrorrO �executerM )rT � connectionrp rL r8 rs r9 r_ � s zRawQuery._execute_queryN)r8 )rl � __module__� __qualname__�__doc__rU r rW rd rj rm �propertyrp rq r_ r8 r8 r8 r9 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� Zb d�dsdt�Zc d�dudv�Zddwdx� Zed�dydz�Zf d�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.�TN� SQLCompilerTFr8 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)rT r� r� r8 r8 r9 rU � s zQuery.__init__c C sP t | j�dkr| jd }t|dd �p|jS t | j�dkr&tt| j�� ��jS d S )N� r �target) �len�select�getattr�fieldrS �nextrh �values� output_field)rT r� r8 r8 r9 r� s �zQuery.output_fieldc C s | j D ]}| S d S r1 )r� �rT �aliasr8 r8 r9 � 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)rT rM rL r8 r8 r9 rq 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_sqlrc r8 r8 r9 r� s zQuery.sql_with_paramsc C s | � � }||t| �< |S )z4Limit the amount of work when a Query is deepcopied.)rW �id)rT �memori r8 r8 r9 � __deepcopy__" s zQuery.__deepcopy__c C s< |d u r |d u r t d��|rt| }|j�| j�| |||�S )Nz Need either using or connection)� ValueErrorr ry �compiler)rT rN r~ � elide_emptyr8 r8 r9 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� �_metarc r8 r8 r9 �get_meta1 s �zQuery.get_metac C s* t � }| j|_| j�� |_| j�� |_| j�� |_| j�� |_| j�� |_| j� � |_| j �� |_ | j dur<| j �� |_ | j rJt dd� | j D ��|_ d|_| j�� |_| jdur^| j�� |_| jduri| j�� |_| jdurut�|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 r8 rV )r6 �queryr8 r8 r9 r^ N � z Query.clone.<locals>.<listcomp>F� subq_aliasesr� )r$ rk �__dict__�copyr� r� r� r� r� rW r� �annotation_select_mask�combined_queriesro �_annotation_select_cacher� �extra_select_mask�_extra_select_cache�select_related�deepcopyr� r� r� �pop)rT �objr8 r8 r9 rW : s: � 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)rW rk �filter_is_stickyr; r� �hasattrr� )rT �klassr� r8 r8 r9 r g s z Query.chainc C s | � � }|�|� |S r1 )rW �change_aliases)rT � change_maprW r8 r8 r9 �relabeled_clonev s zQuery.relabeled_clonec C s | j sd }|�||�S r1 �r� �get_col)rT r� r� r� r8 r8 r9 �_get_col{ s zQuery._get_colc s |si S d}d}i � �j }|�� D ]P\}}��|� |j�dddd�}|js,td| ����|g� |t�fdd�|�� D ��O }|t�fdd�|�� D ��O }|� � �}|�j |< |� t ||�< q�fd d �|D �} �� |� �j �� \} } } td d� �j �� D ��p�| } t�jt�s��js�| s�|s�|s�| s��js��j�r�d d lm} ��� }d|_|�j|�}d|_d|_ |� �j � |j dd� |j�s|j r�| r؈jj j!�"|�#� �f|_d|_ | �st$� }t�jt�r�jD ]}||�� O }q�| �� D ]}||�� O }q��j �� D ]\}}|�%� �r|�&|� �q|� |� i }| �� D ]F\}}i � �j'|gdd�D ].}|�(|� }�sWt)|�d }d|� �}t ||�}|||< ||j |< |�|g� |� |< �q.|� � �|j |< �q |j*dk�r�|j �s�|j �s��jj j!�"|�#� �f|_*n.�}d�_*d�_ i �_+�j �r�dd � �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 �" � | ] }t � j| d d�V qdS )�contains_subqueryFN�r� r� �r6 �refrc r8 r9 r: � � � � �z(Query.get_aggregation.<locals>.<genexpr>c 3 r� )�contains_over_clauseTNr� r� rc r8 r9 r: � r� c s i | ] }|� j �|��qS r8 )r� r� )r6 r� rc r8 r9 rw � rx z)Query.get_aggregation.<locals>.<dictcomp>c s s � | ] }t |d d�V qdS )�contains_aggregateTN)r� )r6 � annotationr8 r8 r9 r: � � � � �r )�AggregateQuery��force)� resolve_refsr� �__colr8 c S s i | ] \}}t ||�|�qS r8 )r )r6 r� r� r8 r8 r9 rw � ��c � i | ] \}}||� � ��qS r8 )�replace_expressions)r6 r� � aggregate)� replacementsr8 r9 rw r� c S � g | ]}|j �qS r8 )�empty_result_set_value)r6 � expressionr8 r8 r9 r^ s ��z)Query.get_aggregation.<locals>.<listcomp>c s s � | ]}|t u V qd S r1 )�NotImplemented)r6 ri r8 r8 r9 r: $ ru )r� )5r� r{ � check_alias�resolve_expressionr� � TypeError�append_annotation_mask�any�get_refsr� r� r �set_annotation_maskr� �split_having_qualifyr� rA �group_byro � is_sliced�distinct� combinator� django.db.models.sql.subqueriesr� rW �subqueryr� �select_for_updater� rS �clear_ordering� default_colsr� �pkr� �get_initial_aliasr; �get_group_by_cols�add� _gen_cols�getr� r� r� � clear_limitsr� � execute_sqlr" �get_convertersr� �apply_convertersrn �zip) rT rN �aggregate_exprs� refs_subquery� refs_windowr� r� �aggregate_exprr� � aggregates�_�having�qualify�has_existing_aggregationr� � inner_query� outer_query�annotation_mask�expr�annotation_aliasr� �col_refs�col�col_ref�index� col_alias�empty_set_resultr� r� ri � convertersr8 )r� rT r9 �get_aggregation� s� � � � �� �������� � � � ����� � � zQuery.get_aggregationc C s | � � }|�|dtd�i�d S )zO Perform a COUNT() query using the current filter constraints. �__count�*)rW r r )rT rN r� r8 r8 r9 � get_count3 s zQuery.get_countc C s | j S r1 )r� rc r8 r8 r9 � has_filters: s zQuery.has_filtersc C s� | � � }|jr |js'|jdu r#|�dd� | jjjD �d� |jdd� |� � |j r:|j dkr:t dd� |j D ��|_ |j dd� |rH|jd d � |�td �d � |S ) NTc s � � | ]}|j V qd S r1 �r4 r5 r8 r8 r9 r: B � � z Query.exists.<locals>.<genexpr>F�� allow_aliases�unionc s s � | ] }|j d d�V qdS )F)�limitN)�exists�r6 �combined_queryr8 r8 r9 r: I r� r� r� )�high�a)rW r� r� r� � add_fieldsr� r� �concrete_fields� set_group_by�clear_select_clauser� r� ro r� � set_limits�add_annotationr )rT r rC r8 r8 r9 r = s" � � z Query.existsc C s | � |�}|j|d�}|�� S )N�rN )r r� � has_results)rT rN rC r� r8 r8 r9 r' S s zQuery.has_resultsc K sZ | � � }|D ]}t�|�rd|v rtd|�d���qt||�|_|j|d�}d�|�� �S )Nz--zInvalid option name: �.r& � ) rW �EXPLAIN_OPTIONS_PATTERN� fullmatchr� r� � explain_infor� �join� explain_query)rT rN r� r� rC � option_namer� r8 r8 r9 �explainX s �� z Query.explainc s< �j |j kr td���jrtd���j|jkrtd���j|jkr%td����� }|j�|hd� i � |tk}|r<t� nt�j �}t |dd�}|� �fdd ��j D �� t� }t |j �d d � }|D ]4} |j | } | � � �} �j| |d �} | jtkr|�| � |�| � | | kr�| � | < |j| s���| � qb|� |� |��� � j|jO _|j�� } | �� � �j�| |� |jrˈ�� fd d�|jD �� nd�_|t kr܈j r�|j r�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.)�exclude� Fc 3 s$ � | ] }� j | jtkr|V qd S r1 �r� � join_typer )r6 �jrc r8 r9 r: � s � �z Query.combine.<locals>.<genexpr>r� N)r� c � g | ]}|� � ��qS r8 �r� �r6 r �r� r8 r9 r^ � � z!Query.combine.<locals>.<listcomp>r8 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_votesrg r� r- r4 r r� �discardr� � unref_alias�update_join_typesr� r� rW �relabel_aliasesr� � set_selectr( r� r� �updater� �set_extra_mask� extra_tables�order_by�extra_order_by)rT �rhs� connector� initial_alias� conjunctionr� � joinpromoter� rhs_votes� rhs_tablesr� r- � new_alias�wr� r8 )r� rT r9 �combined sp � � � z Query.combinec C s* |d u ri }i ||j < |jD ]@}|�|jd �}|�|jd �}|d u r-|d u r-|�|i � q|rN|js:ttt |����|�|i �}|j j j j }| �|j ||� q|�� D ]?\} }| j�| � } rq|�| j�} |�| | fi �}| j}n|�| �} t| d�s|qS| j}|�|i �}|j j j }| �|j ||� qS|S )Nr� )r� r! r� r3 r4 � setdefault� is_relationr r� rh � remote_fieldr� r� �concrete_model�_get_defer_select_maskr{ r� r� � get_field� relation_namer� r� ) rT r> �mask� select_maskr� � field_mask�field_att_mask�field_select_mask� related_model� field_name�filtered_relation�relation� reverse_relr8 r8 r9 rW � s@ �� �z Query._get_defer_select_maskc C s� |d u ri }i ||j < |�� D ]5\}}|�|�}||jv r!|j}n|}|�|i �}|rD|js6ttt |����|j j j j } | �| j ||� q|S r1 )r� r{ rX �related_objectsr� rS rT r r� rh rU r� r� rV �_get_only_select_mask) rT r> rZ r[ r` r\ r� � field_keyr^ r_ r8 r8 r9 re s$ ��zQuery._get_only_select_maskc C sd | j \}}|s i S i }|D ]}|}|�t�D ]}|�|i �}qq | �� }|r,| �||�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 rS r� rW re )rT � field_names�deferrZ r` � part_mask�partr> r8 r8 r9 �get_select_mask s � zQuery.get_select_maskc 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� r� r� � alias_prefixr� r� �appendr� )rT � table_name�createra � alias_listr� r8 r8 r9 � table_alias2 s � zQuery.table_aliasc C s | j | d7 < dS )z-Increases the reference count for this alias.r� N�r� r� r8 r8 r9 � ref_aliasM � zQuery.ref_aliasr� c C s | j | |8 < dS )z-Decreases the reference count for this alias.Nru )rT r� �amountr8 r8 r9 r@ Q rw 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 r1 )r� � parent_alias)r6 r- �r� �aliasesrT r8 r9 r: s s � ��z&Query.promote_joins.<locals>.<genexpr>) rg r� r� r4 ry r �nullable�promote�extend)rT r{ ry � parent_louter�already_louterr8 rz r9 � promote_joinsU 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) rg r� r� r4 r �demotery r rp )rT r{ r� ry r8 r8 r9 � 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� r{ r� r@ )rT � to_countsr� � cur_refcount� unref_amountr8 r8 r9 �reset_refcounts� 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 r6 r8 r7 r8 r9 r8 r9 r^ � r: z(Query.change_aliases.<locals>.<listcomp>c r6 r8 r7 r8 r9 r8 r9 r^ � r: c r� r8 r7 )r6 rv r r9 r8 r9 rw � r� z(Query.change_aliases.<locals>.<dictcomp>c s& i | ]\}}� � ||�|p|� v �qS r8 �r� )r6 r� �aliasedr9 r8 r9 rw � s ��N)r; � isdisjointr� r� rB rA r� ro r� r� r{ r� r� r� r� rq � enumerater� )rT r� � old_aliasrP � alias_data� table_aliases�posr� r8 r9 r9 r� � s8 �� �� �zQuery.change_aliasesc s� �fdd�}�j |j krdS t�� d }t|� �D ]\}}|�jvr'|�_ n ||kr/td��q�j��j g��_|j��j�|_� du rGi � ��� �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 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�ordro r r r r- )�alphabet�prefix�n�seq�src r8 r9 � 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 )rn )ro )r6 r� r� �r1 rT r8 r9 rw � s �z%Query.bump_prefix.<locals>.<dictcomp>) ro �sys�getrecursionlimitr� r� �RecursionErrorr r� r� )rT � other_queryr1 r� �local_recursion_limitr� r� r8 r� r9 r< � s, �� ��zQuery.bump_prefixc C sD | j r | j}| �|� |S | jr | �| �| �� jd��}|S d}|S )zf Return the first alias for this query, after increasing its reference count. N)r� r� rv r� r- �base_table_classr� �db_tabler� r8 r8 r9 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� r8 )r6 r r8 r8 r9 r^ r� z-Query.count_active_tables.<locals>.<listcomp>)r� r� r� rc r8 r8 r9 �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 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 r8 )�equals�r6 r r5 �r- r� r8 r9 r^ ! s z Query.join.<locals>.<listcomp>c s, g | ]\}}�d u s|�v r|� kr|�qS r1 r8 r� r� r8 r9 r^ % s ����T)rr ra ) r� r{ rt rv rq ra r4 ry r r| r ) rT r- r� � reuse_with_filtered_relation� reuse_aliases� reuse_aliasr� r� r4 r8 r� r9 r- s0 � � � 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. r� N)�get_base_chainr� �parents�get_ancestor_link� setup_joinsr3 rH ) rT r> r� r� �seenr � curr_opts� int_model� link_field� join_infor8 r8 r9 �join_parent_modelB 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� r8 r8 r9 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; rS � differencer� )rT r� r� r� r8 r8 r9 r% j s zQuery.add_annotationc s� | � � }|��� d|_|jj�g� �R i ��� |jr+t� ��fdd�|jD ��|_|j� � D ]!\}}|j�g� �R i ���}t |d�rL|j � |j � ||j|< q0�j � � D ] \}} t| t�og| jjjj|kprt| t�or| j| jk|j |< qW|S )NTc s$ g | ]}|j �g� �R i ����qS r8 )r� r ��args�kwargsr� r8 r9 r^ } s ��z,Query.resolve_expression.<locals>.<listcomp>r� )rW r< r� r� r� r� ro r� r� r{ r� r� rD r� rA r% � join_fieldr_ r� r� r# rq rt ) rT r� r� r� rW rv �value�resolvedr� �tabler8 r� r9 r� t s, �� � �zQuery.resolve_expressionc s0 t � j�� � jj�}� fdd�� j|dd�D �S )Nc s g | ] }|j � jv r|�qS r8 )r� r� r8 rc r8 r9 r^ � s �z+Query.get_external_cols.<locals>.<listcomp>T)�include_external)r r� r� r� r@ r� )rT �exprsr8 rc r9 �get_external_cols� s �zQuery.get_external_colsc C s( | � � }tdd� |D ��r|p| gS |S )Nc s r r1 )�possibly_multivaluedr8 r8 r8 r9 r: � r z*Query.get_group_by_cols.<locals>.<genexpr>)r� r� )rT �wrapper� external_colsr8 r8 r9 r� � s zQuery.get_group_by_colsc C s\ | j r|jjs| jdd� | jD ]}|jdd� q| j|d��� \}}| j r*d| }||fS )NFr� )r~ z(%s))r� re �*ignores_unnecessary_order_by_in_subqueriesr� r� r� r� )rT r� r~ r� rM rL r8 r8 r9 r� � s �� z Query.as_sqlc sj t |d�r|j��� |d�}|S t|ttf�r3� ��fdd�|D �}t|�}t |d�r/||� S ||�S |S )Nr� )r� r� r� c 3 s � | ] }�� |�� �V qd S r1 )�resolve_lookup_value)r6 � sub_value�r� � can_reuserT r8 r9 r: � s � � �z-Query.resolve_lookup_value.<locals>.<genexpr>�_make)r� r� rA rg ro �type)rT r� r� r� r� r� �type_r8 r� r9 r� � s" ��� zQuery.resolve_lookup_valuec C s� |� t�}| jr#t|| j�\}}|r#| j| }|r t||�}|d|fS | �|| �� �\}}}} |dt|�t| � � } t| �dkrO| sOtd|| �� j j f ��| | dfS )zX Solve the lookup type from the lookup (e.g.: 'foobar__id__icontains'). r8 r r� z"Invalid lookup "%s" for model %s".F) rh r r� r r � names_to_pathr� r� r r� rl ) rT �lookupr� �lookup_splittedr� �expression_lookupsr� r� r� � lookup_parts� field_partsr8 r8 r9 �solve_lookup_type� 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)rT r� r> r� r8 r8 r9 �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� rj N) rT rA r/ �has_select_fieldsr r� r� r� r� r� r� )rT r� r� r> �vr8 r8 r9 �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.�get_source_expressionsN)r� r� r rk rl r� �check_filterable)rT r� r r8 r8 r9 r� s � � �zQuery.check_filterablec C s� |pdg�^ }}|D ]}| � ||�}q |�|�}|s+| � ||�}d}|�|�}|s+dS |||�}|jdu rH|jsH|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� �iexactz Cannot use None as a query value�isnullTr� ) � try_transform� get_lookuprI �can_use_none_as_rhsr� r r re �!interprets_empty_strings_as_nulls) rT �lookups�lhsrI � transforms� lookup_namer3 � lookup_classr� r8 r8 r9 � build_lookup s* �zQuery.build_lookupc C s\ |� |�}|r ||�S |jj}t�||j�� �}|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� rk �difflib�get_close_matches� get_lookupsr- r rl )rT r� r3 �transform_classr� �suggested_lookups� suggestionr8 r8 r9 r� < s � ��zQuery.try_transformc s� t |t�r td��t |t�r| j|||||||| d�S t|d�rHt|dd�s*td��|j| || d�} t | t �s?| � dg| d �} t | gt d �g fS |\} } | sTtd | ��| � | | �\} }}|rd| �|� |spt|�d krptd ��| j�� � | �| ||| �} � fdd�| j�� D �}|r�| �| � |r�| � | || �} t | gt d �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"| �&|d |j|�}nt'|||j#|j�}n | �&|d |j|�}| � | || �} | j(}t | gt d �}|dk�oT| j)d u �oT| }|�r�|dk�sc| 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� r� � conditionalFz3Cannot filter against a non-conditional expression.)r� r� r� T)rJ z Cannot parse keyword query %rr� �7Joined field references are not permitted in this queryc s$ h | ]\}}|� � |d �kr|�qS rZ r� �r6 �kr� �� pre_joinsr8 r9 � <setcomp>� � z%Query.build_filter.<locals>.<setcomp>)r� � allow_manyr� Nr r� r� r8 )2rA rn r r �_add_qr� r� r� r� r r� r+ r' r� r� r� r� r� r� r{ r� r� r� r rg r� rF r> rH � _lookup_joinsr& � split_exclude�names_with_pathrD � trim_joinsrG rI rT r� r r� rI � is_nullabler� r4 r r� r� r r� ) rT � filter_exprr� r� r� r� r� r� r� r� � condition�argr� r� �parts�reffed_expression� used_joinsr> r� r� r� �erG � join_listr � lookup_type�clause� require_outerr� r8 r� r9 � build_filterR s� ( � � � � �� � ��� � zQuery.build_filterc C s | � t||f�� d S r1 )�add_qr )rT � filter_lhs� filter_rhsr8 r8 r9 � add_filter� � 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 r8 r3 )r6 r rc r8 r9 r� � z Query.add_q.<locals>.<setcomp>N)r� r� r� r� r� r' r� )rT �q_object�existing_innerr r� r8 rc r9 r � s �z Query.add_qc C s | j |dd�d S )NF)r� r )r )rT r r8 r8 r9 � build_where rY zQuery.build_wherec C s t � | _d S r1 )r+ r� rc r8 r8 r9 � clear_where s zQuery.clear_wherec C s� |j } ||jN }|p |j}t| |jd�} t|j t|j�|�} |jD ] } | j| |||||||d�\} }| �|� | r?| �| | � q!| � | �}| |fS )z%Add a Q-object to the current filter.�rJ �negated)r� r� r� r� r� r� r� ) rJ r r+ r= r� r@ r r> r� rA )rT r r� r� r� r� r� r� r� rJ � target_clauserM rD � child_clause� needed_innerr8 r8 r9 r� s0 � � � z Query._add_qc C s~ |j }||jN }|p |j}t||jd�}|jD ]%}t|t�r(| j||||d�}n| j||||dddd�\}} |�||� q|S )z4Add a FilteredRelation object to the current filter.r )r� r� r� TF)r� r� r� r� r� r� ) rJ r r+ r@ rA r. �build_filtered_relation_qr r� ) rT r r� r� r� rJ r rD r r� r8 r8 r9 r 9 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).r2 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� rn rB r r� rY r� r r� r� r� )rT ra r� r� �relation_lookup_parts�relation_field_partsr� r� r� �lookup_field_parts�shift�lookup_field_path�idx�lookup_field_partr8 r8 r9 �add_filtered_relationV s> ��� ������zQuery.add_filtered_relationc C s� g g }}t |�D �]K\}}|g f} |dkr|jj}d} d} z |du r%t�|�|�} W nJ tyu || jv r>| j| j} n5|| jv rs|dkrs| j| } t| j v rm| 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�|dur�||jur�|�|�}|r�|� |� | d � |� |d j}t| d ��r8| r�| �| �}n| j}|�st |�D ]!\}}|j �r| d � |d|d � � |� | � t |d |��q�|d }|� |� |j }|j}|j }| d � |� |� | � q | }| f}|�rU|d t!|�k�rUtd ||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 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.)"r� r� r3 r rX rS r� r� r rY rh r� r~ rT r_ r r� r� rV �AttributeError�sortedr? r- �get_path_to_parent�to_optsr� � get_path_infor( �m2mrp r& r� � target_fieldsr� )rT �namesr> r� �fail_on_missingrI r r� r3 �cur_names_with_pathr� ra r �filtered_relation_pathr� r� � available�path_to_parent� pathinfos� inner_pos�p�lastrF rG r8 r8 r9 r� u s� � �� �� � ���� �� � ��zQuery.names_to_pathc sv |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 �}d|_qK| D ]N}|jrq|j�� }|j }nd}d}|j }|j r��� |j �}nd}�j|j||t|j ||d �}|js�|r�|nd}�j|||d �}|�|� |r�|dd� |_qct� | ||| |�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 r1 r� )r� r� rc r8 r9 �final_transformer s z,Query.setup_joins.<locals>.final_transformerNr r� T)r1 r� c s< z || |�}�� ||�W S ty t� t�r �r ��� w r1 )r� r rA r )r� r� r3 �previous�wrapped�rF �last_field_exceptionrT r8 r9 � transform4 s �z$Query.setup_joins.<locals>.transform)r3 r; )ra )r� r� )�ranger� r� r � functools�partial�has_transformsra rW r� r, �directr r� � join_classr� r r. r- rp rI rE )rT r0 r> r� r� r� r� rH r: �pivotrI rG �rest�excr� r3 r? r- ra rt r| r~ r� r8 r= r9 r� � sn ' ��� � � � �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 r8 ��column�r6 �tr8 r8 r9 r� y � z#Query.trim_joins.<locals>.<setcomp>c S rI r8 rJ rL r8 r8 r9 r� z rN c s* i | ]}|d j � v r|d j |d �qS )r� r rJ �r6 �r)� cur_targetsr8 r9 rw } s �z$Query.trim_joins.<locals>.<dictcomp>c 3 s � | ]}� |j V qd S r1 rJ rL )� targets_dictr8 r9 r: � � � z#Query.trim_joins.<locals>.<genexpr>r� ) r� �reversedr� rD ra r� �foreign_related_fields�issubset�related_fieldsro r@ r� )rT rG rH rI r� �info� join_targetsr8 )rQ rR r9 r f s �zQuery.trim_joinsc c sz � |D ]7}t |t�r|V q|r tt|dd ��r |�� E d H qt|d�r:|s-t |t�r-q| j|�� ||d�E d H qd S )Nr� r� )r� r� ) rA r �callabler� r� r� r r� r� )�clsr� r� r� r r8 r8 r9 r� � s$ � � ���zQuery._gen_colsc c s � dd� | � |�D �E d H d S )Nc s r r1 )r� )r6 r r8 r8 r9 r: � r z)Query._gen_col_aliases.<locals>.<genexpr>)r� )r[ r� r8 r8 r9 �_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� r� r\ rA r� r% r rS r rh r r� r� r� r� r rG rH rI r� rJ rD ) rT r3 r� r� r� r� r� � field_listr? r� rG � final_aliasr r8 r8 r9 � resolve_ref� sT �� �� � �� � zQuery.resolve_refc C sJ | � | j�}| j|_|\}}t|t�rt|�}n t|t�r"t|j�}|�||� |jdd� |� |�\}}|j d } | j } | j } | |v rn| 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� )rk r� r� rA r r r3 r r� � trim_startr� r� r� r� r� r< r� r� r� r� r' r� r r r r( )rT r r� r r� r r �trimmed_prefix�contains_louterr � select_fieldr� r� r� r� r r �or_null_conditionr� r8 r8 r9 r� � sB � zQuery.split_excludec C s( | j �t� t� | jD ]}|�� q d S r1 )r� r� r* r' r� � set_empty)rT r� r8 r8 r9 re s �zQuery.set_emptyc C s t dd� | jjD ��S )Nc s s � | ]}t |t�V qd S r1 )rA r* )r6 �cr8 r8 r9 r: rS z!Query.is_empty.<locals>.<genexpr>)r� r� r@ rc r8 r8 r9 �is_empty r 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)rQ �minrP re )rT �lowr r8 r8 r9 r$ s �zQuery.set_limitsc C s d\| _ | _dS )zClear any existing limits.rK N�rP rQ rc r8 r8 r9 r� 2 � zQuery.clear_limitsc C s | j dkp | jd uS )Nr rj rc r8 r8 r9 r� 6 s zQuery.is_slicedc C s | j d uo | j | j dkS )Nr� )rQ rP rc r8 r8 r9 � 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� rc r8 r8 r9 � can_filter= s zQuery.can_filterc C s* d| _ d| _d| _| �d� | �d� dS )z%Remove all fields from SELECT clause.r8 FN)r� r� r� rE r� rc r8 r8 r9 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. r8 N�r� � values_selectrc r8 r8 r9 �clear_select_fieldsM s zQuery.clear_select_fieldsc C s$ | j |f7 _ | j|f7 _d S r1 rn )rT r r3 r8 r8 r9 �add_select_colV s zQuery.add_select_colc C s d| _ t|�| _d S �NF)r� ro r� )rT �colsr8 r8 r9 rC 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� )rT ri r8 r8 r9 �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� rh r r rG rH rI rp rJ rC r& r r� r* r? r� rS r� r- ) rT ri � allow_m2mr� r> rs r3 r� rG r^ rH r� r0 r8 r8 r9 r e s^ � ��� ������� ���zQuery.add_fieldsc G s� g }|D ]H}t |t�r6|dkrq|�d�r|dd� }|| jv r!q| jr*|| jv r*q| �|�t�| jj � n t |d�s@|� |� t |dd�rLt d| ��q|rUt d | ��|r`| 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� Nr� r� Fz[Using an aggregate in order_by() without also including it in annotate() is not allowed: %sz Invalid order_by arguments: %s)rA �str� startswithr� r� r� rh r r� r� r� rp r� r rG �default_ordering)rT �ordering�errors�itemr8 r8 r9 � add_ordering� s4 ��� 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). Nr8 F)r� r; r� rG rH rz )rT r� � clear_defaultr8 r8 r9 r� � s ��� �zQuery.clear_orderingc C s� |r<| j r<i }i }t| j | j�D ]\}}t|t�r |||< q|||< qi |�| j�| _| �|� t|�� �| _t|�| _ t | j�}| j � � D ] \}}|� � }sQqF|r_|j s_|�t||�� qF|�|� qFt|�| _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)ro r� r� rA r r� r� ro r� rg rS r{ r� r� rp r r~ r� ) rT r �group_by_annotationsro r� r r� r� � group_by_colsr8 r8 r9 r" � s& 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)rA r� �boolrh r rS )rT �fields� field_dictr� �drl r8 r8 r9 �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%sr� r r� �%r2 N)rh r{ r� rx �findrp r� r� rD r� r� r) r' rF ro rH ) rT r� � select_paramsr� rL �tablesrG � select_pairs� param_iterr3 �entry� entry_paramsr� r8 r8 r9 � add_extra� s0 � �zQuery.add_extrac C s t � df| _dS )z0Remove any fields from the deferred loading set.TN)� frozensetrg rc r8 r8 r9 �clear_deferred_loading rk z Query.clear_deferred_loadingc C sj | j \}}|r|�|�df| _ dS |�|� }r |df| _ dS | �� t|��|� }r3|df| _ dS 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)rg r r� r� r; )rT ri �existingrj � new_existing�new_onlyr8 r8 r9 �add_deferred_loading# 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) rg r; �remover� r� r� r3 r� r� )rT ri r� rj r8 r8 r9 �add_immediate_loading< s zQuery.add_immediate_loadingc C �$ |du rd| _ nt|�| _ d| _dS )z@Set the mask of annotations that will be returned by the SELECT.N)r� r; r� �rT r0 r8 r8 r9 r� T s zQuery.set_annotation_maskc C s$ | j d ur| �| j �|�� d S d S r1 )r� r� r r� r8 r8 r9 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� r8 r8 r9 rE ` s zQuery.set_extra_maskc C sj d| _ | �� | �� d| _|rWg }g }g }| js!| js!t|�}n#d| _|D ] }|| jv r3|� |� q&|| j v r>|� |� 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 )NFTc S r� r8 r r5 r8 r8 r9 r^ � rN z$Query.set_values.<locals>.<listcomp>c s r r1 r r5 r8 r8 r9 r: � r z#Query.set_values.<locals>.<genexpr>r )r� r� rp r� r� r� rg r� rR rp rS rE r� r� r� r� r! r� r r" rA r �refsro ro ) rT r� ri � extra_names�annotation_namesr7 �selectedr� r r8 r8 r9 � set_valuesk sJ � 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 r8 )r� r� rc r8 r9 rw � s �z+Query.annotation_select.<locals>.<dictcomp>)r� r� r� r{ rc r8 rc r9 rS � s �zQuery.annotation_selectc sJ � j d ur� j S � js i S � jd ur"� fdd�� j�� D �� _ � j S � jS )Nc r� r8 )r� r� rc r8 r9 rw � r z&Query.extra_select.<locals>.<dictcomp>)r� r� r� r{ rc r8 rc r9 rR � 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 � ��|| � | �d||d �}|r��j�|t� n d d� | jD �}|| � �jD ]}�j| dkr҈��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 r8 )r� r� rL rc r8 r9 r^ � r� z$Query.trim_start.<locals>.<listcomp>r� Tr c S � g | ]}|d �qS rZ r8 rO r8 r8 r9 r^ � r� Nc S r� r� r8 rO r8 r8 r9 r^ � r� c r6 r8 )r� r5 )� select_aliasr8 r9 r^ r: )r~ r� r� r. r4 r r@ r� r� r� rp rU r3 r r- ra rW �get_extra_restrictionr� r� r' r� r� rq rC )rT r � all_pathsr� �pathsrb � lookup_tables� trimmed_pathsrI r� r� �paths_in_prefixra r3 � first_join� select_fields�extra_restrictionr� r8 )r� rT r9 r` � s^ � �� ��zQuery.trim_startc C s |j p |jo tt 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. )�null�empty_strings_allowedr r re r� )rT r� r8 r8 r9 r s �zQuery.is_nullable)T)NNTr1 )FNr� rr )F)FFNTTFTF)FFTTTF)FF)TF)NTF)FT)TNF)NN)�rl r r� r� ro r� r� r� r� r# r� r% rE r� rz �standard_orderingr� r� r� r� rG rP rQ r� r; r� �select_for_update_nowait� select_for_update_skip_locked�select_for_update_of�select_for_no_key_updater� r� � max_depthro r� r� r� �combinator_allr� r� r� rF rH rg r, rU r� r� r, r� rq r� r� r� r� rW r r� r� r r r r r' r0 rR rW re rm rt rv 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� r � classmethodr� r\ r_ r� re rg r$ r� r� rl rm r# rp rq rC rt r r~ r� r" r� r� r� r� r� r� r� rE r� rS rR r` r r8 r8 r8 r9 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 rw r� N)r! )r� �default�dirnr8 r8 r9 � 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|tkrt| _nt| _n| j | _|| _t� | _d S r1 )rJ r r' r( �effective_connector� num_childrenr �votes)rT rJ r� r r8 r8 r9 rU 5 s zJoinPromoter.__init__c C s& | j j� d| j�d| j�d| j�d�S )Nz (connector=z, num_children=z , negated=�))rk r� rJ r� r rc r8 r8 r9 rm 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� rD )rT r� r8 r8 r9 r> J s zJoinPromoter.add_votesc C s~ t � }t � }| j�� D ]'\}}| jtkr || jk r |�|� | jtks-| jtkr2|| 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� )rT r� � to_promote� to_demoter� r� r8 r8 r9 rA Q s � z JoinPromoter.update_join_typesN)rl r r� r� rU rm r> rA r8 r8 r8 r9 r= / s r= )r� )Pr� r� r� rA r� � 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 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" �#django.db.models.sql.datastructuresr# r$ r% r& �django.db.models.sql.wherer' r( r) r* r+ �django.utils.functionalr, �django.utils.regex_helperr- �django.utils.treer. �__all__r� r* r? rB rE r0 r� r/ r� r= r8 r8 r8 r9 �<module> sr ( � I query.py 0000644 00000340776 15030124302 0006272 0 ustar 00 """ 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. """ import copy import difflib import functools import sys from collections import Counter, namedtuple from collections.abc import Iterator, Mapping from itertools import chain, count, product from string import ascii_uppercase from django.core.exceptions import FieldDoesNotExist, FieldError from django.db import DEFAULT_DB_ALIAS, NotSupportedError, connections from django.db.models.aggregates import Count from django.db.models.constants import LOOKUP_SEP from django.db.models.expressions import ( BaseExpression, Col, Exists, F, OuterRef, Ref, ResolvedOuterRef, Value, ) from django.db.models.fields import Field from django.db.models.fields.related_lookups import MultiColSource from django.db.models.lookups import Lookup from django.db.models.query_utils import ( Q, check_rel_lookup_compatibility, refs_expression, ) from django.db.models.sql.constants import INNER, LOUTER, ORDER_DIR, SINGLE from django.db.models.sql.datastructures import BaseTable, Empty, Join, MultiJoin from django.db.models.sql.where import AND, OR, ExtraWhere, NothingNode, WhereNode from django.utils.functional import cached_property from django.utils.regex_helper import _lazy_re_compile from django.utils.tree import Node __all__ = ["Query", "RawQuery"] # Quotation marks ('"`[]), whitespace characters, semicolons, or inline # SQL comments are forbidden in column aliases. FORBIDDEN_ALIAS_PATTERN = _lazy_re_compile(r"['`\"\]\[;\s]|--|/\*|\*/") # Inspired from # https://www.postgresql.org/docs/current/sql-syntax-lexical.html#SQL-SYNTAX-IDENTIFIERS EXPLAIN_OPTIONS_PATTERN = _lazy_re_compile(r"[\w\-]+") def get_field_names_from_opts(opts): if opts is None: return set() return set( chain.from_iterable( (f.name, f.attname) if f.concrete else (f.name,) for f in opts.get_fields() ) ) def get_children_from_q(q): for child in q.children: if isinstance(child, Node): yield from get_children_from_q(child) else: yield child JoinInfo = namedtuple( "JoinInfo", ("final_field", "targets", "opts", "joins", "path", "transform_function"), ) class RawQuery: """A single raw SQL query.""" def __init__(self, sql, using, params=()): self.params = params self.sql = sql self.using = using self.cursor = None # Mirror some properties of a normal query so that # the compiler can be used to process results. self.low_mark, self.high_mark = 0, None # Used for offset/limit self.extra_select = {} self.annotation_select = {} def chain(self, using): return self.clone(using) def clone(self, using): return RawQuery(self.sql, using, params=self.params) def get_columns(self): if self.cursor is None: self._execute_query() converter = connections[self.using].introspection.identifier_converter return [converter(column_meta[0]) for column_meta in self.cursor.description] def __iter__(self): # Always execute a new query for a new iterator. # This could be optimized with a cache at the expense of RAM. self._execute_query() if not connections[self.using].features.can_use_chunked_reads: # If the database can't use chunked reads we need to make sure we # evaluate the entire query up front. result = list(self.cursor) else: result = self.cursor return iter(result) def __repr__(self): return "<%s: %s>" % (self.__class__.__name__, self) @property def params_type(self): if self.params is None: return None return dict if isinstance(self.params, Mapping) else tuple def __str__(self): if self.params_type is None: return self.sql return self.sql % self.params_type(self.params) def _execute_query(self): connection = connections[self.using] # Adapt parameters to the database, as much as possible considering # that the target type isn't known. See #17755. params_type = self.params_type adapter = connection.ops.adapt_unknown_value if params_type is tuple: params = tuple(adapter(val) for val in self.params) elif params_type is dict: params = {key: adapter(val) for key, val in self.params.items()} elif params_type is None: params = None else: raise RuntimeError("Unexpected params type: %s" % params_type) self.cursor = connection.cursor() self.cursor.execute(self.sql, params) ExplainInfo = namedtuple("ExplainInfo", ("format", "options")) class Query(BaseExpression): """A single SQL query.""" alias_prefix = "T" empty_result_set_value = None subq_aliases = frozenset([alias_prefix]) compiler = "SQLCompiler" base_table_class = BaseTable join_class = Join default_cols = True default_ordering = True standard_ordering = True filter_is_sticky = False subquery = False # SQL-related attributes. # Select and related select clauses are expressions to use in the SELECT # clause of the query. The select is used for cases where we want to set up # the select clause to contain other than default fields (values(), # subqueries...). Note that annotations go to annotations dictionary. select = () # The group_by attribute can have one of the following forms: # - None: no group by at all in the query # - A tuple of expressions: group by (at least) those expressions. # String refs are also allowed for now. # - True: group by all select fields of the model # See compiler.get_group_by() for details. group_by = None order_by = () low_mark = 0 # Used for offset/limit. high_mark = None # Used for offset/limit. distinct = False distinct_fields = () select_for_update = False select_for_update_nowait = False select_for_update_skip_locked = False select_for_update_of = () select_for_no_key_update = False select_related = False has_select_fields = False # Arbitrary limit for select_related to prevents infinite recursion. max_depth = 5 # Holds the selects defined by a call to values() or values_list() # excluding annotation_select and extra_select. values_select = () # SQL annotation-related attributes. annotation_select_mask = None _annotation_select_cache = None # Set combination attributes. combinator = None combinator_all = False combined_queries = () # These are for extensions. The contents are more or less appended verbatim # to the appropriate clause. extra_select_mask = None _extra_select_cache = None extra_tables = () extra_order_by = () # A tuple that is a set of model field names and either True, if these are # the fields to defer, or False if these are the only fields to load. deferred_loading = (frozenset(), True) explain_info = None def __init__(self, model, alias_cols=True): self.model = model self.alias_refcount = {} # alias_map is the most important data structure regarding joins. # It's used for recording which joins exist in the query and what # types they are. The key is the alias of the joined table (possibly # the table name) and the value is a Join-like object (see # sql.datastructures.Join for more information). self.alias_map = {} # Whether to provide alias to columns during reference resolving. self.alias_cols = alias_cols # Sometimes the query contains references to aliases in outer queries (as # a result of split_exclude). Correct alias quoting needs to know these # aliases too. # Map external tables to whether they are aliased. self.external_aliases = {} self.table_map = {} # Maps table names to list of aliases. self.used_aliases = set() self.where = WhereNode() # Maps alias -> Annotation Expression. self.annotations = {} # These are for extensions. The contents are more or less appended # verbatim to the appropriate clause. self.extra = {} # Maps col_alias -> (col_sql, params). self._filtered_relations = {} @property def output_field(self): if len(self.select) == 1: select = self.select[0] return getattr(select, "target", None) or select.field elif len(self.annotation_select) == 1: return next(iter(self.annotation_select.values())).output_field @cached_property def base_table(self): for alias in self.alias_map: return alias def __str__(self): """ 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, params = self.sql_with_params() return sql % params def sql_with_params(self): """ Return the query as an SQL string and the parameters that will be substituted into the query. """ return self.get_compiler(DEFAULT_DB_ALIAS).as_sql() def __deepcopy__(self, memo): """Limit the amount of work when a Query is deepcopied.""" result = self.clone() memo[id(self)] = result return result def get_compiler(self, using=None, connection=None, elide_empty=True): if using is None and connection is None: raise ValueError("Need either using or connection") if using: connection = connections[using] return connection.ops.compiler(self.compiler)( self, connection, using, elide_empty ) def get_meta(self): """ 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. """ if self.model: return self.model._meta def clone(self): """ Return a copy of the current Query. A lightweight alternative to deepcopy(). """ obj = Empty() obj.__class__ = self.__class__ # Copy references to everything. obj.__dict__ = self.__dict__.copy() # Clone attributes that can't use shallow copy. obj.alias_refcount = self.alias_refcount.copy() obj.alias_map = self.alias_map.copy() obj.external_aliases = self.external_aliases.copy() obj.table_map = self.table_map.copy() obj.where = self.where.clone() obj.annotations = self.annotations.copy() if self.annotation_select_mask is not None: obj.annotation_select_mask = self.annotation_select_mask.copy() if self.combined_queries: obj.combined_queries = tuple( [query.clone() for query in self.combined_queries] ) # _annotation_select_cache cannot be copied, as doing so breaks the # (necessary) state in which both annotations and # _annotation_select_cache point to the same underlying objects. # It will get re-populated in the cloned queryset the next time it's # used. obj._annotation_select_cache = None obj.extra = self.extra.copy() if self.extra_select_mask is not None: obj.extra_select_mask = self.extra_select_mask.copy() if self._extra_select_cache is not None: obj._extra_select_cache = self._extra_select_cache.copy() if self.select_related is not False: # Use deepcopy because select_related stores fields in nested # dicts. obj.select_related = copy.deepcopy(obj.select_related) if "subq_aliases" in self.__dict__: obj.subq_aliases = self.subq_aliases.copy() obj.used_aliases = self.used_aliases.copy() obj._filtered_relations = self._filtered_relations.copy() # Clear the cached_property, if it exists. obj.__dict__.pop("base_table", None) return obj def chain(self, klass=None): """ 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. """ obj = self.clone() if klass and obj.__class__ != klass: obj.__class__ = klass if not obj.filter_is_sticky: obj.used_aliases = set() obj.filter_is_sticky = False if hasattr(obj, "_setup_query"): obj._setup_query() return obj def relabeled_clone(self, change_map): clone = self.clone() clone.change_aliases(change_map) return clone def _get_col(self, target, field, alias): if not self.alias_cols: alias = None return target.get_col(alias, field) def get_aggregation(self, using, aggregate_exprs): """ Return the dictionary with the values of the existing aggregations. """ if not aggregate_exprs: return {} # Store annotation mask prior to temporarily adding aggregations for # resolving purpose to facilitate their subsequent removal. refs_subquery = False refs_window = False replacements = {} annotation_select_mask = self.annotation_select_mask for alias, aggregate_expr in aggregate_exprs.items(): self.check_alias(alias) aggregate = aggregate_expr.resolve_expression( self, allow_joins=True, reuse=None, summarize=True ) if not aggregate.contains_aggregate: raise TypeError("%s is not an aggregate expression" % alias) # Temporarily add aggregate to annotations to allow remaining # members of `aggregates` to resolve against each others. self.append_annotation_mask([alias]) refs_subquery |= any( getattr(self.annotations[ref], "contains_subquery", False) for ref in aggregate.get_refs() ) refs_window |= any( getattr(self.annotations[ref], "contains_over_clause", True) for ref in aggregate.get_refs() ) aggregate = aggregate.replace_expressions(replacements) self.annotations[alias] = aggregate replacements[Ref(alias, aggregate)] = aggregate # Stash resolved aggregates now that they have been allowed to resolve # against each other. aggregates = {alias: self.annotations.pop(alias) for alias in aggregate_exprs} self.set_annotation_mask(annotation_select_mask) # Existing usage of aggregation can be determined by the presence of # selected aggregates but also by filters against aliased aggregates. _, having, qualify = self.where.split_having_qualify() has_existing_aggregation = ( any( getattr(annotation, "contains_aggregate", True) for annotation in self.annotations.values() ) or having ) # Decide if we need to use a subquery. # # Existing aggregations would cause incorrect results as # get_aggregation() must produce just one result and thus must not use # GROUP BY. # # If the query has limit or distinct, or uses set operations, then # those operations must be done in a subquery so that the query # aggregates on the limit and/or distinct results instead of applying # the distinct and limit after the aggregation. if ( isinstance(self.group_by, tuple) or self.is_sliced or has_existing_aggregation or refs_subquery or refs_window or qualify or self.distinct or self.combinator ): from django.db.models.sql.subqueries import AggregateQuery inner_query = self.clone() inner_query.subquery = True outer_query = AggregateQuery(self.model, inner_query) inner_query.select_for_update = False inner_query.select_related = False inner_query.set_annotation_mask(self.annotation_select) # Queries with distinct_fields need ordering and when a limit is # applied we must take the slice from the ordered query. Otherwise # no need for ordering. inner_query.clear_ordering(force=False) if not inner_query.distinct: # If the inner query uses default select and it has some # aggregate annotations, then we must make sure the inner # query is grouped by the main model's primary key. However, # clearing the select clause can alter results if distinct is # used. if inner_query.default_cols and has_existing_aggregation: inner_query.group_by = ( self.model._meta.pk.get_col(inner_query.get_initial_alias()), ) inner_query.default_cols = False if not qualify: # Mask existing annotations that are not referenced by # aggregates to be pushed to the outer query unless # filtering against window functions is involved as it # requires complex realising. annotation_mask = set() if isinstance(self.group_by, tuple): for expr in self.group_by: annotation_mask |= expr.get_refs() for aggregate in aggregates.values(): annotation_mask |= aggregate.get_refs() # Avoid eliding expressions that might have an incidence on # the implicit grouping logic. for annotation_alias, annotation in self.annotation_select.items(): if annotation.get_group_by_cols(): annotation_mask.add(annotation_alias) inner_query.set_annotation_mask(annotation_mask) # Add aggregates to the outer AggregateQuery. This requires making # sure all columns referenced by the aggregates are selected in the # inner query. It is achieved by retrieving all column references # by the aggregates, explicitly selecting them in the inner query, # and making sure the aggregates are repointed to them. col_refs = {} for alias, aggregate in aggregates.items(): replacements = {} for col in self._gen_cols([aggregate], resolve_refs=False): if not (col_ref := col_refs.get(col)): index = len(col_refs) + 1 col_alias = f"__col{index}" col_ref = Ref(col_alias, col) col_refs[col] = col_ref inner_query.annotations[col_alias] = col inner_query.append_annotation_mask([col_alias]) replacements[col] = col_ref outer_query.annotations[alias] = aggregate.replace_expressions( replacements ) if ( inner_query.select == () and not inner_query.default_cols and not inner_query.annotation_select_mask ): # In case of Model.objects[0:3].count(), there would be no # field selected in the inner query, yet we must use a subquery. # So, make sure at least one field is selected. inner_query.select = ( self.model._meta.pk.get_col(inner_query.get_initial_alias()), ) else: outer_query = self self.select = () self.default_cols = False self.extra = {} if self.annotations: # Inline reference to existing annotations and mask them as # they are unnecessary given only the summarized aggregations # are requested. replacements = { Ref(alias, annotation): annotation for alias, annotation in self.annotations.items() } self.annotations = { alias: aggregate.replace_expressions(replacements) for alias, aggregate in aggregates.items() } else: self.annotations = aggregates self.set_annotation_mask(aggregates) empty_set_result = [ expression.empty_result_set_value for expression in outer_query.annotation_select.values() ] elide_empty = not any(result is NotImplemented for result in empty_set_result) outer_query.clear_ordering(force=True) outer_query.clear_limits() outer_query.select_for_update = False outer_query.select_related = False compiler = outer_query.get_compiler(using, elide_empty=elide_empty) result = compiler.execute_sql(SINGLE) if result is None: result = empty_set_result else: converters = compiler.get_converters(outer_query.annotation_select.values()) result = next(compiler.apply_converters((result,), converters)) return dict(zip(outer_query.annotation_select, result)) def get_count(self, using): """ Perform a COUNT() query using the current filter constraints. """ obj = self.clone() return obj.get_aggregation(using, {"__count": Count("*")})["__count"] def has_filters(self): return self.where def exists(self, limit=True): q = self.clone() if not (q.distinct and q.is_sliced): if q.group_by is True: q.add_fields( (f.attname for f in self.model._meta.concrete_fields), False ) # Disable GROUP BY aliases to avoid orphaning references to the # SELECT clause which is about to be cleared. q.set_group_by(allow_aliases=False) q.clear_select_clause() if q.combined_queries and q.combinator == "union": q.combined_queries = tuple( combined_query.exists(limit=False) for combined_query in q.combined_queries ) q.clear_ordering(force=True) if limit: q.set_limits(high=1) q.add_annotation(Value(1), "a") return q def has_results(self, using): q = self.exists(using) compiler = q.get_compiler(using=using) return compiler.has_results() def explain(self, using, format=None, **options): q = self.clone() for option_name in options: if ( not EXPLAIN_OPTIONS_PATTERN.fullmatch(option_name) or "--" in option_name ): raise ValueError(f"Invalid option name: {option_name!r}.") q.explain_info = ExplainInfo(format, options) compiler = q.get_compiler(using=using) return "\n".join(compiler.explain_query()) def combine(self, rhs, connector): """ 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. """ if self.model != rhs.model: raise TypeError("Cannot combine queries on two different base models.") if self.is_sliced: raise TypeError("Cannot combine queries once a slice has been taken.") if self.distinct != rhs.distinct: raise TypeError("Cannot combine a unique query with a non-unique query.") if self.distinct_fields != rhs.distinct_fields: raise TypeError("Cannot combine queries with different distinct fields.") # If lhs and rhs shares the same alias prefix, it is possible to have # conflicting alias changes like T4 -> T5, T5 -> T6, which might end up # as T4 -> T6 while combining two querysets. To prevent this, change an # alias prefix of the rhs and update current aliases accordingly, # except if the alias is the base table since it must be present in the # query on both sides. initial_alias = self.get_initial_alias() rhs.bump_prefix(self, exclude={initial_alias}) # Work out how to relabel the rhs aliases, if necessary. change_map = {} conjunction = connector == AND # Determine which existing joins can be reused. When combining the # query with AND we must recreate all joins for m2m filters. When # combining with OR we can reuse joins. The reason is that in AND # case a single row can't fulfill a condition like: # revrel__col=1 & revrel__col=2 # But, there might be two different related rows matching this # condition. In OR case a single True is enough, so single row is # enough, too. # # Note that we will be creating duplicate joins for non-m2m joins in # the AND case. The results will be correct but this creates too many # joins. This is something that could be fixed later on. reuse = set() if conjunction else set(self.alias_map) joinpromoter = JoinPromoter(connector, 2, False) joinpromoter.add_votes( j for j in self.alias_map if self.alias_map[j].join_type == INNER ) rhs_votes = set() # Now, add the joins from rhs query into the new query (skipping base # table). rhs_tables = list(rhs.alias_map)[1:] for alias in rhs_tables: join = rhs.alias_map[alias] # If the left side of the join was already relabeled, use the # updated alias. join = join.relabeled_clone(change_map) new_alias = self.join(join, reuse=reuse) if join.join_type == INNER: rhs_votes.add(new_alias) # We can't reuse the same join again in the query. If we have two # distinct joins for the same connection in rhs query, then the # combined query must have two joins, too. reuse.discard(new_alias) if alias != new_alias: change_map[alias] = new_alias if not rhs.alias_refcount[alias]: # The alias was unused in the rhs query. Unref it so that it # will be unused in the new query, too. We have to add and # unref the alias so that join promotion has information of # the join type for the unused alias. self.unref_alias(new_alias) joinpromoter.add_votes(rhs_votes) joinpromoter.update_join_types(self) # Combine subqueries aliases to ensure aliases relabelling properly # handle subqueries when combining where and select clauses. self.subq_aliases |= rhs.subq_aliases # Now relabel a copy of the rhs where-clause and add it to the current # one. w = rhs.where.clone() w.relabel_aliases(change_map) self.where.add(w, connector) # Selection columns and extra extensions are those provided by 'rhs'. if rhs.select: self.set_select([col.relabeled_clone(change_map) for col in rhs.select]) else: self.select = () if connector == OR: # It would be nice to be able to handle this, but the queries don't # really make sense (or return consistent value sets). Not worth # the extra complexity when you can write a real query instead. if self.extra and rhs.extra: raise ValueError( "When merging querysets using 'or', you cannot have " "extra(select=...) on both sides." ) self.extra.update(rhs.extra) extra_select_mask = set() if self.extra_select_mask is not None: extra_select_mask.update(self.extra_select_mask) if rhs.extra_select_mask is not None: extra_select_mask.update(rhs.extra_select_mask) if extra_select_mask: self.set_extra_mask(extra_select_mask) self.extra_tables += rhs.extra_tables # Ordering uses the 'rhs' ordering, unless it has none, in which case # the current ordering is used. self.order_by = rhs.order_by or self.order_by self.extra_order_by = rhs.extra_order_by or self.extra_order_by def _get_defer_select_mask(self, opts, mask, select_mask=None): if select_mask is None: select_mask = {} select_mask[opts.pk] = {} # All concrete fields that are not part of the defer mask must be # loaded. If a relational field is encountered it gets added to the # mask for it be considered if `select_related` and the cycle continues # by recursively caling this function. for field in opts.concrete_fields: field_mask = mask.pop(field.name, None) field_att_mask = mask.pop(field.attname, None) if field_mask is None and field_att_mask is None: select_mask.setdefault(field, {}) elif field_mask: if not field.is_relation: raise FieldError(next(iter(field_mask))) field_select_mask = select_mask.setdefault(field, {}) related_model = field.remote_field.model._meta.concrete_model self._get_defer_select_mask( related_model._meta, field_mask, field_select_mask ) # Remaining defer entries must be references to reverse relationships. # The following code is expected to raise FieldError if it encounters # a malformed defer entry. for field_name, field_mask in mask.items(): if filtered_relation := self._filtered_relations.get(field_name): relation = opts.get_field(filtered_relation.relation_name) field_select_mask = select_mask.setdefault((field_name, relation), {}) field = relation.field else: reverse_rel = opts.get_field(field_name) # While virtual fields such as many-to-many and generic foreign # keys cannot be effectively deferred we've historically # allowed them to be passed to QuerySet.defer(). Ignore such # field references until a layer of validation at mask # alteration time will be implemented eventually. if not hasattr(reverse_rel, "field"): continue field = reverse_rel.field field_select_mask = select_mask.setdefault(field, {}) related_model = field.model._meta.concrete_model self._get_defer_select_mask( related_model._meta, field_mask, field_select_mask ) return select_mask def _get_only_select_mask(self, opts, mask, select_mask=None): if select_mask is None: select_mask = {} select_mask[opts.pk] = {} # Only include fields mentioned in the mask. for field_name, field_mask in mask.items(): field = opts.get_field(field_name) # Retrieve the actual field associated with reverse relationships # as that's what is expected in the select mask. if field in opts.related_objects: field_key = field.field else: field_key = field field_select_mask = select_mask.setdefault(field_key, {}) if field_mask: if not field.is_relation: raise FieldError(next(iter(field_mask))) related_model = field.remote_field.model._meta.concrete_model self._get_only_select_mask( related_model._meta, field_mask, field_select_mask ) return select_mask def get_select_mask(self): """ 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. """ field_names, defer = self.deferred_loading if not field_names: return {} mask = {} for field_name in field_names: part_mask = mask for part in field_name.split(LOOKUP_SEP): part_mask = part_mask.setdefault(part, {}) opts = self.get_meta() if defer: return self._get_defer_select_mask(opts, mask) return self._get_only_select_mask(opts, mask) def table_alias(self, table_name, create=False, filtered_relation=None): """ 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. """ alias_list = self.table_map.get(table_name) if not create and alias_list: alias = alias_list[0] self.alias_refcount[alias] += 1 return alias, False # Create a new alias for this table. if alias_list: alias = "%s%d" % (self.alias_prefix, len(self.alias_map) + 1) alias_list.append(alias) else: # The first occurrence of a table uses the table name directly. alias = ( filtered_relation.alias if filtered_relation is not None else table_name ) self.table_map[table_name] = [alias] self.alias_refcount[alias] = 1 return alias, True def ref_alias(self, alias): """Increases the reference count for this alias.""" self.alias_refcount[alias] += 1 def unref_alias(self, alias, amount=1): """Decreases the reference count for this alias.""" self.alias_refcount[alias] -= amount def promote_joins(self, aliases): """ 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. """ aliases = list(aliases) while aliases: alias = aliases.pop(0) if self.alias_map[alias].join_type is None: # This is the base table (first FROM entry) - this table # isn't really joined at all in the query, so we should not # alter its join type. continue # Only the first alias (skipped above) should have None join_type assert self.alias_map[alias].join_type is not None parent_alias = self.alias_map[alias].parent_alias parent_louter = ( parent_alias and self.alias_map[parent_alias].join_type == LOUTER ) already_louter = self.alias_map[alias].join_type == LOUTER if (self.alias_map[alias].nullable or parent_louter) and not already_louter: self.alias_map[alias] = self.alias_map[alias].promote() # Join type of 'alias' changed, so re-examine all aliases that # refer to this one. aliases.extend( join for join in self.alias_map if self.alias_map[join].parent_alias == alias and join not in aliases ) def demote_joins(self, aliases): """ 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. . """ aliases = list(aliases) while aliases: alias = aliases.pop(0) if self.alias_map[alias].join_type == LOUTER: self.alias_map[alias] = self.alias_map[alias].demote() parent_alias = self.alias_map[alias].parent_alias if self.alias_map[parent_alias].join_type == INNER: aliases.append(parent_alias) def reset_refcounts(self, to_counts): """ Reset reference counts for aliases so that they match the value passed in `to_counts`. """ for alias, cur_refcount in self.alias_refcount.copy().items(): unref_amount = cur_refcount - to_counts.get(alias, 0) self.unref_alias(alias, unref_amount) def change_aliases(self, change_map): """ Change the aliases in change_map (which maps old-alias -> new-alias), relabelling any references to them in select columns and the where clause. """ # If keys and values of change_map were to intersect, an alias might be # updated twice (e.g. T4 -> T5, T5 -> T6, so also T4 -> T6) depending # on their order in change_map. assert set(change_map).isdisjoint(change_map.values()) # 1. Update references in "select" (normal columns plus aliases), # "group by" and "where". self.where.relabel_aliases(change_map) if isinstance(self.group_by, tuple): self.group_by = tuple( [col.relabeled_clone(change_map) for col in self.group_by] ) self.select = tuple([col.relabeled_clone(change_map) for col in self.select]) self.annotations = self.annotations and { key: col.relabeled_clone(change_map) for key, col in self.annotations.items() } # 2. Rename the alias in the internal table/alias datastructures. for old_alias, new_alias in change_map.items(): if old_alias not in self.alias_map: continue alias_data = self.alias_map[old_alias].relabeled_clone(change_map) self.alias_map[new_alias] = alias_data self.alias_refcount[new_alias] = self.alias_refcount[old_alias] del self.alias_refcount[old_alias] del self.alias_map[old_alias] table_aliases = self.table_map[alias_data.table_name] for pos, alias in enumerate(table_aliases): if alias == old_alias: table_aliases[pos] = new_alias break self.external_aliases = { # Table is aliased or it's being changed and thus is aliased. change_map.get(alias, alias): (aliased or alias in change_map) for alias, aliased in self.external_aliases.items() } def bump_prefix(self, other_query, exclude=None): """ 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. """ def prefix_gen(): """ 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', ... """ alphabet = ascii_uppercase prefix = chr(ord(self.alias_prefix) + 1) yield prefix for n in count(1): seq = alphabet[alphabet.index(prefix) :] if prefix else alphabet for s in product(seq, repeat=n): yield "".join(s) prefix = None if self.alias_prefix != other_query.alias_prefix: # No clashes between self and outer query should be possible. return # Explicitly avoid infinite loop. The constant divider is based on how # much depth recursive subquery references add to the stack. This value # might need to be adjusted when adding or removing function calls from # the code path in charge of performing these operations. local_recursion_limit = sys.getrecursionlimit() // 16 for pos, prefix in enumerate(prefix_gen()): if prefix not in self.subq_aliases: self.alias_prefix = prefix break if pos > local_recursion_limit: raise RecursionError( "Maximum recursion depth exceeded: too many subqueries." ) self.subq_aliases = self.subq_aliases.union([self.alias_prefix]) other_query.subq_aliases = other_query.subq_aliases.union(self.subq_aliases) if exclude is None: exclude = {} self.change_aliases( { alias: "%s%d" % (self.alias_prefix, pos) for pos, alias in enumerate(self.alias_map) if alias not in exclude } ) def get_initial_alias(self): """ Return the first alias for this query, after increasing its reference count. """ if self.alias_map: alias = self.base_table self.ref_alias(alias) elif self.model: alias = self.join(self.base_table_class(self.get_meta().db_table, None)) else: alias = None return alias def count_active_tables(self): """ 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. """ return len([1 for count in self.alias_refcount.values() if count]) def join(self, join, reuse=None, reuse_with_filtered_relation=False): """ 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. """ if reuse_with_filtered_relation and reuse: reuse_aliases = [ a for a, j in self.alias_map.items() if a in reuse and j.equals(join) ] else: reuse_aliases = [ a for a, j in self.alias_map.items() if (reuse is None or a in reuse) and j == join ] if reuse_aliases: if join.table_alias in reuse_aliases: reuse_alias = join.table_alias else: # Reuse the most recent alias of the joined table # (a many-to-many relation may be joined multiple times). reuse_alias = reuse_aliases[-1] self.ref_alias(reuse_alias) return reuse_alias # No reuse is possible, so we need a new alias. alias, _ = self.table_alias( join.table_name, create=True, filtered_relation=join.filtered_relation ) if join.join_type: if self.alias_map[join.parent_alias].join_type == LOUTER or join.nullable: join_type = LOUTER else: join_type = INNER join.join_type = join_type join.table_alias = alias self.alias_map[alias] = join return alias def join_parent_model(self, opts, model, alias, seen): """ 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. """ if model in seen: return seen[model] chain = opts.get_base_chain(model) if not chain: return alias curr_opts = opts for int_model in chain: if int_model in seen: curr_opts = int_model._meta alias = seen[int_model] continue # Proxy model have elements in base chain # with no parents, assign the new options # object and skip to the next base in that # case if not curr_opts.parents[int_model]: curr_opts = int_model._meta continue link_field = curr_opts.get_ancestor_link(int_model) join_info = self.setup_joins([link_field.name], curr_opts, alias) curr_opts = int_model._meta alias = seen[int_model] = join_info.joins[-1] return alias or seen[None] def check_alias(self, alias): if FORBIDDEN_ALIAS_PATTERN.search(alias): raise ValueError( "Column aliases cannot contain whitespace characters, quotation marks, " "semicolons, or SQL comments." ) def add_annotation(self, annotation, alias, select=True): """Add a single annotation expression to the Query.""" self.check_alias(alias) annotation = annotation.resolve_expression(self, allow_joins=True, reuse=None) if select: self.append_annotation_mask([alias]) else: self.set_annotation_mask(set(self.annotation_select).difference({alias})) self.annotations[alias] = annotation def resolve_expression(self, query, *args, **kwargs): clone = self.clone() # Subqueries need to use a different set of aliases than the outer query. clone.bump_prefix(query) clone.subquery = True clone.where.resolve_expression(query, *args, **kwargs) # Resolve combined queries. if clone.combinator: clone.combined_queries = tuple( [ combined_query.resolve_expression(query, *args, **kwargs) for combined_query in clone.combined_queries ] ) for key, value in clone.annotations.items(): resolved = value.resolve_expression(query, *args, **kwargs) if hasattr(resolved, "external_aliases"): resolved.external_aliases.update(clone.external_aliases) clone.annotations[key] = resolved # Outer query's aliases are considered external. for alias, table in query.alias_map.items(): clone.external_aliases[alias] = ( isinstance(table, Join) and table.join_field.related_model._meta.db_table != alias ) or ( isinstance(table, BaseTable) and table.table_name != table.table_alias ) return clone def get_external_cols(self): exprs = chain(self.annotations.values(), self.where.children) return [ col for col in self._gen_cols(exprs, include_external=True) if col.alias in self.external_aliases ] def get_group_by_cols(self, wrapper=None): # If wrapper is referenced by an alias for an explicit GROUP BY through # values() a reference to this expression and not the self must be # returned to ensure external column references are not grouped against # as well. external_cols = self.get_external_cols() if any(col.possibly_multivalued for col in external_cols): return [wrapper or self] return external_cols def as_sql(self, compiler, connection): # Some backends (e.g. Oracle) raise an error when a subquery contains # unnecessary ORDER BY clause. if ( self.subquery and not connection.features.ignores_unnecessary_order_by_in_subqueries ): self.clear_ordering(force=False) for query in self.combined_queries: query.clear_ordering(force=False) sql, params = self.get_compiler(connection=connection).as_sql() if self.subquery: sql = "(%s)" % sql return sql, params def resolve_lookup_value(self, value, can_reuse, allow_joins, summarize=False): if hasattr(value, "resolve_expression"): value = value.resolve_expression( self, reuse=can_reuse, allow_joins=allow_joins, summarize=summarize, ) elif isinstance(value, (list, tuple)): # The items of the iterable may be expressions and therefore need # to be resolved independently. values = ( self.resolve_lookup_value(sub_value, can_reuse, allow_joins) for sub_value in value ) type_ = type(value) if hasattr(type_, "_make"): # namedtuple return type_(*values) return type_(values) return value def solve_lookup_type(self, lookup, summarize=False): """ Solve the lookup type from the lookup (e.g.: 'foobar__id__icontains'). """ lookup_splitted = lookup.split(LOOKUP_SEP) if self.annotations: annotation, expression_lookups = refs_expression( lookup_splitted, self.annotations ) if annotation: expression = self.annotations[annotation] if summarize: expression = Ref(annotation, expression) return expression_lookups, (), expression _, field, _, lookup_parts = self.names_to_path(lookup_splitted, self.get_meta()) field_parts = lookup_splitted[0 : len(lookup_splitted) - len(lookup_parts)] if len(lookup_parts) > 1 and not field_parts: raise FieldError( 'Invalid lookup "%s" for model %s".' % (lookup, self.get_meta().model.__name__) ) return lookup_parts, field_parts, False def check_query_object_type(self, value, opts, field): """ Check whether the object passed while querying is of the correct type. If not, raise a ValueError specifying the wrong object. """ if hasattr(value, "_meta"): if not check_rel_lookup_compatibility(value._meta.model, opts, field): raise ValueError( 'Cannot query "%s": Must be "%s" instance.' % (value, opts.object_name) ) def check_related_objects(self, field, value, opts): """Check the type of object passed to query relations.""" if field.is_relation: # Check that the field and the queryset use the same model in a # query like .filter(author=Author.objects.all()). For example, the # opts would be Author's (from the author field) and value.model # would be Author.objects.all() queryset's .model (Author also). # The field is the related field on the lhs side. if ( isinstance(value, Query) and not value.has_select_fields and not check_rel_lookup_compatibility(value.model, opts, field) ): raise ValueError( 'Cannot use QuerySet for "%s": Use a QuerySet for "%s".' % (value.model._meta.object_name, opts.object_name) ) elif hasattr(value, "_meta"): self.check_query_object_type(value, opts, field) elif hasattr(value, "__iter__"): for v in value: self.check_query_object_type(v, opts, field) def check_filterable(self, expression): """Raise an error if expression cannot be used in a WHERE clause.""" if hasattr(expression, "resolve_expression") and not getattr( expression, "filterable", True ): raise NotSupportedError( expression.__class__.__name__ + " is disallowed in the filter " "clause." ) if hasattr(expression, "get_source_expressions"): for expr in expression.get_source_expressions(): self.check_filterable(expr) def build_lookup(self, lookups, lhs, rhs): """ 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 is the default lookup if one isn't given. *transforms, lookup_name = lookups or ["exact"] for name in transforms: lhs = self.try_transform(lhs, name) # First try get_lookup() so that the lookup takes precedence if the lhs # supports both transform and lookup for the name. lookup_class = lhs.get_lookup(lookup_name) if not lookup_class: # A lookup wasn't found. Try to interpret the name as a transform # and do an Exact lookup against it. lhs = self.try_transform(lhs, lookup_name) lookup_name = "exact" lookup_class = lhs.get_lookup(lookup_name) if not lookup_class: return lookup = lookup_class(lhs, rhs) # Interpret '__exact=None' as the sql 'is NULL'; otherwise, reject all # uses of None as a query value unless the lookup supports it. if lookup.rhs is None and not lookup.can_use_none_as_rhs: if lookup_name not in ("exact", "iexact"): raise ValueError("Cannot use None as a query value") return lhs.get_lookup("isnull")(lhs, True) # For Oracle '' is equivalent to null. The check must be done at this # stage because join promotion can't be done in the compiler. Using # DEFAULT_DB_ALIAS isn't nice but it's the best that can be done here. # A similar thing is done in is_nullable(), too. if ( lookup_name == "exact" and lookup.rhs == "" and connections[DEFAULT_DB_ALIAS].features.interprets_empty_strings_as_nulls ): return lhs.get_lookup("isnull")(lhs, True) return lookup def try_transform(self, lhs, name): """ Helper method for build_lookup(). Try to fetch and initialize a transform for name parameter from lhs. """ transform_class = lhs.get_transform(name) if transform_class: return transform_class(lhs) else: output_field = lhs.output_field.__class__ suggested_lookups = difflib.get_close_matches( name, lhs.output_field.get_lookups() ) if suggested_lookups: suggestion = ", perhaps you meant %s?" % " or ".join(suggested_lookups) else: suggestion = "." raise FieldError( "Unsupported lookup '%s' for %s or join on the field not " "permitted%s" % (name, output_field.__name__, suggestion) ) def build_filter( self, filter_expr, branch_negated=False, current_negated=False, can_reuse=None, allow_joins=True, split_subq=True, reuse_with_filtered_relation=False, check_filterable=True, summarize=False, ): """ 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. """ if isinstance(filter_expr, dict): raise FieldError("Cannot parse keyword query as dict") if isinstance(filter_expr, Q): return self._add_q( filter_expr, branch_negated=branch_negated, current_negated=current_negated, used_aliases=can_reuse, allow_joins=allow_joins, split_subq=split_subq, check_filterable=check_filterable, summarize=summarize, ) if hasattr(filter_expr, "resolve_expression"): if not getattr(filter_expr, "conditional", False): raise TypeError("Cannot filter against a non-conditional expression.") condition = filter_expr.resolve_expression( self, allow_joins=allow_joins, summarize=summarize ) if not isinstance(condition, Lookup): condition = self.build_lookup(["exact"], condition, True) return WhereNode([condition], connector=AND), [] arg, value = filter_expr if not arg: raise FieldError("Cannot parse keyword query %r" % arg) lookups, parts, reffed_expression = self.solve_lookup_type(arg, summarize) if check_filterable: self.check_filterable(reffed_expression) if not allow_joins and len(parts) > 1: raise FieldError("Joined field references are not permitted in this query") pre_joins = self.alias_refcount.copy() value = self.resolve_lookup_value(value, can_reuse, allow_joins, summarize) used_joins = { k for k, v in self.alias_refcount.items() if v > pre_joins.get(k, 0) } if check_filterable: self.check_filterable(value) if reffed_expression: condition = self.build_lookup(lookups, reffed_expression, value) return WhereNode([condition], connector=AND), [] opts = self.get_meta() alias = self.get_initial_alias() allow_many = not branch_negated or not split_subq try: join_info = self.setup_joins( parts, opts, alias, can_reuse=can_reuse, allow_many=allow_many, reuse_with_filtered_relation=reuse_with_filtered_relation, ) # Prevent iterator from being consumed by check_related_objects() if isinstance(value, Iterator): value = list(value) self.check_related_objects(join_info.final_field, value, join_info.opts) # split_exclude() needs to know which joins were generated for the # lookup parts self._lookup_joins = join_info.joins except MultiJoin as e: return self.split_exclude(filter_expr, can_reuse, e.names_with_path) # Update used_joins before trimming since they are reused to determine # which joins could be later promoted to INNER. used_joins.update(join_info.joins) targets, alias, join_list = self.trim_joins( join_info.targets, join_info.joins, join_info.path ) if can_reuse is not None: can_reuse.update(join_list) if join_info.final_field.is_relation: if len(targets) == 1: col = self._get_col(targets[0], join_info.final_field, alias) else: col = MultiColSource( alias, targets, join_info.targets, join_info.final_field ) else: col = self._get_col(targets[0], join_info.final_field, alias) condition = self.build_lookup(lookups, col, value) lookup_type = condition.lookup_name clause = WhereNode([condition], connector=AND) require_outer = ( lookup_type == "isnull" and condition.rhs is True and not current_negated ) if ( current_negated and (lookup_type != "isnull" or condition.rhs is False) and condition.rhs is not None ): require_outer = True if lookup_type != "isnull": # The condition added here will be SQL like this: # NOT (col IS NOT NULL), where the first NOT is added in # upper layers of code. The reason for addition is that if col # is null, then col != someval will result in SQL "unknown" # which isn't the same as in Python. The Python None handling # is wanted, and it can be gotten by # (col IS NULL OR col != someval) # <=> # NOT (col IS NOT NULL AND col = someval). if ( self.is_nullable(targets[0]) or self.alias_map[join_list[-1]].join_type == LOUTER ): lookup_class = targets[0].get_lookup("isnull") col = self._get_col(targets[0], join_info.targets[0], alias) clause.add(lookup_class(col, False), AND) # If someval is a nullable column, someval IS NOT NULL is # added. if isinstance(value, Col) and self.is_nullable(value.target): lookup_class = value.target.get_lookup("isnull") clause.add(lookup_class(value, False), AND) return clause, used_joins if not require_outer else () def add_filter(self, filter_lhs, filter_rhs): self.add_q(Q((filter_lhs, filter_rhs))) def add_q(self, q_object): """ A preprocessor for the internal _add_q(). Responsible for doing final join promotion. """ # For join promotion this case is doing an AND for the added q_object # and existing conditions. So, any existing inner join forces the join # type to remain inner. Existing outer joins can however be demoted. # (Consider case where rel_a is LOUTER and rel_a__col=1 is added - if # rel_a doesn't produce any rows, then the whole condition must fail. # So, demotion is OK. existing_inner = { a for a in self.alias_map if self.alias_map[a].join_type == INNER } clause, _ = self._add_q(q_object, self.used_aliases) if clause: self.where.add(clause, AND) self.demote_joins(existing_inner) def build_where(self, filter_expr): return self.build_filter(filter_expr, allow_joins=False)[0] def clear_where(self): self.where = WhereNode() def _add_q( self, q_object, used_aliases, branch_negated=False, current_negated=False, allow_joins=True, split_subq=True, check_filterable=True, summarize=False, ): """Add a Q-object to the current filter.""" connector = q_object.connector current_negated ^= q_object.negated branch_negated = branch_negated or q_object.negated target_clause = WhereNode(connector=connector, negated=q_object.negated) joinpromoter = JoinPromoter( q_object.connector, len(q_object.children), current_negated ) for child in q_object.children: child_clause, needed_inner = self.build_filter( child, can_reuse=used_aliases, branch_negated=branch_negated, current_negated=current_negated, allow_joins=allow_joins, split_subq=split_subq, check_filterable=check_filterable, summarize=summarize, ) joinpromoter.add_votes(needed_inner) if child_clause: target_clause.add(child_clause, connector) needed_inner = joinpromoter.update_join_types(self) return target_clause, needed_inner def build_filtered_relation_q( self, q_object, reuse, branch_negated=False, current_negated=False ): """Add a FilteredRelation object to the current filter.""" connector = q_object.connector current_negated ^= q_object.negated branch_negated = branch_negated or q_object.negated target_clause = WhereNode(connector=connector, negated=q_object.negated) for child in q_object.children: if isinstance(child, Node): child_clause = self.build_filtered_relation_q( child, reuse=reuse, branch_negated=branch_negated, current_negated=current_negated, ) else: child_clause, _ = self.build_filter( child, can_reuse=reuse, branch_negated=branch_negated, current_negated=current_negated, allow_joins=True, split_subq=False, reuse_with_filtered_relation=True, ) target_clause.add(child_clause, connector) return target_clause def add_filtered_relation(self, filtered_relation, alias): filtered_relation.alias = alias lookups = dict(get_children_from_q(filtered_relation.condition)) relation_lookup_parts, relation_field_parts, _ = self.solve_lookup_type( filtered_relation.relation_name ) if relation_lookup_parts: raise ValueError( "FilteredRelation's relation_name cannot contain lookups " "(got %r)." % filtered_relation.relation_name ) for lookup in chain(lookups): lookup_parts, lookup_field_parts, _ = self.solve_lookup_type(lookup) shift = 2 if not lookup_parts else 1 lookup_field_path = lookup_field_parts[:-shift] for idx, lookup_field_part in enumerate(lookup_field_path): if len(relation_field_parts) > idx: if relation_field_parts[idx] != lookup_field_part: raise ValueError( "FilteredRelation's condition doesn't support " "relations outside the %r (got %r)." % (filtered_relation.relation_name, lookup) ) else: raise ValueError( "FilteredRelation's condition doesn't support nested " "relations deeper than the relation_name (got %r for " "%r)." % (lookup, filtered_relation.relation_name) ) self._filtered_relations[filtered_relation.alias] = filtered_relation def names_to_path(self, names, opts, allow_many=True, fail_on_missing=False): """ 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). """ path, names_with_path = [], [] for pos, name in enumerate(names): cur_names_with_path = (name, []) if name == "pk": name = opts.pk.name field = None filtered_relation = None try: if opts is None: raise FieldDoesNotExist field = opts.get_field(name) except FieldDoesNotExist: if name in self.annotation_select: field = self.annotation_select[name].output_field elif name in self._filtered_relations and pos == 0: filtered_relation = self._filtered_relations[name] if LOOKUP_SEP in filtered_relation.relation_name: parts = filtered_relation.relation_name.split(LOOKUP_SEP) filtered_relation_path, field, _, _ = self.names_to_path( parts, opts, allow_many, fail_on_missing, ) path.extend(filtered_relation_path[:-1]) else: field = opts.get_field(filtered_relation.relation_name) if field is not None: # Fields that contain one-to-many relations with a generic # model (like a GenericForeignKey) cannot generate reverse # relations and therefore cannot be used for reverse querying. if field.is_relation and not field.related_model: raise FieldError( "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." % name ) try: model = field.model._meta.concrete_model except AttributeError: # QuerySet.annotate() may introduce fields that aren't # attached to a model. model = None else: # We didn't find the current field, so move position back # one step. pos -= 1 if pos == -1 or fail_on_missing: available = sorted( [ *get_field_names_from_opts(opts), *self.annotation_select, *self._filtered_relations, ] ) raise FieldError( "Cannot resolve keyword '%s' into field. " "Choices are: %s" % (name, ", ".join(available)) ) break # Check if we need any joins for concrete inheritance cases (the # field lives in parent, but we are currently in one of its # children) if opts is not None and model is not opts.model: path_to_parent = opts.get_path_to_parent(model) if path_to_parent: path.extend(path_to_parent) cur_names_with_path[1].extend(path_to_parent) opts = path_to_parent[-1].to_opts if hasattr(field, "path_infos"): if filtered_relation: pathinfos = field.get_path_info(filtered_relation) else: pathinfos = field.path_infos if not allow_many: for inner_pos, p in enumerate(pathinfos): if p.m2m: cur_names_with_path[1].extend(pathinfos[0 : inner_pos + 1]) names_with_path.append(cur_names_with_path) raise MultiJoin(pos + 1, names_with_path) last = pathinfos[-1] path.extend(pathinfos) final_field = last.join_field opts = last.to_opts targets = last.target_fields cur_names_with_path[1].extend(pathinfos) names_with_path.append(cur_names_with_path) else: # Local non-relational field. final_field = field targets = (field,) if fail_on_missing and pos + 1 != len(names): raise FieldError( "Cannot resolve keyword %r into field. Join on '%s'" " not permitted." % (names[pos + 1], name) ) break return path, final_field, targets, names[pos + 1 :] def setup_joins( self, names, opts, alias, can_reuse=None, allow_many=True, reuse_with_filtered_relation=False, ): """ 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). """ joins = [alias] # The transform can't be applied yet, as joins must be trimmed later. # To avoid making every caller of this method look up transforms # directly, compute transforms here and create a partial that converts # fields to the appropriate wrapped version. def final_transformer(field, alias): if not self.alias_cols: alias = None return field.get_col(alias) # Try resolving all the names as fields first. If there's an error, # treat trailing names as lookups until a field can be resolved. last_field_exception = None for pivot in range(len(names), 0, -1): try: path, final_field, targets, rest = self.names_to_path( names[:pivot], opts, allow_many, fail_on_missing=True, ) except FieldError as exc: if pivot == 1: # The first item cannot be a lookup, so it's safe # to raise the field error here. raise else: last_field_exception = exc else: # The transforms are the remaining items that couldn't be # resolved into fields. transforms = names[pivot:] break for name in transforms: def transform(field, alias, *, name, previous): try: wrapped = previous(field, alias) return self.try_transform(wrapped, name) except FieldError: # FieldError is raised if the transform doesn't exist. if isinstance(final_field, Field) and last_field_exception: raise last_field_exception else: raise final_transformer = functools.partial( transform, name=name, previous=final_transformer ) final_transformer.has_transforms = True # Then, add the path to the query's joins. Note that we can't trim # joins at this stage - we will need the information about join type # of the trimmed joins. for join in path: if join.filtered_relation: filtered_relation = join.filtered_relation.clone() table_alias = filtered_relation.alias else: filtered_relation = None table_alias = None opts = join.to_opts if join.direct: nullable = self.is_nullable(join.join_field) else: nullable = True connection = self.join_class( opts.db_table, alias, table_alias, INNER, join.join_field, nullable, filtered_relation=filtered_relation, ) reuse = can_reuse if join.m2m or reuse_with_filtered_relation else None alias = self.join( connection, reuse=reuse, reuse_with_filtered_relation=reuse_with_filtered_relation, ) joins.append(alias) if filtered_relation: filtered_relation.path = joins[:] return JoinInfo(final_field, targets, opts, joins, path, final_transformer) def trim_joins(self, targets, joins, path): """ 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. """ joins = joins[:] for pos, info in enumerate(reversed(path)): if len(joins) == 1 or not info.direct: break if info.filtered_relation: break join_targets = {t.column for t in info.join_field.foreign_related_fields} cur_targets = {t.column for t in targets} if not cur_targets.issubset(join_targets): break targets_dict = { r[1].column: r[0] for r in info.join_field.related_fields if r[1].column in cur_targets } targets = tuple(targets_dict[t.column] for t in targets) self.unref_alias(joins.pop()) return targets, joins[-1], joins @classmethod def _gen_cols(cls, exprs, include_external=False, resolve_refs=True): for expr in exprs: if isinstance(expr, Col): yield expr elif include_external and callable( getattr(expr, "get_external_cols", None) ): yield from expr.get_external_cols() elif hasattr(expr, "get_source_expressions"): if not resolve_refs and isinstance(expr, Ref): continue yield from cls._gen_cols( expr.get_source_expressions(), include_external=include_external, resolve_refs=resolve_refs, ) @classmethod def _gen_col_aliases(cls, exprs): yield from (expr.alias for expr in cls._gen_cols(exprs)) def resolve_ref(self, name, allow_joins=True, reuse=None, summarize=False): annotation = self.annotations.get(name) if annotation is not None: if not allow_joins: for alias in self._gen_col_aliases([annotation]): if isinstance(self.alias_map[alias], Join): raise FieldError( "Joined field references are not permitted in this query" ) if summarize: # Summarize currently means we are doing an aggregate() query # which is executed as a wrapped subquery if any of the # aggregate() elements reference an existing annotation. In # that case we need to return a Ref to the subquery's annotation. if name not in self.annotation_select: raise FieldError( "Cannot aggregate over the '%s' alias. Use annotate() " "to promote it." % name ) return Ref(name, self.annotation_select[name]) else: return annotation else: field_list = name.split(LOOKUP_SEP) annotation = self.annotations.get(field_list[0]) if annotation is not None: for transform in field_list[1:]: annotation = self.try_transform(annotation, transform) return annotation join_info = self.setup_joins( field_list, self.get_meta(), self.get_initial_alias(), can_reuse=reuse ) targets, final_alias, join_list = self.trim_joins( join_info.targets, join_info.joins, join_info.path ) if not allow_joins and len(join_list) > 1: raise FieldError( "Joined field references are not permitted in this query" ) if len(targets) > 1: raise FieldError( "Referencing multicolumn fields with F() objects isn't supported" ) # Verify that the last lookup in name is a field or a transform: # transform_function() raises FieldError if not. transform = join_info.transform_function(targets[0], final_alias) if reuse is not None: reuse.update(join_list) return transform def split_exclude(self, filter_expr, can_reuse, names_with_path): """ 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 ) """ # Generate the inner query. query = self.__class__(self.model) query._filtered_relations = self._filtered_relations filter_lhs, filter_rhs = filter_expr if isinstance(filter_rhs, OuterRef): filter_rhs = OuterRef(filter_rhs) elif isinstance(filter_rhs, F): filter_rhs = OuterRef(filter_rhs.name) query.add_filter(filter_lhs, filter_rhs) query.clear_ordering(force=True) # Try to have as simple as possible subquery -> trim leading joins from # the subquery. trimmed_prefix, contains_louter = query.trim_start(names_with_path) col = query.select[0] select_field = col.target alias = col.alias if alias in can_reuse: pk = select_field.model._meta.pk # Need to add a restriction so that outer query's filters are in effect for # the subquery, too. query.bump_prefix(self) lookup_class = select_field.get_lookup("exact") # Note that the query.select[0].alias is different from alias # due to bump_prefix above. lookup = lookup_class(pk.get_col(query.select[0].alias), pk.get_col(alias)) query.where.add(lookup, AND) query.external_aliases[alias] = True lookup_class = select_field.get_lookup("exact") lookup = lookup_class(col, ResolvedOuterRef(trimmed_prefix)) query.where.add(lookup, AND) condition, needed_inner = self.build_filter(Exists(query)) if contains_louter: or_null_condition, _ = self.build_filter( ("%s__isnull" % trimmed_prefix, True), current_negated=True, branch_negated=True, can_reuse=can_reuse, ) condition.add(or_null_condition, OR) # Note that the end result will be: # (outercol NOT IN innerq AND outercol IS NOT NULL) OR outercol IS NULL. # This might look crazy but due to how IN works, this seems to be # correct. If the IS NOT NULL check is removed then outercol NOT # IN will return UNKNOWN. If the IS NULL check is removed, then if # outercol IS NULL we will not match the row. return condition, needed_inner def set_empty(self): self.where.add(NothingNode(), AND) for query in self.combined_queries: query.set_empty() def is_empty(self): return any(isinstance(c, NothingNode) for c in self.where.children) def set_limits(self, low=None, high=None): """ 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. """ if high is not None: if self.high_mark is not None: self.high_mark = min(self.high_mark, self.low_mark + high) else: self.high_mark = self.low_mark + high if low is not None: if self.high_mark is not None: self.low_mark = min(self.high_mark, self.low_mark + low) else: self.low_mark = self.low_mark + low if self.low_mark == self.high_mark: self.set_empty() def clear_limits(self): """Clear any existing limits.""" self.low_mark, self.high_mark = 0, None @property def is_sliced(self): return self.low_mark != 0 or self.high_mark is not None def has_limit_one(self): return self.high_mark is not None and (self.high_mark - self.low_mark) == 1 def can_filter(self): """ Return True if adding filters to this instance is still possible. Typically, this means no limits or offsets have been put on the results. """ return not self.is_sliced def clear_select_clause(self): """Remove all fields from SELECT clause.""" self.select = () self.default_cols = False self.select_related = False self.set_extra_mask(()) self.set_annotation_mask(()) def clear_select_fields(self): """ Clear the list of fields to select (but not extra_select columns). Some queryset types completely replace any existing list of select columns. """ self.select = () self.values_select = () def add_select_col(self, col, name): self.select += (col,) self.values_select += (name,) def set_select(self, cols): self.default_cols = False self.select = tuple(cols) def add_distinct_fields(self, *field_names): """ Add and resolve the given fields to the query's "distinct on" clause. """ self.distinct_fields = field_names self.distinct = True def add_fields(self, field_names, allow_m2m=True): """ Add the given (model) fields to the select set. Add the field names in the order specified. """ alias = self.get_initial_alias() opts = self.get_meta() try: cols = [] for name in field_names: # Join promotion note - we must not remove any rows here, so # if there is no existing joins, use outer join. join_info = self.setup_joins( name.split(LOOKUP_SEP), opts, alias, allow_many=allow_m2m ) targets, final_alias, joins = self.trim_joins( join_info.targets, join_info.joins, join_info.path, ) for target in targets: cols.append(join_info.transform_function(target, final_alias)) if cols: self.set_select(cols) except MultiJoin: raise FieldError("Invalid field name: '%s'" % name) except FieldError: if LOOKUP_SEP in name: # For lookups spanning over relationships, show the error # from the model on which the lookup failed. raise elif name in self.annotations: raise FieldError( "Cannot select the '%s' alias. Use annotate() to promote " "it." % name ) else: names = sorted( [ *get_field_names_from_opts(opts), *self.extra, *self.annotation_select, *self._filtered_relations, ] ) raise FieldError( "Cannot resolve keyword %r into field. " "Choices are: %s" % (name, ", ".join(names)) ) def add_ordering(self, *ordering): """ 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. """ errors = [] for item in ordering: if isinstance(item, str): if item == "?": continue if item.startswith("-"): item = item[1:] if item in self.annotations: continue if self.extra and item in self.extra: continue # names_to_path() validates the lookup. A descriptive # FieldError will be raise if it's not. self.names_to_path(item.split(LOOKUP_SEP), self.model._meta) elif not hasattr(item, "resolve_expression"): errors.append(item) if getattr(item, "contains_aggregate", False): raise FieldError( "Using an aggregate in order_by() without also including " "it in annotate() is not allowed: %s" % item ) if errors: raise FieldError("Invalid order_by arguments: %s" % errors) if ordering: self.order_by += ordering else: self.default_ordering = False def clear_ordering(self, force=False, clear_default=True): """ 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). """ if not force and ( self.is_sliced or self.distinct_fields or self.select_for_update ): return self.order_by = () self.extra_order_by = () if clear_default: self.default_ordering = False def set_group_by(self, allow_aliases=True): """ 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. """ if allow_aliases and self.values_select: # If grouping by aliases is allowed assign selected value aliases # by moving them to annotations. group_by_annotations = {} values_select = {} for alias, expr in zip(self.values_select, self.select): if isinstance(expr, Col): values_select[alias] = expr else: group_by_annotations[alias] = expr self.annotations = {**group_by_annotations, **self.annotations} self.append_annotation_mask(group_by_annotations) self.select = tuple(values_select.values()) self.values_select = tuple(values_select) group_by = list(self.select) for alias, annotation in self.annotation_select.items(): if not (group_by_cols := annotation.get_group_by_cols()): continue if allow_aliases and not annotation.contains_aggregate: group_by.append(Ref(alias, annotation)) else: group_by.extend(group_by_cols) self.group_by = tuple(group_by) def add_select_related(self, fields): """ 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). """ if isinstance(self.select_related, bool): field_dict = {} else: field_dict = self.select_related for field in fields: d = field_dict for part in field.split(LOOKUP_SEP): d = d.setdefault(part, {}) self.select_related = field_dict def add_extra(self, select, select_params, where, params, tables, order_by): """ Add data to the various extra_* attributes for user-created additions to the query. """ if select: # We need to pair any placeholder markers in the 'select' # dictionary with their parameters in 'select_params' so that # subsequent updates to the select dictionary also adjust the # parameters appropriately. select_pairs = {} if select_params: param_iter = iter(select_params) else: param_iter = iter([]) for name, entry in select.items(): self.check_alias(name) entry = str(entry) entry_params = [] pos = entry.find("%s") while pos != -1: if pos == 0 or entry[pos - 1] != "%": entry_params.append(next(param_iter)) pos = entry.find("%s", pos + 2) select_pairs[name] = (entry, entry_params) self.extra.update(select_pairs) if where or params: self.where.add(ExtraWhere(where, params), AND) if tables: self.extra_tables += tuple(tables) if order_by: self.extra_order_by = order_by def clear_deferred_loading(self): """Remove any fields from the deferred loading set.""" self.deferred_loading = (frozenset(), True) def add_deferred_loading(self, field_names): """ 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). """ # Fields on related models are stored in the literal double-underscore # format, so that we can use a set datastructure. We do the foo__bar # splitting and handling when computing the SQL column names (as part of # get_columns()). existing, defer = self.deferred_loading if defer: # Add to existing deferred names. self.deferred_loading = existing.union(field_names), True else: # Remove names from the set of any existing "immediate load" names. if new_existing := existing.difference(field_names): self.deferred_loading = new_existing, False else: self.clear_deferred_loading() if new_only := set(field_names).difference(existing): self.deferred_loading = new_only, True def add_immediate_loading(self, field_names): """ 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.) """ existing, defer = self.deferred_loading field_names = set(field_names) if "pk" in field_names: field_names.remove("pk") field_names.add(self.get_meta().pk.name) if defer: # Remove any existing deferred names from the current set before # setting the new names. self.deferred_loading = field_names.difference(existing), False else: # Replace any existing "immediate load" field names. self.deferred_loading = frozenset(field_names), False def set_annotation_mask(self, names): """Set the mask of annotations that will be returned by the SELECT.""" if names is None: self.annotation_select_mask = None else: self.annotation_select_mask = set(names) self._annotation_select_cache = None def append_annotation_mask(self, names): if self.annotation_select_mask is not None: self.set_annotation_mask(self.annotation_select_mask.union(names)) def set_extra_mask(self, names): """ 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. """ if names is None: self.extra_select_mask = None else: self.extra_select_mask = set(names) self._extra_select_cache = None def set_values(self, fields): self.select_related = False self.clear_deferred_loading() self.clear_select_fields() self.has_select_fields = True if fields: field_names = [] extra_names = [] annotation_names = [] if not self.extra and not self.annotations: # Shortcut - if there are no extra or annotations, then # the values() clause must be just field names. field_names = list(fields) else: self.default_cols = False for f in fields: if f in self.extra_select: extra_names.append(f) elif f in self.annotation_select: annotation_names.append(f) else: field_names.append(f) self.set_extra_mask(extra_names) self.set_annotation_mask(annotation_names) selected = frozenset(field_names + extra_names + annotation_names) else: field_names = [f.attname for f in self.model._meta.concrete_fields] selected = frozenset(field_names) # Selected annotations must be known before setting the GROUP BY # clause. if self.group_by is True: self.add_fields( (f.attname for f in self.model._meta.concrete_fields), False ) # Disable GROUP BY aliases to avoid orphaning references to the # SELECT clause which is about to be cleared. self.set_group_by(allow_aliases=False) self.clear_select_fields() elif self.group_by: # Resolve GROUP BY annotation references if they are not part of # the selected fields anymore. group_by = [] for expr in self.group_by: if isinstance(expr, Ref) and expr.refs not in selected: expr = self.annotations[expr.refs] group_by.append(expr) self.group_by = tuple(group_by) self.values_select = tuple(field_names) self.add_fields(field_names, True) @property def annotation_select(self): """ Return the dictionary of aggregate columns that are not masked and should be used in the SELECT clause. Cache this result for performance. """ if self._annotation_select_cache is not None: return self._annotation_select_cache elif not self.annotations: return {} elif self.annotation_select_mask is not None: self._annotation_select_cache = { k: v for k, v in self.annotations.items() if k in self.annotation_select_mask } return self._annotation_select_cache else: return self.annotations @property def extra_select(self): if self._extra_select_cache is not None: return self._extra_select_cache if not self.extra: return {} elif self.extra_select_mask is not None: self._extra_select_cache = { k: v for k, v in self.extra.items() if k in self.extra_select_mask } return self._extra_select_cache else: return self.extra def trim_start(self, names_with_path): """ 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. _""" all_paths = [] for _, paths in names_with_path: all_paths.extend(paths) contains_louter = False # Trim and operate only on tables that were generated for # the lookup part of the query. That is, avoid trimming # joins generated for F() expressions. lookup_tables = [ t for t in self.alias_map if t in self._lookup_joins or t == self.base_table ] for trimmed_paths, path in enumerate(all_paths): if path.m2m: break if self.alias_map[lookup_tables[trimmed_paths + 1]].join_type == LOUTER: contains_louter = True alias = lookup_tables[trimmed_paths] self.unref_alias(alias) # The path.join_field is a Rel, lets get the other side's field join_field = path.join_field.field # Build the filter prefix. paths_in_prefix = trimmed_paths trimmed_prefix = [] for name, path in names_with_path: if paths_in_prefix - len(path) < 0: break trimmed_prefix.append(name) paths_in_prefix -= len(path) trimmed_prefix.append(join_field.foreign_related_fields[0].name) trimmed_prefix = LOOKUP_SEP.join(trimmed_prefix) # Lets still see if we can trim the first join from the inner query # (that is, self). We can't do this for: # - LEFT JOINs because we would miss those rows that have nothing on # the outer side, # - INNER JOINs from filtered relations because we would miss their # filters. first_join = self.alias_map[lookup_tables[trimmed_paths + 1]] if first_join.join_type != LOUTER and not first_join.filtered_relation: select_fields = [r[0] for r in join_field.related_fields] select_alias = lookup_tables[trimmed_paths + 1] self.unref_alias(lookup_tables[trimmed_paths]) extra_restriction = join_field.get_extra_restriction( None, lookup_tables[trimmed_paths + 1] ) if extra_restriction: self.where.add(extra_restriction, AND) else: # TODO: It might be possible to trim more joins from the start of the # inner query if it happens to have a longer join chain containing the # values in select_fields. Lets punt this one for now. select_fields = [r[1] for r in join_field.related_fields] select_alias = lookup_tables[trimmed_paths] # The found starting point is likely a join_class instead of a # base_table_class reference. But the first entry in the query's FROM # clause must not be a JOIN. for table in self.alias_map: if self.alias_refcount[table] > 0: self.alias_map[table] = self.base_table_class( self.alias_map[table].table_name, table, ) break self.set_select([f.get_col(select_alias) for f in select_fields]) return trimmed_prefix, contains_louter def is_nullable(self, field): """ 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. """ # We need to use DEFAULT_DB_ALIAS here, as QuerySet does not have # (nor should it have) knowledge of which connection is going to be # used. The proper fix would be to defer all decisions where # is_nullable() is needed to the compiler stage, but that is not easy # to do currently. return field.null or ( field.empty_strings_allowed and connections[DEFAULT_DB_ALIAS].features.interprets_empty_strings_as_nulls ) def get_order_dir(field, default="ASC"): """ 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. """ dirn = ORDER_DIR[default] if field[0] == "-": return field[1:], dirn[1] return field, dirn[0] class JoinPromoter: """ A class to abstract away join promotion problems for complex filter conditions. """ def __init__(self, connector, num_children, negated): self.connector = connector self.negated = negated if self.negated: if connector == AND: self.effective_connector = OR else: self.effective_connector = AND else: self.effective_connector = self.connector self.num_children = num_children # Maps of table alias to how many times it is seen as required for # inner and/or outer joins. self.votes = Counter() def __repr__(self): return ( f"{self.__class__.__qualname__}(connector={self.connector!r}, " f"num_children={self.num_children!r}, negated={self.negated!r})" ) def add_votes(self, votes): """ Add single vote per item to self.votes. Parameter can be any iterable. """ self.votes.update(votes) def update_join_types(self, query): """ 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. """ to_promote = set() to_demote = set() # The effective_connector is used so that NOT (a AND b) is treated # similarly to (a OR b) for join promotion. for table, votes in self.votes.items(): # We must use outer joins in OR case when the join isn't contained # in all of the joins. Otherwise the INNER JOIN itself could remove # valid results. Consider the case where a model with rel_a and # rel_b relations is queried with rel_a__col=1 | rel_b__col=2. Now, # if rel_a join doesn't produce any results is null (for example # reverse foreign key or null value in direct foreign key), and # there is a matching row in rel_b with col=2, then an INNER join # to rel_a would remove a valid match from the query. So, we need # to promote any existing INNER to LOUTER (it is possible this # promotion in turn will be demoted later on). if self.effective_connector == OR and votes < self.num_children: to_promote.add(table) # If connector is AND and there is a filter that can match only # when there is a joinable row, then use INNER. For example, in # rel_a__col=1 & rel_b__col=2, if either of the rels produce NULL # as join output, then the col=1 or col=2 can't match (as # NULL=anything is always false). # For the OR case, if all children voted for a join to be inner, # then we can use INNER for the join. For example: # (rel_a__col__icontains=Alex | rel_a__col__icontains=Russell) # then if rel_a doesn't produce any rows, the whole condition # can't match. Hence we can safely use INNER join. if self.effective_connector == AND or ( self.effective_connector == OR and votes == self.num_children ): to_demote.add(table) # Finally, what happens in cases where we have: # (rel_a__col=1|rel_b__col=2) & rel_a__col__gte=0 # Now, we first generate the OR clause, and promote joins for it # in the first if branch above. Both rel_a and rel_b are promoted # to LOUTER joins. After that we do the AND case. The OR case # voted no inner joins but the rel_a__col__gte=0 votes inner join # for rel_a. We demote it back to INNER join (in AND case a single # vote is enough). The demotion is OK, if rel_a doesn't produce # rows, then the rel_a__col__gte=0 clause can't be true, and thus # the whole clause must be false. So, it is safe to use INNER # join. # Note that in this example we could just as well have the __gte # clause and the OR clause swapped. Or we could replace the __gte # clause with an OR clause containing rel_a__col=1|rel_a__col=2, # and again we could safely demote to INNER. query.promote_joins(to_promote) query.demote_joins(to_demote) return to_demote compiler.py 0000644 00000256054 15030124302 0006732 0 ustar 00 import collections import json import re from functools import partial from itertools import chain from django.core.exceptions import EmptyResultSet, FieldError, FullResultSet from django.db import DatabaseError, NotSupportedError from django.db.models.constants import LOOKUP_SEP from django.db.models.expressions import F, OrderBy, RawSQL, Ref, Value from django.db.models.functions import Cast, Random from django.db.models.lookups import Lookup from django.db.models.query_utils import select_related_descend from django.db.models.sql.constants import ( CURSOR, GET_ITERATOR_CHUNK_SIZE, MULTI, NO_RESULTS, ORDER_DIR, SINGLE, ) from django.db.models.sql.query import Query, get_order_dir from django.db.models.sql.where import AND from django.db.transaction import TransactionManagementError from django.utils.functional import cached_property from django.utils.hashable import make_hashable from django.utils.regex_helper import _lazy_re_compile class PositionRef(Ref): def __init__(self, ordinal, refs, source): self.ordinal = ordinal super().__init__(refs, source) def as_sql(self, compiler, connection): return str(self.ordinal), () class SQLCompiler: # Multiline ordering SQL clause may appear from RawSQL. ordering_parts = _lazy_re_compile( r"^(.*)\s(?:ASC|DESC).*", re.MULTILINE | re.DOTALL, ) def __init__(self, query, connection, using, elide_empty=True): self.query = query self.connection = connection self.using = using # Some queries, e.g. coalesced aggregation, need to be executed even if # they would return an empty result set. self.elide_empty = elide_empty self.quote_cache = {"*": "*"} # The select, klass_info, and annotations are needed by QuerySet.iterator() # these are set as a side-effect of executing the query. Note that we calculate # separately a list of extra select columns needed for grammatical correctness # of the query, but these columns are not included in self.select. self.select = None self.annotation_col_map = None self.klass_info = None self._meta_ordering = None def __repr__(self): return ( f"<{self.__class__.__qualname__} " f"model={self.query.model.__qualname__} " f"connection={self.connection!r} using={self.using!r}>" ) def setup_query(self, with_col_aliases=False): if all(self.query.alias_refcount[a] == 0 for a in self.query.alias_map): self.query.get_initial_alias() self.select, self.klass_info, self.annotation_col_map = self.get_select( with_col_aliases=with_col_aliases, ) self.col_count = len(self.select) def pre_sql_setup(self, with_col_aliases=False): """ Do any necessary class setup immediately prior to producing SQL. This is for things that can't necessarily be done in __init__ because we might not have all the pieces in place at that time. """ self.setup_query(with_col_aliases=with_col_aliases) order_by = self.get_order_by() self.where, self.having, self.qualify = self.query.where.split_having_qualify( must_group_by=self.query.group_by is not None ) extra_select = self.get_extra_select(order_by, self.select) self.has_extra_select = bool(extra_select) group_by = self.get_group_by(self.select + extra_select, order_by) return extra_select, order_by, group_by def get_group_by(self, select, order_by): """ Return a list of 2-tuples of form (sql, params). The logic of what exactly the GROUP BY clause contains is hard to describe in other words than "if it passes the test suite, then it is correct". """ # Some examples: # SomeModel.objects.annotate(Count('somecol')) # GROUP BY: all fields of the model # # SomeModel.objects.values('name').annotate(Count('somecol')) # GROUP BY: name # # SomeModel.objects.annotate(Count('somecol')).values('name') # GROUP BY: all cols of the model # # SomeModel.objects.values('name', 'pk') # .annotate(Count('somecol')).values('pk') # GROUP BY: name, pk # # SomeModel.objects.values('name').annotate(Count('somecol')).values('pk') # GROUP BY: name, pk # # In fact, the self.query.group_by is the minimal set to GROUP BY. It # can't be ever restricted to a smaller set, but additional columns in # HAVING, ORDER BY, and SELECT clauses are added to it. Unfortunately # the end result is that it is impossible to force the query to have # a chosen GROUP BY clause - you can almost do this by using the form: # .values(*wanted_cols).annotate(AnAggregate()) # but any later annotations, extra selects, values calls that # refer some column outside of the wanted_cols, order_by, or even # filter calls can alter the GROUP BY clause. # The query.group_by is either None (no GROUP BY at all), True # (group by select fields), or a list of expressions to be added # to the group by. if self.query.group_by is None: return [] expressions = [] group_by_refs = set() if self.query.group_by is not True: # If the group by is set to a list (by .values() call most likely), # then we need to add everything in it to the GROUP BY clause. # Backwards compatibility hack for setting query.group_by. Remove # when we have public API way of forcing the GROUP BY clause. # Converts string references to expressions. for expr in self.query.group_by: if not hasattr(expr, "as_sql"): expr = self.query.resolve_ref(expr) if isinstance(expr, Ref): if expr.refs not in group_by_refs: group_by_refs.add(expr.refs) expressions.append(expr.source) else: expressions.append(expr) # Note that even if the group_by is set, it is only the minimal # set to group by. So, we need to add cols in select, order_by, and # having into the select in any case. selected_expr_indices = {} for index, (expr, _, alias) in enumerate(select, start=1): if alias: selected_expr_indices[expr] = index # Skip members of the select clause that are already explicitly # grouped against. if alias in group_by_refs: continue expressions.extend(expr.get_group_by_cols()) if not self._meta_ordering: for expr, (sql, params, is_ref) in order_by: # Skip references to the SELECT clause, as all expressions in # the SELECT clause are already part of the GROUP BY. if not is_ref: expressions.extend(expr.get_group_by_cols()) having_group_by = self.having.get_group_by_cols() if self.having else () for expr in having_group_by: expressions.append(expr) result = [] seen = set() expressions = self.collapse_group_by(expressions, having_group_by) allows_group_by_select_index = ( self.connection.features.allows_group_by_select_index ) for expr in expressions: try: sql, params = self.compile(expr) except (EmptyResultSet, FullResultSet): continue if ( allows_group_by_select_index and (select_index := selected_expr_indices.get(expr)) is not None ): sql, params = str(select_index), () else: sql, params = expr.select_format(self, sql, params) params_hash = make_hashable(params) if (sql, params_hash) not in seen: result.append((sql, params)) seen.add((sql, params_hash)) return result def collapse_group_by(self, expressions, having): # If the database supports group by functional dependence reduction, # then the expressions can be reduced to the set of selected table # primary keys as all other columns are functionally dependent on them. if self.connection.features.allows_group_by_selected_pks: # Filter out all expressions associated with a table's primary key # present in the grouped columns. This is done by identifying all # tables that have their primary key included in the grouped # columns and removing non-primary key columns referring to them. # Unmanaged models are excluded because they could be representing # database views on which the optimization might not be allowed. pks = { expr for expr in expressions if ( hasattr(expr, "target") and expr.target.primary_key and self.connection.features.allows_group_by_selected_pks_on_model( expr.target.model ) ) } aliases = {expr.alias for expr in pks} expressions = [ expr for expr in expressions if expr in pks or expr in having or getattr(expr, "alias", None) not in aliases ] return expressions def get_select(self, with_col_aliases=False): """ Return three values: - a list of 3-tuples of (expression, (sql, params), alias) - a klass_info structure, - a dictionary of annotations The (sql, params) is what the expression will produce, and alias is the "AS alias" for the column (possibly None). The klass_info structure contains the following information: - The base model of the query. - Which columns for that model are present in the query (by position of the select clause). - related_klass_infos: [f, klass_info] to descent into The annotations is a dictionary of {'attname': column position} values. """ select = [] klass_info = None annotations = {} select_idx = 0 for alias, (sql, params) in self.query.extra_select.items(): annotations[alias] = select_idx select.append((RawSQL(sql, params), alias)) select_idx += 1 assert not (self.query.select and self.query.default_cols) select_mask = self.query.get_select_mask() if self.query.default_cols: cols = self.get_default_columns(select_mask) else: # self.query.select is a special case. These columns never go to # any model. cols = self.query.select if cols: select_list = [] for col in cols: select_list.append(select_idx) select.append((col, None)) select_idx += 1 klass_info = { "model": self.query.model, "select_fields": select_list, } for alias, annotation in self.query.annotation_select.items(): annotations[alias] = select_idx select.append((annotation, alias)) select_idx += 1 if self.query.select_related: related_klass_infos = self.get_related_selections(select, select_mask) klass_info["related_klass_infos"] = related_klass_infos def get_select_from_parent(klass_info): for ki in klass_info["related_klass_infos"]: if ki["from_parent"]: ki["select_fields"] = ( klass_info["select_fields"] + ki["select_fields"] ) get_select_from_parent(ki) get_select_from_parent(klass_info) ret = [] col_idx = 1 for col, alias in select: try: sql, params = self.compile(col) except EmptyResultSet: empty_result_set_value = getattr( col, "empty_result_set_value", NotImplemented ) if empty_result_set_value is NotImplemented: # Select a predicate that's always False. sql, params = "0", () else: sql, params = self.compile(Value(empty_result_set_value)) except FullResultSet: sql, params = self.compile(Value(True)) else: sql, params = col.select_format(self, sql, params) if alias is None and with_col_aliases: alias = f"col{col_idx}" col_idx += 1 ret.append((col, (sql, params), alias)) return ret, klass_info, annotations def _order_by_pairs(self): if self.query.extra_order_by: ordering = self.query.extra_order_by elif not self.query.default_ordering: ordering = self.query.order_by elif self.query.order_by: ordering = self.query.order_by elif (meta := self.query.get_meta()) and meta.ordering: ordering = meta.ordering self._meta_ordering = ordering else: ordering = [] if self.query.standard_ordering: default_order, _ = ORDER_DIR["ASC"] else: default_order, _ = ORDER_DIR["DESC"] selected_exprs = {} # Avoid computing `selected_exprs` if there is no `ordering` as it's # relatively expensive. if ordering and (select := self.select): for ordinal, (expr, _, alias) in enumerate(select, start=1): pos_expr = PositionRef(ordinal, alias, expr) if alias: selected_exprs[alias] = pos_expr selected_exprs[expr] = pos_expr for field in ordering: if hasattr(field, "resolve_expression"): if isinstance(field, Value): # output_field must be resolved for constants. field = Cast(field, field.output_field) if not isinstance(field, OrderBy): field = field.asc() if not self.query.standard_ordering: field = field.copy() field.reverse_ordering() select_ref = selected_exprs.get(field.expression) if select_ref or ( isinstance(field.expression, F) and (select_ref := selected_exprs.get(field.expression.name)) ): # Emulation of NULLS (FIRST|LAST) cannot be combined with # the usage of ordering by position. if ( field.nulls_first is None and field.nulls_last is None ) or self.connection.features.supports_order_by_nulls_modifier: field = field.copy() field.expression = select_ref # Alias collisions are not possible when dealing with # combined queries so fallback to it if emulation of NULLS # handling is required. elif self.query.combinator: field = field.copy() field.expression = Ref(select_ref.refs, select_ref.source) yield field, select_ref is not None continue if field == "?": # random yield OrderBy(Random()), False continue col, order = get_order_dir(field, default_order) descending = order == "DESC" if select_ref := selected_exprs.get(col): # Reference to expression in SELECT clause yield ( OrderBy( select_ref, descending=descending, ), True, ) continue if col in self.query.annotations: # References to an expression which is masked out of the SELECT # clause. if self.query.combinator and self.select: # Don't use the resolved annotation because other # combinated queries might define it differently. expr = F(col) else: expr = self.query.annotations[col] if isinstance(expr, Value): # output_field must be resolved for constants. expr = Cast(expr, expr.output_field) yield OrderBy(expr, descending=descending), False continue if "." in field: # This came in through an extra(order_by=...) addition. Pass it # on verbatim. table, col = col.split(".", 1) yield ( OrderBy( RawSQL( "%s.%s" % (self.quote_name_unless_alias(table), col), [] ), descending=descending, ), False, ) continue if self.query.extra and col in self.query.extra: if col in self.query.extra_select: yield ( OrderBy( Ref(col, RawSQL(*self.query.extra[col])), descending=descending, ), True, ) else: yield ( OrderBy(RawSQL(*self.query.extra[col]), descending=descending), False, ) else: if self.query.combinator and self.select: # Don't use the first model's field because other # combinated queries might define it differently. yield OrderBy(F(col), descending=descending), False else: # 'col' is of the form 'field' or 'field1__field2' or # '-field1__field2__field', etc. yield from self.find_ordering_name( field, self.query.get_meta(), default_order=default_order, ) def get_order_by(self): """ Return a list of 2-tuples of the form (expr, (sql, params, is_ref)) for the ORDER BY clause. The order_by clause can alter the select clause (for example it can add aliases to clauses that do not yet have one, or it can add totally new select clauses). """ result = [] seen = set() for expr, is_ref in self._order_by_pairs(): resolved = expr.resolve_expression(self.query, allow_joins=True, reuse=None) if not is_ref and self.query.combinator and self.select: src = resolved.expression expr_src = expr.expression for sel_expr, _, col_alias in self.select: if src == sel_expr: # When values() is used the exact alias must be used to # reference annotations. if ( self.query.has_select_fields and col_alias in self.query.annotation_select and not ( isinstance(expr_src, F) and col_alias == expr_src.name ) ): continue resolved.set_source_expressions( [Ref(col_alias if col_alias else src.target.column, src)] ) break else: # Add column used in ORDER BY clause to the selected # columns and to each combined query. order_by_idx = len(self.query.select) + 1 col_alias = f"__orderbycol{order_by_idx}" for q in self.query.combined_queries: # If fields were explicitly selected through values() # combined queries cannot be augmented. if q.has_select_fields: raise DatabaseError( "ORDER BY term does not match any column in " "the result set." ) q.add_annotation(expr_src, col_alias) self.query.add_select_col(resolved, col_alias) resolved.set_source_expressions([Ref(col_alias, src)]) sql, params = self.compile(resolved) # Don't add the same column twice, but the order direction is # not taken into account so we strip it. When this entire method # is refactored into expressions, then we can check each part as we # generate it. without_ordering = self.ordering_parts.search(sql)[1] params_hash = make_hashable(params) if (without_ordering, params_hash) in seen: continue seen.add((without_ordering, params_hash)) result.append((resolved, (sql, params, is_ref))) return result def get_extra_select(self, order_by, select): extra_select = [] if self.query.distinct and not self.query.distinct_fields: select_sql = [t[1] for t in select] for expr, (sql, params, is_ref) in order_by: without_ordering = self.ordering_parts.search(sql)[1] if not is_ref and (without_ordering, params) not in select_sql: extra_select.append((expr, (without_ordering, params), None)) return extra_select def quote_name_unless_alias(self, name): """ A wrapper around connection.ops.quote_name that doesn't quote aliases for table names. This avoids problems with some SQL dialects that treat quoted strings specially (e.g. PostgreSQL). """ if name in self.quote_cache: return self.quote_cache[name] if ( (name in self.query.alias_map and name not in self.query.table_map) or name in self.query.extra_select or ( self.query.external_aliases.get(name) and name not in self.query.table_map ) ): self.quote_cache[name] = name return name r = self.connection.ops.quote_name(name) self.quote_cache[name] = r return r def compile(self, node): vendor_impl = getattr(node, "as_" + self.connection.vendor, None) if vendor_impl: sql, params = vendor_impl(self, self.connection) else: sql, params = node.as_sql(self, self.connection) return sql, params def get_combinator_sql(self, combinator, all): features = self.connection.features compilers = [ query.get_compiler(self.using, self.connection, self.elide_empty) for query in self.query.combined_queries ] if not features.supports_slicing_ordering_in_compound: for compiler in compilers: if compiler.query.is_sliced: raise DatabaseError( "LIMIT/OFFSET not allowed in subqueries of compound statements." ) if compiler.get_order_by(): raise DatabaseError( "ORDER BY not allowed in subqueries of compound statements." ) elif self.query.is_sliced and combinator == "union": for compiler in compilers: # A sliced union cannot have its parts elided as some of them # might be sliced as well and in the event where only a single # part produces a non-empty resultset it might be impossible to # generate valid SQL. compiler.elide_empty = False parts = () for compiler in compilers: try: # If the columns list is limited, then all combined queries # must have the same columns list. Set the selects defined on # the query on all combined queries, if not already set. if not compiler.query.values_select and self.query.values_select: compiler.query = compiler.query.clone() compiler.query.set_values( ( *self.query.extra_select, *self.query.values_select, *self.query.annotation_select, ) ) part_sql, part_args = compiler.as_sql(with_col_aliases=True) if compiler.query.combinator: # Wrap in a subquery if wrapping in parentheses isn't # supported. if not features.supports_parentheses_in_compound: part_sql = "SELECT * FROM ({})".format(part_sql) # Add parentheses when combining with compound query if not # already added for all compound queries. elif ( self.query.subquery or not features.supports_slicing_ordering_in_compound ): part_sql = "({})".format(part_sql) elif ( self.query.subquery and features.supports_slicing_ordering_in_compound ): part_sql = "({})".format(part_sql) parts += ((part_sql, part_args),) except EmptyResultSet: # Omit the empty queryset with UNION and with DIFFERENCE if the # first queryset is nonempty. if combinator == "union" or (combinator == "difference" and parts): continue raise if not parts: raise EmptyResultSet combinator_sql = self.connection.ops.set_operators[combinator] if all and combinator == "union": combinator_sql += " ALL" braces = "{}" if not self.query.subquery and features.supports_slicing_ordering_in_compound: braces = "({})" sql_parts, args_parts = zip( *((braces.format(sql), args) for sql, args in parts) ) result = [" {} ".format(combinator_sql).join(sql_parts)] params = [] for part in args_parts: params.extend(part) return result, params def get_qualify_sql(self): where_parts = [] if self.where: where_parts.append(self.where) if self.having: where_parts.append(self.having) inner_query = self.query.clone() inner_query.subquery = True inner_query.where = inner_query.where.__class__(where_parts) # Augment the inner query with any window function references that # might have been masked via values() and alias(). If any masked # aliases are added they'll be masked again to avoid fetching # the data in the `if qual_aliases` branch below. select = { expr: alias for expr, _, alias in self.get_select(with_col_aliases=True)[0] } select_aliases = set(select.values()) qual_aliases = set() replacements = {} def collect_replacements(expressions): while expressions: expr = expressions.pop() if expr in replacements: continue elif select_alias := select.get(expr): replacements[expr] = select_alias elif isinstance(expr, Lookup): expressions.extend(expr.get_source_expressions()) elif isinstance(expr, Ref): if expr.refs not in select_aliases: expressions.extend(expr.get_source_expressions()) else: num_qual_alias = len(qual_aliases) select_alias = f"qual{num_qual_alias}" qual_aliases.add(select_alias) inner_query.add_annotation(expr, select_alias) replacements[expr] = select_alias collect_replacements(list(self.qualify.leaves())) self.qualify = self.qualify.replace_expressions( {expr: Ref(alias, expr) for expr, alias in replacements.items()} ) order_by = [] for order_by_expr, *_ in self.get_order_by(): collect_replacements(order_by_expr.get_source_expressions()) order_by.append( order_by_expr.replace_expressions( {expr: Ref(alias, expr) for expr, alias in replacements.items()} ) ) inner_query_compiler = inner_query.get_compiler( self.using, connection=self.connection, elide_empty=self.elide_empty ) inner_sql, inner_params = inner_query_compiler.as_sql( # The limits must be applied to the outer query to avoid pruning # results too eagerly. with_limits=False, # Force unique aliasing of selected columns to avoid collisions # and make rhs predicates referencing easier. with_col_aliases=True, ) qualify_sql, qualify_params = self.compile(self.qualify) result = [ "SELECT * FROM (", inner_sql, ")", self.connection.ops.quote_name("qualify"), "WHERE", qualify_sql, ] if qual_aliases: # If some select aliases were unmasked for filtering purposes they # must be masked back. cols = [self.connection.ops.quote_name(alias) for alias in select.values()] result = [ "SELECT", ", ".join(cols), "FROM (", *result, ")", self.connection.ops.quote_name("qualify_mask"), ] params = list(inner_params) + qualify_params # As the SQL spec is unclear on whether or not derived tables # ordering must propagate it has to be explicitly repeated on the # outer-most query to ensure it's preserved. if order_by: ordering_sqls = [] for ordering in order_by: ordering_sql, ordering_params = self.compile(ordering) ordering_sqls.append(ordering_sql) params.extend(ordering_params) result.extend(["ORDER BY", ", ".join(ordering_sqls)]) return result, params def as_sql(self, with_limits=True, with_col_aliases=False): """ Create the SQL for this query. Return the SQL string and list of parameters. If 'with_limits' is False, any limit/offset information is not included in the query. """ refcounts_before = self.query.alias_refcount.copy() try: combinator = self.query.combinator extra_select, order_by, group_by = self.pre_sql_setup( with_col_aliases=with_col_aliases or bool(combinator), ) for_update_part = None # Is a LIMIT/OFFSET clause needed? with_limit_offset = with_limits and self.query.is_sliced combinator = self.query.combinator features = self.connection.features if combinator: if not getattr(features, "supports_select_{}".format(combinator)): raise NotSupportedError( "{} is not supported on this database backend.".format( combinator ) ) result, params = self.get_combinator_sql( combinator, self.query.combinator_all ) elif self.qualify: result, params = self.get_qualify_sql() order_by = None else: distinct_fields, distinct_params = self.get_distinct() # This must come after 'select', 'ordering', and 'distinct' # (see docstring of get_from_clause() for details). from_, f_params = self.get_from_clause() try: where, w_params = ( self.compile(self.where) if self.where is not None else ("", []) ) except EmptyResultSet: if self.elide_empty: raise # Use a predicate that's always False. where, w_params = "0 = 1", [] except FullResultSet: where, w_params = "", [] try: having, h_params = ( self.compile(self.having) if self.having is not None else ("", []) ) except FullResultSet: having, h_params = "", [] result = ["SELECT"] params = [] if self.query.distinct: distinct_result, distinct_params = self.connection.ops.distinct_sql( distinct_fields, distinct_params, ) result += distinct_result params += distinct_params out_cols = [] for _, (s_sql, s_params), alias in self.select + extra_select: if alias: s_sql = "%s AS %s" % ( s_sql, self.connection.ops.quote_name(alias), ) params.extend(s_params) out_cols.append(s_sql) result += [", ".join(out_cols)] if from_: result += ["FROM", *from_] elif self.connection.features.bare_select_suffix: result += [self.connection.features.bare_select_suffix] params.extend(f_params) if self.query.select_for_update and features.has_select_for_update: if ( self.connection.get_autocommit() # Don't raise an exception when database doesn't # support transactions, as it's a noop. and features.supports_transactions ): raise TransactionManagementError( "select_for_update cannot be used outside of a transaction." ) if ( with_limit_offset and not features.supports_select_for_update_with_limit ): raise NotSupportedError( "LIMIT/OFFSET is not supported with " "select_for_update on this database backend." ) nowait = self.query.select_for_update_nowait skip_locked = self.query.select_for_update_skip_locked of = self.query.select_for_update_of no_key = self.query.select_for_no_key_update # If it's a NOWAIT/SKIP LOCKED/OF/NO KEY query but the # backend doesn't support it, raise NotSupportedError to # prevent a possible deadlock. if nowait and not features.has_select_for_update_nowait: raise NotSupportedError( "NOWAIT is not supported on this database backend." ) elif skip_locked and not features.has_select_for_update_skip_locked: raise NotSupportedError( "SKIP LOCKED is not supported on this database backend." ) elif of and not features.has_select_for_update_of: raise NotSupportedError( "FOR UPDATE OF is not supported on this database backend." ) elif no_key and not features.has_select_for_no_key_update: raise NotSupportedError( "FOR NO KEY UPDATE is not supported on this " "database backend." ) for_update_part = self.connection.ops.for_update_sql( nowait=nowait, skip_locked=skip_locked, of=self.get_select_for_update_of_arguments(), no_key=no_key, ) if for_update_part and features.for_update_after_from: result.append(for_update_part) if where: result.append("WHERE %s" % where) params.extend(w_params) grouping = [] for g_sql, g_params in group_by: grouping.append(g_sql) params.extend(g_params) if grouping: if distinct_fields: raise NotImplementedError( "annotate() + distinct(fields) is not implemented." ) order_by = order_by or self.connection.ops.force_no_ordering() result.append("GROUP BY %s" % ", ".join(grouping)) if self._meta_ordering: order_by = None if having: result.append("HAVING %s" % having) params.extend(h_params) if self.query.explain_info: result.insert( 0, self.connection.ops.explain_query_prefix( self.query.explain_info.format, **self.query.explain_info.options, ), ) if order_by: ordering = [] for _, (o_sql, o_params, _) in order_by: ordering.append(o_sql) params.extend(o_params) order_by_sql = "ORDER BY %s" % ", ".join(ordering) if combinator and features.requires_compound_order_by_subquery: result = ["SELECT * FROM (", *result, ")", order_by_sql] else: result.append(order_by_sql) if with_limit_offset: result.append( self.connection.ops.limit_offset_sql( self.query.low_mark, self.query.high_mark ) ) if for_update_part and not features.for_update_after_from: result.append(for_update_part) if self.query.subquery and extra_select: # If the query is used as a subquery, the extra selects would # result in more columns than the left-hand side expression is # expecting. This can happen when a subquery uses a combination # of order_by() and distinct(), forcing the ordering expressions # to be selected as well. Wrap the query in another subquery # to exclude extraneous selects. sub_selects = [] sub_params = [] for index, (select, _, alias) in enumerate(self.select, start=1): if alias: sub_selects.append( "%s.%s" % ( self.connection.ops.quote_name("subquery"), self.connection.ops.quote_name(alias), ) ) else: select_clone = select.relabeled_clone( {select.alias: "subquery"} ) subselect, subparams = select_clone.as_sql( self, self.connection ) sub_selects.append(subselect) sub_params.extend(subparams) return "SELECT %s FROM (%s) subquery" % ( ", ".join(sub_selects), " ".join(result), ), tuple(sub_params + params) return " ".join(result), tuple(params) finally: # Finally do cleanup - get rid of the joins we created above. self.query.reset_refcounts(refcounts_before) def get_default_columns( self, select_mask, start_alias=None, opts=None, from_parent=None ): """ Compute the default columns for selecting every field in the base model. Will sometimes be called to pull in related models (e.g. via select_related), in which case "opts" and "start_alias" will be given to provide a starting point for the traversal. Return a list of strings, quoted appropriately for use in SQL directly, as well as a set of aliases used in the select statement (if 'as_pairs' is True, return a list of (alias, col_name) pairs instead of strings as the first component and None as the second component). """ result = [] if opts is None: if (opts := self.query.get_meta()) is None: return result start_alias = start_alias or self.query.get_initial_alias() # The 'seen_models' is used to optimize checking the needed parent # alias for a given field. This also includes None -> start_alias to # be used by local fields. seen_models = {None: start_alias} for field in opts.concrete_fields: model = field.model._meta.concrete_model # A proxy model will have a different model and concrete_model. We # will assign None if the field belongs to this model. if model == opts.model: model = None if ( from_parent and model is not None and issubclass( from_parent._meta.concrete_model, model._meta.concrete_model ) ): # Avoid loading data for already loaded parents. # We end up here in the case select_related() resolution # proceeds from parent model to child model. In that case the # parent model data is already present in the SELECT clause, # and we want to avoid reloading the same data again. continue if select_mask and field not in select_mask: continue alias = self.query.join_parent_model(opts, model, start_alias, seen_models) column = field.get_col(alias) result.append(column) return result def get_distinct(self): """ Return a quoted list of fields to use in DISTINCT ON part of the query. This method can alter the tables in the query, and thus it must be called before get_from_clause(). """ result = [] params = [] opts = self.query.get_meta() for name in self.query.distinct_fields: parts = name.split(LOOKUP_SEP) _, targets, alias, joins, path, _, transform_function = self._setup_joins( parts, opts, None ) targets, alias, _ = self.query.trim_joins(targets, joins, path) for target in targets: if name in self.query.annotation_select: result.append(self.connection.ops.quote_name(name)) else: r, p = self.compile(transform_function(target, alias)) result.append(r) params.append(p) return result, params def find_ordering_name( self, name, opts, alias=None, default_order="ASC", already_seen=None ): """ Return the table alias (the name might be ambiguous, the alias will not be) and column name for ordering by the given 'name' parameter. The 'name' is of the form 'field1__field2__...__fieldN'. """ name, order = get_order_dir(name, default_order) descending = order == "DESC" pieces = name.split(LOOKUP_SEP) ( field, targets, alias, joins, path, opts, transform_function, ) = self._setup_joins(pieces, opts, alias) # If we get to this point and the field is a relation to another model, # append the default ordering for that model unless it is the pk # shortcut or the attribute name of the field that is specified or # there are transforms to process. if ( field.is_relation and opts.ordering and getattr(field, "attname", None) != pieces[-1] and name != "pk" and not getattr(transform_function, "has_transforms", False) ): # Firstly, avoid infinite loops. already_seen = already_seen or set() join_tuple = tuple( getattr(self.query.alias_map[j], "join_cols", None) for j in joins ) if join_tuple in already_seen: raise FieldError("Infinite loop caused by ordering.") already_seen.add(join_tuple) results = [] for item in opts.ordering: if hasattr(item, "resolve_expression") and not isinstance( item, OrderBy ): item = item.desc() if descending else item.asc() if isinstance(item, OrderBy): results.append( (item.prefix_references(f"{name}{LOOKUP_SEP}"), False) ) continue results.extend( (expr.prefix_references(f"{name}{LOOKUP_SEP}"), is_ref) for expr, is_ref in self.find_ordering_name( item, opts, alias, order, already_seen ) ) return results targets, alias, _ = self.query.trim_joins(targets, joins, path) return [ (OrderBy(transform_function(t, alias), descending=descending), False) for t in targets ] def _setup_joins(self, pieces, opts, alias): """ Helper method for get_order_by() and get_distinct(). get_ordering() and get_distinct() must produce same target columns on same input, as the prefixes of get_ordering() and get_distinct() must match. Executing SQL where this is not true is an error. """ alias = alias or self.query.get_initial_alias() field, targets, opts, joins, path, transform_function = self.query.setup_joins( pieces, opts, alias ) alias = joins[-1] return field, targets, alias, joins, path, opts, transform_function def get_from_clause(self): """ Return a list of strings that are joined together to go after the "FROM" part of the query, as well as a list any extra parameters that need to be included. Subclasses, can override this to create a from-clause via a "select". This should only be called after any SQL construction methods that might change the tables that are needed. This means the select columns, ordering, and distinct must be done first. """ result = [] params = [] for alias in tuple(self.query.alias_map): if not self.query.alias_refcount[alias]: continue try: from_clause = self.query.alias_map[alias] except KeyError: # Extra tables can end up in self.tables, but not in the # alias_map if they aren't in a join. That's OK. We skip them. continue clause_sql, clause_params = self.compile(from_clause) result.append(clause_sql) params.extend(clause_params) for t in self.query.extra_tables: alias, _ = self.query.table_alias(t) # Only add the alias if it's not already present (the table_alias() # call increments the refcount, so an alias refcount of one means # this is the only reference). if ( alias not in self.query.alias_map or self.query.alias_refcount[alias] == 1 ): result.append(", %s" % self.quote_name_unless_alias(alias)) return result, params def get_related_selections( self, select, select_mask, opts=None, root_alias=None, cur_depth=1, requested=None, restricted=None, ): """ Fill in the information needed for a select_related query. The current depth is measured as the number of connections away from the root model (for example, cur_depth=1 means we are looking at models with direct connections to the root model). """ def _get_field_choices(): direct_choices = (f.name for f in opts.fields if f.is_relation) reverse_choices = ( f.field.related_query_name() for f in opts.related_objects if f.field.unique ) return chain( direct_choices, reverse_choices, self.query._filtered_relations ) related_klass_infos = [] if not restricted and cur_depth > self.query.max_depth: # We've recursed far enough; bail out. return related_klass_infos if not opts: opts = self.query.get_meta() root_alias = self.query.get_initial_alias() # Setup for the case when only particular related fields should be # included in the related selection. fields_found = set() if requested is None: restricted = isinstance(self.query.select_related, dict) if restricted: requested = self.query.select_related def get_related_klass_infos(klass_info, related_klass_infos): klass_info["related_klass_infos"] = related_klass_infos for f in opts.fields: fields_found.add(f.name) if restricted: next = requested.get(f.name, {}) if not f.is_relation: # If a non-related field is used like a relation, # or if a single non-relational field is given. if next or f.name in requested: raise FieldError( "Non-relational field given in select_related: '%s'. " "Choices are: %s" % ( f.name, ", ".join(_get_field_choices()) or "(none)", ) ) else: next = False if not select_related_descend(f, restricted, requested, select_mask): continue related_select_mask = select_mask.get(f) or {} klass_info = { "model": f.remote_field.model, "field": f, "reverse": False, "local_setter": f.set_cached_value, "remote_setter": f.remote_field.set_cached_value if f.unique else lambda x, y: None, "from_parent": False, } related_klass_infos.append(klass_info) select_fields = [] _, _, _, joins, _, _ = self.query.setup_joins([f.name], opts, root_alias) alias = joins[-1] columns = self.get_default_columns( related_select_mask, start_alias=alias, opts=f.remote_field.model._meta ) for col in columns: select_fields.append(len(select)) select.append((col, None)) klass_info["select_fields"] = select_fields next_klass_infos = self.get_related_selections( select, related_select_mask, f.remote_field.model._meta, alias, cur_depth + 1, next, restricted, ) get_related_klass_infos(klass_info, next_klass_infos) if restricted: related_fields = [ (o.field, o.related_model) for o in opts.related_objects if o.field.unique and not o.many_to_many ] for related_field, model in related_fields: related_select_mask = select_mask.get(related_field) or {} if not select_related_descend( related_field, restricted, requested, related_select_mask, reverse=True, ): continue related_field_name = related_field.related_query_name() fields_found.add(related_field_name) join_info = self.query.setup_joins( [related_field_name], opts, root_alias ) alias = join_info.joins[-1] from_parent = issubclass(model, opts.model) and model is not opts.model klass_info = { "model": model, "field": related_field, "reverse": True, "local_setter": related_field.remote_field.set_cached_value, "remote_setter": related_field.set_cached_value, "from_parent": from_parent, } related_klass_infos.append(klass_info) select_fields = [] columns = self.get_default_columns( related_select_mask, start_alias=alias, opts=model._meta, from_parent=opts.model, ) for col in columns: select_fields.append(len(select)) select.append((col, None)) klass_info["select_fields"] = select_fields next = requested.get(related_field.related_query_name(), {}) next_klass_infos = self.get_related_selections( select, related_select_mask, model._meta, alias, cur_depth + 1, next, restricted, ) get_related_klass_infos(klass_info, next_klass_infos) def local_setter(final_field, obj, from_obj): # Set a reverse fk object when relation is non-empty. if from_obj: final_field.remote_field.set_cached_value(from_obj, obj) def local_setter_noop(obj, from_obj): pass def remote_setter(name, obj, from_obj): setattr(from_obj, name, obj) for name in list(requested): # Filtered relations work only on the topmost level. if cur_depth > 1: break if name in self.query._filtered_relations: fields_found.add(name) final_field, _, join_opts, joins, _, _ = self.query.setup_joins( [name], opts, root_alias ) model = join_opts.model alias = joins[-1] from_parent = ( issubclass(model, opts.model) and model is not opts.model ) klass_info = { "model": model, "field": final_field, "reverse": True, "local_setter": ( partial(local_setter, final_field) if len(joins) <= 2 else local_setter_noop ), "remote_setter": partial(remote_setter, name), "from_parent": from_parent, } related_klass_infos.append(klass_info) select_fields = [] field_select_mask = select_mask.get((name, final_field)) or {} columns = self.get_default_columns( field_select_mask, start_alias=alias, opts=model._meta, from_parent=opts.model, ) for col in columns: select_fields.append(len(select)) select.append((col, None)) klass_info["select_fields"] = select_fields next_requested = requested.get(name, {}) next_klass_infos = self.get_related_selections( select, field_select_mask, opts=model._meta, root_alias=alias, cur_depth=cur_depth + 1, requested=next_requested, restricted=restricted, ) get_related_klass_infos(klass_info, next_klass_infos) fields_not_found = set(requested).difference(fields_found) if fields_not_found: invalid_fields = ("'%s'" % s for s in fields_not_found) raise FieldError( "Invalid field name(s) given in select_related: %s. " "Choices are: %s" % ( ", ".join(invalid_fields), ", ".join(_get_field_choices()) or "(none)", ) ) return related_klass_infos def get_select_for_update_of_arguments(self): """ Return a quoted list of arguments for the SELECT FOR UPDATE OF part of the query. """ def _get_parent_klass_info(klass_info): concrete_model = klass_info["model"]._meta.concrete_model for parent_model, parent_link in concrete_model._meta.parents.items(): parent_list = parent_model._meta.get_parent_list() yield { "model": parent_model, "field": parent_link, "reverse": False, "select_fields": [ select_index for select_index in klass_info["select_fields"] # Selected columns from a model or its parents. if ( self.select[select_index][0].target.model == parent_model or self.select[select_index][0].target.model in parent_list ) ], } def _get_first_selected_col_from_model(klass_info): """ Find the first selected column from a model. If it doesn't exist, don't lock a model. select_fields is filled recursively, so it also contains fields from the parent models. """ concrete_model = klass_info["model"]._meta.concrete_model for select_index in klass_info["select_fields"]: if self.select[select_index][0].target.model == concrete_model: return self.select[select_index][0] def _get_field_choices(): """Yield all allowed field paths in breadth-first search order.""" queue = collections.deque([(None, self.klass_info)]) while queue: parent_path, klass_info = queue.popleft() if parent_path is None: path = [] yield "self" else: field = klass_info["field"] if klass_info["reverse"]: field = field.remote_field path = parent_path + [field.name] yield LOOKUP_SEP.join(path) queue.extend( (path, klass_info) for klass_info in _get_parent_klass_info(klass_info) ) queue.extend( (path, klass_info) for klass_info in klass_info.get("related_klass_infos", []) ) if not self.klass_info: return [] result = [] invalid_names = [] for name in self.query.select_for_update_of: klass_info = self.klass_info if name == "self": col = _get_first_selected_col_from_model(klass_info) else: for part in name.split(LOOKUP_SEP): klass_infos = ( *klass_info.get("related_klass_infos", []), *_get_parent_klass_info(klass_info), ) for related_klass_info in klass_infos: field = related_klass_info["field"] if related_klass_info["reverse"]: field = field.remote_field if field.name == part: klass_info = related_klass_info break else: klass_info = None break if klass_info is None: invalid_names.append(name) continue col = _get_first_selected_col_from_model(klass_info) if col is not None: if self.connection.features.select_for_update_of_column: result.append(self.compile(col)[0]) else: result.append(self.quote_name_unless_alias(col.alias)) if invalid_names: raise FieldError( "Invalid field name(s) given in select_for_update(of=(...)): %s. " "Only relational fields followed in the query are allowed. " "Choices are: %s." % ( ", ".join(invalid_names), ", ".join(_get_field_choices()), ) ) return result def get_converters(self, expressions): converters = {} for i, expression in enumerate(expressions): if expression: backend_converters = self.connection.ops.get_db_converters(expression) field_converters = expression.get_db_converters(self.connection) if backend_converters or field_converters: converters[i] = (backend_converters + field_converters, expression) return converters def apply_converters(self, rows, converters): connection = self.connection converters = list(converters.items()) for row in map(list, rows): for pos, (convs, expression) in converters: value = row[pos] for converter in convs: value = converter(value, expression, connection) row[pos] = value yield row def results_iter( self, results=None, tuple_expected=False, chunked_fetch=False, chunk_size=GET_ITERATOR_CHUNK_SIZE, ): """Return an iterator over the results from executing this query.""" if results is None: results = self.execute_sql( MULTI, chunked_fetch=chunked_fetch, chunk_size=chunk_size ) fields = [s[0] for s in self.select[0 : self.col_count]] converters = self.get_converters(fields) rows = chain.from_iterable(results) if converters: rows = self.apply_converters(rows, converters) if tuple_expected: rows = map(tuple, rows) return rows def has_results(self): """ Backends (e.g. NoSQL) can override this in order to use optimized versions of "query has any results." """ return bool(self.execute_sql(SINGLE)) def execute_sql( self, result_type=MULTI, chunked_fetch=False, chunk_size=GET_ITERATOR_CHUNK_SIZE ): """ Run the query against the database and return the result(s). The return value is a single data item if result_type is SINGLE, or an iterator over the results if the result_type is MULTI. result_type is either MULTI (use fetchmany() to retrieve all rows), SINGLE (only retrieve a single row), or None. In this last case, the cursor is returned if any query is executed, since it's used by subclasses such as InsertQuery). It's possible, however, that no query is needed, as the filters describe an empty set. In that case, None is returned, to avoid any unnecessary database interaction. """ result_type = result_type or NO_RESULTS try: sql, params = self.as_sql() if not sql: raise EmptyResultSet except EmptyResultSet: if result_type == MULTI: return iter([]) else: return if chunked_fetch: cursor = self.connection.chunked_cursor() else: cursor = self.connection.cursor() try: cursor.execute(sql, params) except Exception: # Might fail for server-side cursors (e.g. connection closed) cursor.close() raise if result_type == CURSOR: # Give the caller the cursor to process and close. return cursor if result_type == SINGLE: try: val = cursor.fetchone() if val: return val[0 : self.col_count] return val finally: # done with the cursor cursor.close() if result_type == NO_RESULTS: cursor.close() return result = cursor_iter( cursor, self.connection.features.empty_fetchmany_value, self.col_count if self.has_extra_select else None, chunk_size, ) if not chunked_fetch or not self.connection.features.can_use_chunked_reads: # If we are using non-chunked reads, we return the same data # structure as normally, but ensure it is all read into memory # before going any further. Use chunked_fetch if requested, # unless the database doesn't support it. return list(result) return result def as_subquery_condition(self, alias, columns, compiler): qn = compiler.quote_name_unless_alias qn2 = self.connection.ops.quote_name for index, select_col in enumerate(self.query.select): lhs_sql, lhs_params = self.compile(select_col) rhs = "%s.%s" % (qn(alias), qn2(columns[index])) self.query.where.add(RawSQL("%s = %s" % (lhs_sql, rhs), lhs_params), AND) sql, params = self.as_sql() return "EXISTS (%s)" % sql, params def explain_query(self): result = list(self.execute_sql()) # Some backends return 1 item tuples with strings, and others return # tuples with integers and strings. Flatten them out into strings. format_ = self.query.explain_info.format output_formatter = json.dumps if format_ and format_.lower() == "json" else str for row in result[0]: if not isinstance(row, str): yield " ".join(output_formatter(c) for c in row) else: yield row class SQLInsertCompiler(SQLCompiler): returning_fields = None returning_params = () def field_as_sql(self, field, val): """ Take a field and a value intended to be saved on that field, and return placeholder SQL and accompanying params. Check for raw values, expressions, and fields with get_placeholder() defined in that order. When field is None, consider the value raw and use it as the placeholder, with no corresponding parameters returned. """ if field is None: # A field value of None means the value is raw. sql, params = val, [] elif hasattr(val, "as_sql"): # This is an expression, let's compile it. sql, params = self.compile(val) elif hasattr(field, "get_placeholder"): # Some fields (e.g. geo fields) need special munging before # they can be inserted. sql, params = field.get_placeholder(val, self, self.connection), [val] else: # Return the common case for the placeholder sql, params = "%s", [val] # The following hook is only used by Oracle Spatial, which sometimes # needs to yield 'NULL' and [] as its placeholder and params instead # of '%s' and [None]. The 'NULL' placeholder is produced earlier by # OracleOperations.get_geom_placeholder(). The following line removes # the corresponding None parameter. See ticket #10888. params = self.connection.ops.modify_insert_params(sql, params) return sql, params def prepare_value(self, field, value): """ Prepare a value to be used in a query by resolving it if it is an expression and otherwise calling the field's get_db_prep_save(). """ if hasattr(value, "resolve_expression"): value = value.resolve_expression( self.query, allow_joins=False, for_save=True ) # Don't allow values containing Col expressions. They refer to # existing columns on a row, but in the case of insert the row # doesn't exist yet. if value.contains_column_references: raise ValueError( 'Failed to insert expression "%s" on %s. F() expressions ' "can only be used to update, not to insert." % (value, field) ) if value.contains_aggregate: raise FieldError( "Aggregate functions are not allowed in this query " "(%s=%r)." % (field.name, value) ) if value.contains_over_clause: raise FieldError( "Window expressions are not allowed in this query (%s=%r)." % (field.name, value) ) return field.get_db_prep_save(value, connection=self.connection) def pre_save_val(self, field, obj): """ Get the given field's value off the given obj. pre_save() is used for things like auto_now on DateTimeField. Skip it if this is a raw query. """ if self.query.raw: return getattr(obj, field.attname) return field.pre_save(obj, add=True) def assemble_as_sql(self, fields, value_rows): """ Take a sequence of N fields and a sequence of M rows of values, and generate placeholder SQL and parameters for each field and value. Return a pair containing: * a sequence of M rows of N SQL placeholder strings, and * a sequence of M rows of corresponding parameter values. Each placeholder string may contain any number of '%s' interpolation strings, and each parameter row will contain exactly as many params as the total number of '%s's in the corresponding placeholder row. """ if not value_rows: return [], [] # list of (sql, [params]) tuples for each object to be saved # Shape: [n_objs][n_fields][2] rows_of_fields_as_sql = ( (self.field_as_sql(field, v) for field, v in zip(fields, row)) for row in value_rows ) # tuple like ([sqls], [[params]s]) for each object to be saved # Shape: [n_objs][2][n_fields] sql_and_param_pair_rows = (zip(*row) for row in rows_of_fields_as_sql) # Extract separate lists for placeholders and params. # Each of these has shape [n_objs][n_fields] placeholder_rows, param_rows = zip(*sql_and_param_pair_rows) # Params for each field are still lists, and need to be flattened. param_rows = [[p for ps in row for p in ps] for row in param_rows] return placeholder_rows, param_rows def as_sql(self): # We don't need quote_name_unless_alias() here, since these are all # going to be column names (so we can avoid the extra overhead). qn = self.connection.ops.quote_name opts = self.query.get_meta() insert_statement = self.connection.ops.insert_statement( on_conflict=self.query.on_conflict, ) result = ["%s %s" % (insert_statement, qn(opts.db_table))] fields = self.query.fields or [opts.pk] result.append("(%s)" % ", ".join(qn(f.column) for f in fields)) if self.query.fields: value_rows = [ [ self.prepare_value(field, self.pre_save_val(field, obj)) for field in fields ] for obj in self.query.objs ] else: # An empty object. value_rows = [ [self.connection.ops.pk_default_value()] for _ in self.query.objs ] fields = [None] # Currently the backends just accept values when generating bulk # queries and generate their own placeholders. Doing that isn't # necessary and it should be possible to use placeholders and # expressions in bulk inserts too. can_bulk = ( not self.returning_fields and self.connection.features.has_bulk_insert ) placeholder_rows, param_rows = self.assemble_as_sql(fields, value_rows) on_conflict_suffix_sql = self.connection.ops.on_conflict_suffix_sql( fields, self.query.on_conflict, (f.column for f in self.query.update_fields), (f.column for f in self.query.unique_fields), ) if ( self.returning_fields and self.connection.features.can_return_columns_from_insert ): if self.connection.features.can_return_rows_from_bulk_insert: result.append( self.connection.ops.bulk_insert_sql(fields, placeholder_rows) ) params = param_rows else: result.append("VALUES (%s)" % ", ".join(placeholder_rows[0])) params = [param_rows[0]] if on_conflict_suffix_sql: result.append(on_conflict_suffix_sql) # Skip empty r_sql to allow subclasses to customize behavior for # 3rd party backends. Refs #19096. r_sql, self.returning_params = self.connection.ops.return_insert_columns( self.returning_fields ) if r_sql: result.append(r_sql) params += [self.returning_params] return [(" ".join(result), tuple(chain.from_iterable(params)))] if can_bulk: result.append(self.connection.ops.bulk_insert_sql(fields, placeholder_rows)) if on_conflict_suffix_sql: result.append(on_conflict_suffix_sql) return [(" ".join(result), tuple(p for ps in param_rows for p in ps))] else: if on_conflict_suffix_sql: result.append(on_conflict_suffix_sql) return [ (" ".join(result + ["VALUES (%s)" % ", ".join(p)]), vals) for p, vals in zip(placeholder_rows, param_rows) ] def execute_sql(self, returning_fields=None): assert not ( returning_fields and len(self.query.objs) != 1 and not self.connection.features.can_return_rows_from_bulk_insert ) opts = self.query.get_meta() self.returning_fields = returning_fields with self.connection.cursor() as cursor: for sql, params in self.as_sql(): cursor.execute(sql, params) if not self.returning_fields: return [] if ( self.connection.features.can_return_rows_from_bulk_insert and len(self.query.objs) > 1 ): rows = self.connection.ops.fetch_returned_insert_rows(cursor) elif self.connection.features.can_return_columns_from_insert: assert len(self.query.objs) == 1 rows = [ self.connection.ops.fetch_returned_insert_columns( cursor, self.returning_params, ) ] else: rows = [ ( self.connection.ops.last_insert_id( cursor, opts.db_table, opts.pk.column, ), ) ] cols = [field.get_col(opts.db_table) for field in self.returning_fields] converters = self.get_converters(cols) if converters: rows = list(self.apply_converters(rows, converters)) return rows class SQLDeleteCompiler(SQLCompiler): @cached_property def single_alias(self): # Ensure base table is in aliases. self.query.get_initial_alias() return sum(self.query.alias_refcount[t] > 0 for t in self.query.alias_map) == 1 @classmethod def _expr_refs_base_model(cls, expr, base_model): if isinstance(expr, Query): return expr.model == base_model if not hasattr(expr, "get_source_expressions"): return False return any( cls._expr_refs_base_model(source_expr, base_model) for source_expr in expr.get_source_expressions() ) @cached_property def contains_self_reference_subquery(self): return any( self._expr_refs_base_model(expr, self.query.model) for expr in chain( self.query.annotations.values(), self.query.where.children ) ) def _as_sql(self, query): delete = "DELETE FROM %s" % self.quote_name_unless_alias(query.base_table) try: where, params = self.compile(query.where) except FullResultSet: return delete, () return f"{delete} WHERE {where}", tuple(params) def as_sql(self): """ Create the SQL for this query. Return the SQL string and list of parameters. """ if self.single_alias and not self.contains_self_reference_subquery: return self._as_sql(self.query) innerq = self.query.clone() innerq.__class__ = Query innerq.clear_select_clause() pk = self.query.model._meta.pk innerq.select = [pk.get_col(self.query.get_initial_alias())] outerq = Query(self.query.model) if not self.connection.features.update_can_self_select: # Force the materialization of the inner query to allow reference # to the target table on MySQL. sql, params = innerq.get_compiler(connection=self.connection).as_sql() innerq = RawSQL("SELECT * FROM (%s) subquery" % sql, params) outerq.add_filter("pk__in", innerq) return self._as_sql(outerq) class SQLUpdateCompiler(SQLCompiler): def as_sql(self): """ Create the SQL for this query. Return the SQL string and list of parameters. """ self.pre_sql_setup() if not self.query.values: return "", () qn = self.quote_name_unless_alias values, update_params = [], [] for field, model, val in self.query.values: if hasattr(val, "resolve_expression"): val = val.resolve_expression( self.query, allow_joins=False, for_save=True ) if val.contains_aggregate: raise FieldError( "Aggregate functions are not allowed in this query " "(%s=%r)." % (field.name, val) ) if val.contains_over_clause: raise FieldError( "Window expressions are not allowed in this query " "(%s=%r)." % (field.name, val) ) elif hasattr(val, "prepare_database_save"): if field.remote_field: val = val.prepare_database_save(field) else: raise TypeError( "Tried to update field %s with a model instance, %r. " "Use a value compatible with %s." % (field, val, field.__class__.__name__) ) val = field.get_db_prep_save(val, connection=self.connection) # Getting the placeholder for the field. if hasattr(field, "get_placeholder"): placeholder = field.get_placeholder(val, self, self.connection) else: placeholder = "%s" name = field.column if hasattr(val, "as_sql"): sql, params = self.compile(val) values.append("%s = %s" % (qn(name), placeholder % sql)) update_params.extend(params) elif val is not None: values.append("%s = %s" % (qn(name), placeholder)) update_params.append(val) else: values.append("%s = NULL" % qn(name)) table = self.query.base_table result = [ "UPDATE %s SET" % qn(table), ", ".join(values), ] try: where, params = self.compile(self.query.where) except FullResultSet: params = [] else: result.append("WHERE %s" % where) return " ".join(result), tuple(update_params + params) def execute_sql(self, result_type): """ Execute the specified update. Return the number of rows affected by the primary update query. The "primary update query" is the first non-empty query that is executed. Row counts for any subsequent, related queries are not available. """ cursor = super().execute_sql(result_type) try: rows = cursor.rowcount if cursor else 0 is_empty = cursor is None finally: if cursor: cursor.close() for query in self.query.get_related_updates(): aux_rows = query.get_compiler(self.using).execute_sql(result_type) if is_empty and aux_rows: rows = aux_rows is_empty = False return rows def pre_sql_setup(self): """ If the update depends on results from other tables, munge the "where" conditions to match the format required for (portable) SQL updates. If multiple updates are required, pull out the id values to update at this point so that they don't change as a result of the progressive updates. """ refcounts_before = self.query.alias_refcount.copy() # Ensure base table is in the query self.query.get_initial_alias() count = self.query.count_active_tables() if not self.query.related_updates and count == 1: return query = self.query.chain(klass=Query) query.select_related = False query.clear_ordering(force=True) query.extra = {} query.select = [] meta = query.get_meta() fields = [meta.pk.name] related_ids_index = [] for related in self.query.related_updates: if all( path.join_field.primary_key for path in meta.get_path_to_parent(related) ): # If a primary key chain exists to the targeted related update, # then the meta.pk value can be used for it. related_ids_index.append((related, 0)) else: # This branch will only be reached when updating a field of an # ancestor that is not part of the primary key chain of a MTI # tree. related_ids_index.append((related, len(fields))) fields.append(related._meta.pk.name) query.add_fields(fields) super().pre_sql_setup() must_pre_select = ( count > 1 and not self.connection.features.update_can_self_select ) # Now we adjust the current query: reset the where clause and get rid # of all the tables we don't need (since they're in the sub-select). self.query.clear_where() if self.query.related_updates or must_pre_select: # Either we're using the idents in multiple update queries (so # don't want them to change), or the db backend doesn't support # selecting from the updating table (e.g. MySQL). idents = [] related_ids = collections.defaultdict(list) for rows in query.get_compiler(self.using).execute_sql(MULTI): idents.extend(r[0] for r in rows) for parent, index in related_ids_index: related_ids[parent].extend(r[index] for r in rows) self.query.add_filter("pk__in", idents) self.query.related_ids = related_ids else: # The fast path. Filters and updates in one query. self.query.add_filter("pk__in", query) self.query.reset_refcounts(refcounts_before) class SQLAggregateCompiler(SQLCompiler): def as_sql(self): """ Create the SQL for this query. Return the SQL string and list of parameters. """ sql, params = [], [] for annotation in self.query.annotation_select.values(): ann_sql, ann_params = self.compile(annotation) ann_sql, ann_params = annotation.select_format(self, ann_sql, ann_params) sql.append(ann_sql) params.extend(ann_params) self.col_count = len(self.query.annotation_select) sql = ", ".join(sql) params = tuple(params) inner_query_sql, inner_query_params = self.query.inner_query.get_compiler( self.using, elide_empty=self.elide_empty, ).as_sql(with_col_aliases=True) sql = "SELECT %s FROM (%s) subquery" % (sql, inner_query_sql) params += inner_query_params return sql, params def cursor_iter(cursor, sentinel, col_count, itersize): """ Yield blocks of rows from a cursor and ensure the cursor is closed when done. """ try: for rows in iter((lambda: cursor.fetchmany(itersize)), sentinel): yield rows if col_count is None else [r[:col_count] for r in rows] finally: cursor.close() where.py 0000644 00000030646 15030124302 0006227 0 ustar 00 """ Code to manage the creation and SQL rendering of 'where' constraints. """ import operator from functools import reduce from django.core.exceptions import EmptyResultSet, FullResultSet from django.db.models.expressions import Case, When from django.db.models.lookups import Exact from django.utils import tree from django.utils.functional import cached_property # Connection types AND = "AND" OR = "OR" XOR = "XOR" class WhereNode(tree.Node): """ An SQL WHERE clause. The class is tied to the Query class that created it (in order to create the correct SQL). A child is usually an expression producing boolean values. Most likely the expression is a Lookup instance. However, a child could also be any class with as_sql() and either relabeled_clone() method or relabel_aliases() and clone() methods and contains_aggregate attribute. """ default = AND resolved = False conditional = True def split_having_qualify(self, negated=False, must_group_by=False): """ Return three possibly None nodes: one for those parts of self that should be included in the WHERE clause, one for those parts of self that must be included in the HAVING clause, and one for those parts that refer to window functions. """ if not self.contains_aggregate and not self.contains_over_clause: return self, None, None in_negated = negated ^ self.negated # Whether or not children must be connected in the same filtering # clause (WHERE > HAVING > QUALIFY) to maintain logical semantic. must_remain_connected = ( (in_negated and self.connector == AND) or (not in_negated and self.connector == OR) or self.connector == XOR ) if ( must_remain_connected and self.contains_aggregate and not self.contains_over_clause ): # It's must cheaper to short-circuit and stash everything in the # HAVING clause than split children if possible. return None, self, None where_parts = [] having_parts = [] qualify_parts = [] for c in self.children: if hasattr(c, "split_having_qualify"): where_part, having_part, qualify_part = c.split_having_qualify( in_negated, must_group_by ) if where_part is not None: where_parts.append(where_part) if having_part is not None: having_parts.append(having_part) if qualify_part is not None: qualify_parts.append(qualify_part) elif c.contains_over_clause: qualify_parts.append(c) elif c.contains_aggregate: having_parts.append(c) else: where_parts.append(c) if must_remain_connected and qualify_parts: # Disjunctive heterogeneous predicates can be pushed down to # qualify as long as no conditional aggregation is involved. if not where_parts or (where_parts and not must_group_by): return None, None, self elif where_parts: # In theory this should only be enforced when dealing with # where_parts containing predicates against multi-valued # relationships that could affect aggregation results but this # is complex to infer properly. raise NotImplementedError( "Heterogeneous disjunctive predicates against window functions are " "not implemented when performing conditional aggregation." ) where_node = ( self.create(where_parts, self.connector, self.negated) if where_parts else None ) having_node = ( self.create(having_parts, self.connector, self.negated) if having_parts else None ) qualify_node = ( self.create(qualify_parts, self.connector, self.negated) if qualify_parts else None ) return where_node, having_node, qualify_node def as_sql(self, compiler, connection): """ Return the SQL version of the where clause and the value to be substituted in. Return '', [] if this node matches everything, None, [] if this node is empty, and raise EmptyResultSet if this node can't match anything. """ result = [] result_params = [] if self.connector == AND: full_needed, empty_needed = len(self.children), 1 else: full_needed, empty_needed = 1, len(self.children) if self.connector == XOR and not connection.features.supports_logical_xor: # Convert if the database doesn't support XOR: # a XOR b XOR c XOR ... # to: # (a OR b OR c OR ...) AND (a + b + c + ...) == 1 lhs = self.__class__(self.children, OR) rhs_sum = reduce( operator.add, (Case(When(c, then=1), default=0) for c in self.children), ) rhs = Exact(1, rhs_sum) return self.__class__([lhs, rhs], AND, self.negated).as_sql( compiler, connection ) for child in self.children: try: sql, params = compiler.compile(child) except EmptyResultSet: empty_needed -= 1 except FullResultSet: full_needed -= 1 else: if sql: result.append(sql) result_params.extend(params) else: full_needed -= 1 # Check if this node matches nothing or everything. # First check the amount of full nodes and empty nodes # to make this node empty/full. # Now, check if this node is full/empty using the # counts. if empty_needed == 0: if self.negated: raise FullResultSet else: raise EmptyResultSet if full_needed == 0: if self.negated: raise EmptyResultSet else: raise FullResultSet conn = " %s " % self.connector sql_string = conn.join(result) if not sql_string: raise FullResultSet if self.negated: # Some backends (Oracle at least) need parentheses around the inner # SQL in the negated case, even if the inner SQL contains just a # single expression. sql_string = "NOT (%s)" % sql_string elif len(result) > 1 or self.resolved: sql_string = "(%s)" % sql_string return sql_string, result_params def get_group_by_cols(self): cols = [] for child in self.children: cols.extend(child.get_group_by_cols()) return cols def get_source_expressions(self): return self.children[:] def set_source_expressions(self, children): assert len(children) == len(self.children) self.children = children def relabel_aliases(self, change_map): """ Relabel the alias values of any children. 'change_map' is a dictionary mapping old (current) alias values to the new values. """ for pos, child in enumerate(self.children): if hasattr(child, "relabel_aliases"): # For example another WhereNode child.relabel_aliases(change_map) elif hasattr(child, "relabeled_clone"): self.children[pos] = child.relabeled_clone(change_map) def clone(self): clone = self.create(connector=self.connector, negated=self.negated) for child in self.children: if hasattr(child, "clone"): child = child.clone() clone.children.append(child) return clone def relabeled_clone(self, change_map): clone = self.clone() clone.relabel_aliases(change_map) return clone def replace_expressions(self, replacements): if replacement := replacements.get(self): return replacement clone = self.create(connector=self.connector, negated=self.negated) for child in self.children: clone.children.append(child.replace_expressions(replacements)) return clone def get_refs(self): refs = set() for child in self.children: refs |= child.get_refs() return refs @classmethod def _contains_aggregate(cls, obj): if isinstance(obj, tree.Node): return any(cls._contains_aggregate(c) for c in obj.children) return obj.contains_aggregate @cached_property def contains_aggregate(self): return self._contains_aggregate(self) @classmethod def _contains_over_clause(cls, obj): if isinstance(obj, tree.Node): return any(cls._contains_over_clause(c) for c in obj.children) return obj.contains_over_clause @cached_property def contains_over_clause(self): return self._contains_over_clause(self) @property def is_summary(self): return any(child.is_summary for child in self.children) @staticmethod def _resolve_leaf(expr, query, *args, **kwargs): if hasattr(expr, "resolve_expression"): expr = expr.resolve_expression(query, *args, **kwargs) return expr @classmethod def _resolve_node(cls, node, query, *args, **kwargs): if hasattr(node, "children"): for child in node.children: cls._resolve_node(child, query, *args, **kwargs) if hasattr(node, "lhs"): node.lhs = cls._resolve_leaf(node.lhs, query, *args, **kwargs) if hasattr(node, "rhs"): node.rhs = cls._resolve_leaf(node.rhs, query, *args, **kwargs) def resolve_expression(self, *args, **kwargs): clone = self.clone() clone._resolve_node(clone, *args, **kwargs) clone.resolved = True return clone @cached_property def output_field(self): from django.db.models import BooleanField return BooleanField() @property def _output_field_or_none(self): return self.output_field def select_format(self, compiler, sql, params): # Wrap filters with a CASE WHEN expression if a database backend # (e.g. Oracle) doesn't support boolean expression in SELECT or GROUP # BY list. if not compiler.connection.features.supports_boolean_expr_in_select_clause: sql = f"CASE WHEN {sql} THEN 1 ELSE 0 END" return sql, params def get_db_converters(self, connection): return self.output_field.get_db_converters(connection) def get_lookup(self, lookup): return self.output_field.get_lookup(lookup) def leaves(self): for child in self.children: if isinstance(child, WhereNode): yield from child.leaves() else: yield child class NothingNode: """A node that matches nothing.""" contains_aggregate = False contains_over_clause = False def as_sql(self, compiler=None, connection=None): raise EmptyResultSet class ExtraWhere: # The contents are a black box - assume no aggregates or windows are used. contains_aggregate = False contains_over_clause = False def __init__(self, sqls, params): self.sqls = sqls self.params = params def as_sql(self, compiler=None, connection=None): sqls = ["(%s)" % sql for sql in self.sqls] return " AND ".join(sqls), list(self.params or ()) class SubqueryConstraint: # Even if aggregates or windows would be used in a subquery, # the outer query isn't interested about those. contains_aggregate = False contains_over_clause = False def __init__(self, alias, columns, targets, query_object): self.alias = alias self.columns = columns self.targets = targets query_object.clear_ordering(clear_default=True) self.query_object = query_object def as_sql(self, compiler, connection): query = self.query_object query.set_values(self.targets) query_compiler = query.get_compiler(connection=connection) return query_compiler.as_subquery_condition(self.alias, self.columns, compiler) subqueries.py 0000644 00000013457 15030124302 0007305 0 ustar 00 """ Query subclasses which provide extra functionality beyond simple data retrieval. """ from django.core.exceptions import FieldError from django.db.models.sql.constants import CURSOR, GET_ITERATOR_CHUNK_SIZE, NO_RESULTS from django.db.models.sql.query import Query __all__ = ["DeleteQuery", "UpdateQuery", "InsertQuery", "AggregateQuery"] class DeleteQuery(Query): """A DELETE SQL query.""" compiler = "SQLDeleteCompiler" def do_query(self, table, where, using): self.alias_map = {table: self.alias_map[table]} self.where = where cursor = self.get_compiler(using).execute_sql(CURSOR) if cursor: with cursor: return cursor.rowcount return 0 def delete_batch(self, pk_list, using): """ Set up and execute delete queries for all the objects in pk_list. More than one physical query may be executed if there are a lot of values in pk_list. """ # number of objects deleted num_deleted = 0 field = self.get_meta().pk for offset in range(0, len(pk_list), GET_ITERATOR_CHUNK_SIZE): self.clear_where() self.add_filter( f"{field.attname}__in", pk_list[offset : offset + GET_ITERATOR_CHUNK_SIZE], ) num_deleted += self.do_query( self.get_meta().db_table, self.where, using=using ) return num_deleted class UpdateQuery(Query): """An UPDATE SQL query.""" compiler = "SQLUpdateCompiler" def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self._setup_query() def _setup_query(self): """ Run on initialization and at the end of chaining. Any attributes that would normally be set in __init__() should go here instead. """ self.values = [] self.related_ids = None self.related_updates = {} def clone(self): obj = super().clone() obj.related_updates = self.related_updates.copy() return obj def update_batch(self, pk_list, values, using): self.add_update_values(values) for offset in range(0, len(pk_list), GET_ITERATOR_CHUNK_SIZE): self.clear_where() self.add_filter( "pk__in", pk_list[offset : offset + GET_ITERATOR_CHUNK_SIZE] ) self.get_compiler(using).execute_sql(NO_RESULTS) def add_update_values(self, values): """ Convert a dictionary of field name to value mappings into an update query. This is the entry point for the public update() method on querysets. """ values_seq = [] for name, val in values.items(): field = self.get_meta().get_field(name) direct = ( not (field.auto_created and not field.concrete) or not field.concrete ) model = field.model._meta.concrete_model if not direct or (field.is_relation and field.many_to_many): raise FieldError( "Cannot update model field %r (only non-relations and " "foreign keys permitted)." % field ) if model is not self.get_meta().concrete_model: self.add_related_update(model, field, val) continue values_seq.append((field, model, val)) return self.add_update_fields(values_seq) def add_update_fields(self, values_seq): """ Append a sequence of (field, model, value) triples to the internal list that will be used to generate the UPDATE query. Might be more usefully called add_update_targets() to hint at the extra information here. """ for field, model, val in values_seq: if hasattr(val, "resolve_expression"): # Resolve expressions here so that annotations are no longer needed val = val.resolve_expression(self, allow_joins=False, for_save=True) self.values.append((field, model, val)) def add_related_update(self, model, field, value): """ Add (name, value) to an update query for an ancestor model. Update are coalesced so that only one update query per ancestor is run. """ self.related_updates.setdefault(model, []).append((field, None, value)) def get_related_updates(self): """ Return a list of query objects: one for each update required to an ancestor model. Each query will have the same filtering conditions as the current query but will only update a single table. """ if not self.related_updates: return [] result = [] for model, values in self.related_updates.items(): query = UpdateQuery(model) query.values = values if self.related_ids is not None: query.add_filter("pk__in", self.related_ids[model]) result.append(query) return result class InsertQuery(Query): compiler = "SQLInsertCompiler" def __init__( self, *args, on_conflict=None, update_fields=None, unique_fields=None, **kwargs ): super().__init__(*args, **kwargs) self.fields = [] self.objs = [] self.on_conflict = on_conflict self.update_fields = update_fields or [] self.unique_fields = unique_fields or [] def insert_values(self, fields, objs, raw=False): self.fields = fields self.objs = objs self.raw = raw class AggregateQuery(Query): """ Take another query as a parameter to the FROM clause and only select the elements in the provided list. """ compiler = "SQLAggregateCompiler" def __init__(self, model, inner_query): self.inner_query = inner_query super().__init__(model) __init__.py 0000644 00000000361 15030124302 0006643 0 ustar 00 from django.db.models.sql.query import * # NOQA from django.db.models.sql.query import Query from django.db.models.sql.subqueries import * # NOQA from django.db.models.sql.where import AND, OR, XOR __all__ = ["Query", "AND", "OR", "XOR"] sql.js 0000644 00000135605 15030146453 0005714 0 ustar 00 // CodeMirror, copyright (c) by Marijn Haverbeke and others // Distributed under an MIT license: https://codemirror.net/LICENSE (function(mod) { if (typeof exports == "object" && typeof module == "object") // CommonJS mod(require("../../lib/codemirror")); else if (typeof define == "function" && define.amd) // AMD define(["../../lib/codemirror"], mod); else // Plain browser env mod(CodeMirror); })(function(CodeMirror) { "use strict"; CodeMirror.defineMode("sql", function(config, parserConfig) { var client = parserConfig.client || {}, atoms = parserConfig.atoms || {"false": true, "true": true, "null": true}, builtin = parserConfig.builtin || set(defaultBuiltin), keywords = parserConfig.keywords || set(sqlKeywords), operatorChars = parserConfig.operatorChars || /^[*+\-%<>!=&|~^\/]/, support = parserConfig.support || {}, hooks = parserConfig.hooks || {}, dateSQL = parserConfig.dateSQL || {"date" : true, "time" : true, "timestamp" : true}, backslashStringEscapes = parserConfig.backslashStringEscapes !== false, brackets = parserConfig.brackets || /^[\{}\(\)\[\]]/, punctuation = parserConfig.punctuation || /^[;.,:]/ function tokenBase(stream, state) { var ch = stream.next(); // call hooks from the mime type if (hooks[ch]) { var result = hooks[ch](stream, state); if (result !== false) return result; } if (support.hexNumber && ((ch == "0" && stream.match(/^[xX][0-9a-fA-F]+/)) || (ch == "x" || ch == "X") && stream.match(/^'[0-9a-fA-F]+'/))) { // hex // ref: http://dev.mysql.com/doc/refman/5.5/en/hexadecimal-literals.html return "number"; } else if (support.binaryNumber && (((ch == "b" || ch == "B") && stream.match(/^'[01]+'/)) || (ch == "0" && stream.match(/^b[01]+/)))) { // bitstring // ref: http://dev.mysql.com/doc/refman/5.5/en/bit-field-literals.html return "number"; } else if (ch.charCodeAt(0) > 47 && ch.charCodeAt(0) < 58) { // numbers // ref: http://dev.mysql.com/doc/refman/5.5/en/number-literals.html stream.match(/^[0-9]*(\.[0-9]+)?([eE][-+]?[0-9]+)?/); support.decimallessFloat && stream.match(/^\.(?!\.)/); return "number"; } else if (ch == "?" && (stream.eatSpace() || stream.eol() || stream.eat(";"))) { // placeholders return "variable-3"; } else if (ch == "'" || (ch == '"' && support.doubleQuote)) { // strings // ref: http://dev.mysql.com/doc/refman/5.5/en/string-literals.html state.tokenize = tokenLiteral(ch); return state.tokenize(stream, state); } else if ((((support.nCharCast && (ch == "n" || ch == "N")) || (support.charsetCast && ch == "_" && stream.match(/[a-z][a-z0-9]*/i))) && (stream.peek() == "'" || stream.peek() == '"'))) { // charset casting: _utf8'str', N'str', n'str' // ref: http://dev.mysql.com/doc/refman/5.5/en/string-literals.html return "keyword"; } else if (support.escapeConstant && (ch == "e" || ch == "E") && (stream.peek() == "'" || (stream.peek() == '"' && support.doubleQuote))) { // escape constant: E'str', e'str' // ref: https://www.postgresql.org/docs/current/sql-syntax-lexical.html#SQL-SYNTAX-STRINGS-ESCAPE state.tokenize = function(stream, state) { return (state.tokenize = tokenLiteral(stream.next(), true))(stream, state); } return "keyword"; } else if (support.commentSlashSlash && ch == "/" && stream.eat("/")) { // 1-line comment stream.skipToEnd(); return "comment"; } else if ((support.commentHash && ch == "#") || (ch == "-" && stream.eat("-") && (!support.commentSpaceRequired || stream.eat(" ")))) { // 1-line comments // ref: https://kb.askmonty.org/en/comment-syntax/ stream.skipToEnd(); return "comment"; } else if (ch == "/" && stream.eat("*")) { // multi-line comments // ref: https://kb.askmonty.org/en/comment-syntax/ state.tokenize = tokenComment(1); return state.tokenize(stream, state); } else if (ch == ".") { // .1 for 0.1 if (support.zerolessFloat && stream.match(/^(?:\d+(?:e[+-]?\d+)?)/i)) return "number"; if (stream.match(/^\.+/)) return null // .table_name (ODBC) // // ref: http://dev.mysql.com/doc/refman/5.6/en/identifier-qualifiers.html if (support.ODBCdotTable && stream.match(/^[\w\d_$#]+/)) return "variable-2"; } else if (operatorChars.test(ch)) { // operators stream.eatWhile(operatorChars); return "operator"; } else if (brackets.test(ch)) { // brackets return "bracket"; } else if (punctuation.test(ch)) { // punctuation stream.eatWhile(punctuation); return "punctuation"; } else if (ch == '{' && (stream.match(/^( )*(d|D|t|T|ts|TS)( )*'[^']*'( )*}/) || stream.match(/^( )*(d|D|t|T|ts|TS)( )*"[^"]*"( )*}/))) { // dates (weird ODBC syntax) // ref: http://dev.mysql.com/doc/refman/5.5/en/date-and-time-literals.html return "number"; } else { stream.eatWhile(/^[_\w\d]/); var word = stream.current().toLowerCase(); // dates (standard SQL syntax) // ref: http://dev.mysql.com/doc/refman/5.5/en/date-and-time-literals.html if (dateSQL.hasOwnProperty(word) && (stream.match(/^( )+'[^']*'/) || stream.match(/^( )+"[^"]*"/))) return "number"; if (atoms.hasOwnProperty(word)) return "atom"; if (builtin.hasOwnProperty(word)) return "builtin"; if (keywords.hasOwnProperty(word)) return "keyword"; if (client.hasOwnProperty(word)) return "string-2"; return null; } } // 'string', with char specified in quote escaped by '\' function tokenLiteral(quote, backslashEscapes) { return function(stream, state) { var escaped = false, ch; while ((ch = stream.next()) != null) { if (ch == quote && !escaped) { state.tokenize = tokenBase; break; } escaped = (backslashStringEscapes || backslashEscapes) && !escaped && ch == "\\"; } return "string"; }; } function tokenComment(depth) { return function(stream, state) { var m = stream.match(/^.*?(\/\*|\*\/)/) if (!m) stream.skipToEnd() else if (m[1] == "/*") state.tokenize = tokenComment(depth + 1) else if (depth > 1) state.tokenize = tokenComment(depth - 1) else state.tokenize = tokenBase return "comment" } } function pushContext(stream, state, type) { state.context = { prev: state.context, indent: stream.indentation(), col: stream.column(), type: type }; } function popContext(state) { state.indent = state.context.indent; state.context = state.context.prev; } return { startState: function() { return {tokenize: tokenBase, context: null}; }, token: function(stream, state) { if (stream.sol()) { if (state.context && state.context.align == null) state.context.align = false; } if (state.tokenize == tokenBase && stream.eatSpace()) return null; var style = state.tokenize(stream, state); if (style == "comment") return style; if (state.context && state.context.align == null) state.context.align = true; var tok = stream.current(); if (tok == "(") pushContext(stream, state, ")"); else if (tok == "[") pushContext(stream, state, "]"); else if (state.context && state.context.type == tok) popContext(state); return style; }, indent: function(state, textAfter) { var cx = state.context; if (!cx) return CodeMirror.Pass; var closing = textAfter.charAt(0) == cx.type; if (cx.align) return cx.col + (closing ? 0 : 1); else return cx.indent + (closing ? 0 : config.indentUnit); }, blockCommentStart: "/*", blockCommentEnd: "*/", lineComment: support.commentSlashSlash ? "//" : support.commentHash ? "#" : "--", closeBrackets: "()[]{}''\"\"``" }; }); // `identifier` function hookIdentifier(stream) { // MySQL/MariaDB identifiers // ref: http://dev.mysql.com/doc/refman/5.6/en/identifier-qualifiers.html var ch; while ((ch = stream.next()) != null) { if (ch == "`" && !stream.eat("`")) return "variable-2"; } stream.backUp(stream.current().length - 1); return stream.eatWhile(/\w/) ? "variable-2" : null; } // "identifier" function hookIdentifierDoublequote(stream) { // Standard SQL /SQLite identifiers // ref: http://web.archive.org/web/20160813185132/http://savage.net.au/SQL/sql-99.bnf.html#delimited%20identifier // ref: http://sqlite.org/lang_keywords.html var ch; while ((ch = stream.next()) != null) { if (ch == "\"" && !stream.eat("\"")) return "variable-2"; } stream.backUp(stream.current().length - 1); return stream.eatWhile(/\w/) ? "variable-2" : null; } // variable token function hookVar(stream) { // variables // @@prefix.varName @varName // varName can be quoted with ` or ' or " // ref: http://dev.mysql.com/doc/refman/5.5/en/user-variables.html if (stream.eat("@")) { stream.match(/^session\./); stream.match(/^local\./); stream.match(/^global\./); } if (stream.eat("'")) { stream.match(/^.*'/); return "variable-2"; } else if (stream.eat('"')) { stream.match(/^.*"/); return "variable-2"; } else if (stream.eat("`")) { stream.match(/^.*`/); return "variable-2"; } else if (stream.match(/^[0-9a-zA-Z$\.\_]+/)) { return "variable-2"; } return null; }; // short client keyword token function hookClient(stream) { // \N means NULL // ref: http://dev.mysql.com/doc/refman/5.5/en/null-values.html if (stream.eat("N")) { return "atom"; } // \g, etc // ref: http://dev.mysql.com/doc/refman/5.5/en/mysql-commands.html return stream.match(/^[a-zA-Z.#!?]/) ? "variable-2" : null; } // these keywords are used by all SQL dialects (however, a mode can still overwrite it) var sqlKeywords = "alter and as asc between by count create delete desc distinct drop from group having in insert into is join like not on or order select set table union update values where limit "; // turn a space-separated list into an array function set(str) { var obj = {}, words = str.split(" "); for (var i = 0; i < words.length; ++i) obj[words[i]] = true; return obj; } var defaultBuiltin = "bool boolean bit blob enum long longblob longtext medium mediumblob mediumint mediumtext time timestamp tinyblob tinyint tinytext text bigint int int1 int2 int3 int4 int8 integer float float4 float8 double char varbinary varchar varcharacter precision real date datetime year unsigned signed decimal numeric" // A generic SQL Mode. It's not a standard, it just try to support what is generally supported CodeMirror.defineMIME("text/x-sql", { name: "sql", keywords: set(sqlKeywords + "begin"), builtin: set(defaultBuiltin), atoms: set("false true null unknown"), dateSQL: set("date time timestamp"), support: set("ODBCdotTable doubleQuote binaryNumber hexNumber") }); CodeMirror.defineMIME("text/x-mssql", { name: "sql", client: set("$partition binary_checksum checksum connectionproperty context_info current_request_id error_line error_message error_number error_procedure error_severity error_state formatmessage get_filestream_transaction_context getansinull host_id host_name isnull isnumeric min_active_rowversion newid newsequentialid rowcount_big xact_state object_id"), keywords: set(sqlKeywords + "begin trigger proc view index for add constraint key primary foreign collate clustered nonclustered declare exec go if use index holdlock nolock nowait paglock readcommitted readcommittedlock readpast readuncommitted repeatableread rowlock serializable snapshot tablock tablockx updlock with"), builtin: set("bigint numeric bit smallint decimal smallmoney int tinyint money float real char varchar text nchar nvarchar ntext binary varbinary image cursor timestamp hierarchyid uniqueidentifier sql_variant xml table "), atoms: set("is not null like and or in left right between inner outer join all any some cross unpivot pivot exists"), operatorChars: /^[*+\-%<>!=^\&|\/]/, brackets: /^[\{}\(\)]/, punctuation: /^[;.,:/]/, backslashStringEscapes: false, dateSQL: set("date datetimeoffset datetime2 smalldatetime datetime time"), hooks: { "@": hookVar } }); CodeMirror.defineMIME("text/x-mysql", { name: "sql", client: set("charset clear connect edit ego exit go help nopager notee nowarning pager print prompt quit rehash source status system tee"), keywords: set(sqlKeywords + "accessible action add after algorithm all analyze asensitive at authors auto_increment autocommit avg avg_row_length before binary binlog both btree cache call cascade cascaded case catalog_name chain change changed character check checkpoint checksum class_origin client_statistics close coalesce code collate collation collations column columns comment commit committed completion concurrent condition connection consistent constraint contains continue contributors convert cross current current_date current_time current_timestamp current_user cursor data database databases day_hour day_microsecond day_minute day_second deallocate dec declare default delay_key_write delayed delimiter des_key_file describe deterministic dev_pop dev_samp deviance diagnostics directory disable discard distinctrow div dual dumpfile each elseif enable enclosed end ends engine engines enum errors escape escaped even event events every execute exists exit explain extended fast fetch field fields first flush for force foreign found_rows full fulltext function general get global grant grants group group_concat handler hash help high_priority hosts hour_microsecond hour_minute hour_second if ignore ignore_server_ids import index index_statistics infile inner innodb inout insensitive insert_method install interval invoker isolation iterate key keys kill language last leading leave left level limit linear lines list load local localtime localtimestamp lock logs low_priority master master_heartbeat_period master_ssl_verify_server_cert masters match max max_rows maxvalue message_text middleint migrate min min_rows minute_microsecond minute_second mod mode modifies modify mutex mysql_errno natural next no no_write_to_binlog offline offset one online open optimize option optionally out outer outfile pack_keys parser partition partitions password phase plugin plugins prepare preserve prev primary privileges procedure processlist profile profiles purge query quick range read read_write reads real rebuild recover references regexp relaylog release remove rename reorganize repair repeatable replace require resignal restrict resume return returns revoke right rlike rollback rollup row row_format rtree savepoint schedule schema schema_name schemas second_microsecond security sensitive separator serializable server session share show signal slave slow smallint snapshot soname spatial specific sql sql_big_result sql_buffer_result sql_cache sql_calc_found_rows sql_no_cache sql_small_result sqlexception sqlstate sqlwarning ssl start starting starts status std stddev stddev_pop stddev_samp storage straight_join subclass_origin sum suspend table_name table_statistics tables tablespace temporary terminated to trailing transaction trigger triggers truncate uncommitted undo uninstall unique unlock upgrade usage use use_frm user user_resources user_statistics using utc_date utc_time utc_timestamp value variables varying view views warnings when while with work write xa xor year_month zerofill begin do then else loop repeat"), builtin: set("bool boolean bit blob decimal double float long longblob longtext medium mediumblob mediumint mediumtext time timestamp tinyblob tinyint tinytext text bigint int int1 int2 int3 int4 int8 integer float float4 float8 double char varbinary varchar varcharacter precision date datetime year unsigned signed numeric"), atoms: set("false true null unknown"), operatorChars: /^[*+\-%<>!=&|^]/, dateSQL: set("date time timestamp"), support: set("ODBCdotTable decimallessFloat zerolessFloat binaryNumber hexNumber doubleQuote nCharCast charsetCast commentHash commentSpaceRequired"), hooks: { "@": hookVar, "`": hookIdentifier, "\\": hookClient } }); CodeMirror.defineMIME("text/x-mariadb", { name: "sql", client: set("charset clear connect edit ego exit go help nopager notee nowarning pager print prompt quit rehash source status system tee"), keywords: set(sqlKeywords + "accessible action add after algorithm all always analyze asensitive at authors auto_increment autocommit avg avg_row_length before binary binlog both btree cache call cascade cascaded case catalog_name chain change changed character check checkpoint checksum class_origin client_statistics close coalesce code collate collation collations column columns comment commit committed completion concurrent condition connection consistent constraint contains continue contributors convert cross current current_date current_time current_timestamp current_user cursor data database databases day_hour day_microsecond day_minute day_second deallocate dec declare default delay_key_write delayed delimiter des_key_file describe deterministic dev_pop dev_samp deviance diagnostics directory disable discard distinctrow div dual dumpfile each elseif enable enclosed end ends engine engines enum errors escape escaped even event events every execute exists exit explain extended fast fetch field fields first flush for force foreign found_rows full fulltext function general generated get global grant grants group groupby_concat handler hard hash help high_priority hosts hour_microsecond hour_minute hour_second if ignore ignore_server_ids import index index_statistics infile inner innodb inout insensitive insert_method install interval invoker isolation iterate key keys kill language last leading leave left level limit linear lines list load local localtime localtimestamp lock logs low_priority master master_heartbeat_period master_ssl_verify_server_cert masters match max max_rows maxvalue message_text middleint migrate min min_rows minute_microsecond minute_second mod mode modifies modify mutex mysql_errno natural next no no_write_to_binlog offline offset one online open optimize option optionally out outer outfile pack_keys parser partition partitions password persistent phase plugin plugins prepare preserve prev primary privileges procedure processlist profile profiles purge query quick range read read_write reads real rebuild recover references regexp relaylog release remove rename reorganize repair repeatable replace require resignal restrict resume return returns revoke right rlike rollback rollup row row_format rtree savepoint schedule schema schema_name schemas second_microsecond security sensitive separator serializable server session share show shutdown signal slave slow smallint snapshot soft soname spatial specific sql sql_big_result sql_buffer_result sql_cache sql_calc_found_rows sql_no_cache sql_small_result sqlexception sqlstate sqlwarning ssl start starting starts status std stddev stddev_pop stddev_samp storage straight_join subclass_origin sum suspend table_name table_statistics tables tablespace temporary terminated to trailing transaction trigger triggers truncate uncommitted undo uninstall unique unlock upgrade usage use use_frm user user_resources user_statistics using utc_date utc_time utc_timestamp value variables varying view views virtual warnings when while with work write xa xor year_month zerofill begin do then else loop repeat"), builtin: set("bool boolean bit blob decimal double float long longblob longtext medium mediumblob mediumint mediumtext time timestamp tinyblob tinyint tinytext text bigint int int1 int2 int3 int4 int8 integer float float4 float8 double char varbinary varchar varcharacter precision date datetime year unsigned signed numeric"), atoms: set("false true null unknown"), operatorChars: /^[*+\-%<>!=&|^]/, dateSQL: set("date time timestamp"), support: set("ODBCdotTable decimallessFloat zerolessFloat binaryNumber hexNumber doubleQuote nCharCast charsetCast commentHash commentSpaceRequired"), hooks: { "@": hookVar, "`": hookIdentifier, "\\": hookClient } }); // provided by the phpLiteAdmin project - phpliteadmin.org CodeMirror.defineMIME("text/x-sqlite", { name: "sql", // commands of the official SQLite client, ref: https://www.sqlite.org/cli.html#dotcmd client: set("auth backup bail binary changes check clone databases dbinfo dump echo eqp exit explain fullschema headers help import imposter indexes iotrace limit lint load log mode nullvalue once open output print prompt quit read restore save scanstats schema separator session shell show stats system tables testcase timeout timer trace vfsinfo vfslist vfsname width"), // ref: http://sqlite.org/lang_keywords.html keywords: set(sqlKeywords + "abort action add after all analyze attach autoincrement before begin cascade case cast check collate column commit conflict constraint cross current_date current_time current_timestamp database default deferrable deferred detach each else end escape except exclusive exists explain fail for foreign full glob if ignore immediate index indexed initially inner instead intersect isnull key left limit match natural no notnull null of offset outer plan pragma primary query raise recursive references regexp reindex release rename replace restrict right rollback row savepoint temp temporary then to transaction trigger unique using vacuum view virtual when with without"), // SQLite is weakly typed, ref: http://sqlite.org/datatype3.html. This is just a list of some common types. builtin: set("bool boolean bit blob decimal double float long longblob longtext medium mediumblob mediumint mediumtext time timestamp tinyblob tinyint tinytext text clob bigint int int2 int8 integer float double char varchar date datetime year unsigned signed numeric real"), // ref: http://sqlite.org/syntax/literal-value.html atoms: set("null current_date current_time current_timestamp"), // ref: http://sqlite.org/lang_expr.html#binaryops operatorChars: /^[*+\-%<>!=&|/~]/, // SQLite is weakly typed, ref: http://sqlite.org/datatype3.html. This is just a list of some common types. dateSQL: set("date time timestamp datetime"), support: set("decimallessFloat zerolessFloat"), identifierQuote: "\"", //ref: http://sqlite.org/lang_keywords.html hooks: { // bind-parameters ref:http://sqlite.org/lang_expr.html#varparam "@": hookVar, ":": hookVar, "?": hookVar, "$": hookVar, // The preferred way to escape Identifiers is using double quotes, ref: http://sqlite.org/lang_keywords.html "\"": hookIdentifierDoublequote, // there is also support for backtics, ref: http://sqlite.org/lang_keywords.html "`": hookIdentifier } }); // the query language used by Apache Cassandra is called CQL, but this mime type // is called Cassandra to avoid confusion with Contextual Query Language CodeMirror.defineMIME("text/x-cassandra", { name: "sql", client: { }, keywords: set("add all allow alter and any apply as asc authorize batch begin by clustering columnfamily compact consistency count create custom delete desc distinct drop each_quorum exists filtering from grant if in index insert into key keyspace keyspaces level limit local_one local_quorum modify nan norecursive nosuperuser not of on one order password permission permissions primary quorum rename revoke schema select set storage superuser table three to token truncate ttl two type unlogged update use user users using values where with writetime"), builtin: set("ascii bigint blob boolean counter decimal double float frozen inet int list map static text timestamp timeuuid tuple uuid varchar varint"), atoms: set("false true infinity NaN"), operatorChars: /^[<>=]/, dateSQL: { }, support: set("commentSlashSlash decimallessFloat"), hooks: { } }); // this is based on Peter Raganitsch's 'plsql' mode CodeMirror.defineMIME("text/x-plsql", { name: "sql", client: set("appinfo arraysize autocommit autoprint autorecovery autotrace blockterminator break btitle cmdsep colsep compatibility compute concat copycommit copytypecheck define describe echo editfile embedded escape exec execute feedback flagger flush heading headsep instance linesize lno loboffset logsource long longchunksize markup native newpage numformat numwidth pagesize pause pno recsep recsepchar release repfooter repheader serveroutput shiftinout show showmode size spool sqlblanklines sqlcase sqlcode sqlcontinue sqlnumber sqlpluscompatibility sqlprefix sqlprompt sqlterminator suffix tab term termout time timing trimout trimspool ttitle underline verify version wrap"), keywords: set("abort accept access add all alter and any array arraylen as asc assert assign at attributes audit authorization avg base_table begin between binary_integer body boolean by case cast char char_base check close cluster clusters colauth column comment commit compress connect connected constant constraint crash create current currval cursor data_base database date dba deallocate debugoff debugon decimal declare default definition delay delete desc digits dispose distinct do drop else elseif elsif enable end entry escape exception exception_init exchange exclusive exists exit external fast fetch file for force form from function generic goto grant group having identified if immediate in increment index indexes indicator initial initrans insert interface intersect into is key level library like limited local lock log logging long loop master maxextents maxtrans member minextents minus mislabel mode modify multiset new next no noaudit nocompress nologging noparallel not nowait number_base object of off offline on online only open option or order out package parallel partition pctfree pctincrease pctused pls_integer positive positiven pragma primary prior private privileges procedure public raise range raw read rebuild record ref references refresh release rename replace resource restrict return returning returns reverse revoke rollback row rowid rowlabel rownum rows run savepoint schema segment select separate session set share snapshot some space split sql start statement storage subtype successful synonym tabauth table tables tablespace task terminate then to trigger truncate type union unique unlimited unrecoverable unusable update use using validate value values variable view views when whenever where while with work"), builtin: set("abs acos add_months ascii asin atan atan2 average bfile bfilename bigserial bit blob ceil character chartorowid chr clob concat convert cos cosh count dec decode deref dual dump dup_val_on_index empty error exp false float floor found glb greatest hextoraw initcap instr instrb int integer isopen last_day least length lengthb ln lower lpad ltrim lub make_ref max min mlslabel mod months_between natural naturaln nchar nclob new_time next_day nextval nls_charset_decl_len nls_charset_id nls_charset_name nls_initcap nls_lower nls_sort nls_upper nlssort no_data_found notfound null number numeric nvarchar2 nvl others power rawtohex real reftohex round rowcount rowidtochar rowtype rpad rtrim serial sign signtype sin sinh smallint soundex sqlcode sqlerrm sqrt stddev string substr substrb sum sysdate tan tanh to_char text to_date to_label to_multi_byte to_number to_single_byte translate true trunc uid unlogged upper user userenv varchar varchar2 variance varying vsize xml"), operatorChars: /^[*\/+\-%<>!=~]/, dateSQL: set("date time timestamp"), support: set("doubleQuote nCharCast zerolessFloat binaryNumber hexNumber") }); // Created to support specific hive keywords CodeMirror.defineMIME("text/x-hive", { name: "sql", keywords: set("select alter $elem$ $key$ $value$ add after all analyze and archive as asc before between binary both bucket buckets by cascade case cast change cluster clustered clusterstatus collection column columns comment compute concatenate continue create cross cursor data database databases dbproperties deferred delete delimited desc describe directory disable distinct distribute drop else enable end escaped exclusive exists explain export extended external fetch fields fileformat first format formatted from full function functions grant group having hold_ddltime idxproperties if import in index indexes inpath inputdriver inputformat insert intersect into is items join keys lateral left like limit lines load local location lock locks mapjoin materialized minus msck no_drop nocompress not of offline on option or order out outer outputdriver outputformat overwrite partition partitioned partitions percent plus preserve procedure purge range rcfile read readonly reads rebuild recordreader recordwriter recover reduce regexp rename repair replace restrict revoke right rlike row schema schemas semi sequencefile serde serdeproperties set shared show show_database sort sorted ssl statistics stored streamtable table tables tablesample tblproperties temporary terminated textfile then tmp to touch transform trigger unarchive undo union uniquejoin unlock update use using utc utc_tmestamp view when where while with admin authorization char compact compactions conf cube current current_date current_timestamp day decimal defined dependency directories elem_type exchange file following for grouping hour ignore inner interval jar less logical macro minute month more none noscan over owner partialscan preceding pretty principals protection reload rewrite role roles rollup rows second server sets skewed transactions truncate unbounded unset uri user values window year"), builtin: set("bool boolean long timestamp tinyint smallint bigint int float double date datetime unsigned string array struct map uniontype key_type utctimestamp value_type varchar"), atoms: set("false true null unknown"), operatorChars: /^[*+\-%<>!=]/, dateSQL: set("date timestamp"), support: set("ODBCdotTable doubleQuote binaryNumber hexNumber") }); CodeMirror.defineMIME("text/x-pgsql", { name: "sql", client: set("source"), // For PostgreSQL - https://www.postgresql.org/docs/11/sql-keywords-appendix.html // For pl/pgsql lang - https://github.com/postgres/postgres/blob/REL_11_2/src/pl/plpgsql/src/pl_scanner.c keywords: set(sqlKeywords + "a abort abs absent absolute access according action ada add admin after aggregate alias all allocate also alter always analyse analyze and any are array array_agg array_max_cardinality as asc asensitive assert assertion assignment asymmetric at atomic attach attribute attributes authorization avg backward base64 before begin begin_frame begin_partition bernoulli between bigint binary bit bit_length blob blocked bom boolean both breadth by c cache call called cardinality cascade cascaded case cast catalog catalog_name ceil ceiling chain char char_length character character_length character_set_catalog character_set_name character_set_schema characteristics characters check checkpoint class class_origin clob close cluster coalesce cobol collate collation collation_catalog collation_name collation_schema collect column column_name columns command_function command_function_code comment comments commit committed concurrently condition condition_number configuration conflict connect connection connection_name constant constraint constraint_catalog constraint_name constraint_schema constraints constructor contains content continue control conversion convert copy corr corresponding cost count covar_pop covar_samp create cross csv cube cume_dist current current_catalog current_date current_default_transform_group current_path current_role current_row current_schema current_time current_timestamp current_transform_group_for_type current_user cursor cursor_name cycle data database datalink datatype date datetime_interval_code datetime_interval_precision day db deallocate debug dec decimal declare default defaults deferrable deferred defined definer degree delete delimiter delimiters dense_rank depends depth deref derived desc describe descriptor detach detail deterministic diagnostics dictionary disable discard disconnect dispatch distinct dlnewcopy dlpreviouscopy dlurlcomplete dlurlcompleteonly dlurlcompletewrite dlurlpath dlurlpathonly dlurlpathwrite dlurlscheme dlurlserver dlvalue do document domain double drop dump dynamic dynamic_function dynamic_function_code each element else elseif elsif empty enable encoding encrypted end end_frame end_partition endexec enforced enum equals errcode error escape event every except exception exclude excluding exclusive exec execute exists exit exp explain expression extension external extract false family fetch file filter final first first_value flag float floor following for force foreach foreign fortran forward found frame_row free freeze from fs full function functions fusion g general generated get global go goto grant granted greatest group grouping groups handler having header hex hierarchy hint hold hour id identity if ignore ilike immediate immediately immutable implementation implicit import in include including increment indent index indexes indicator info inherit inherits initially inline inner inout input insensitive insert instance instantiable instead int integer integrity intersect intersection interval into invoker is isnull isolation join k key key_member key_type label lag language large last last_value lateral lead leading leakproof least left length level library like like_regex limit link listen ln load local localtime localtimestamp location locator lock locked log logged loop lower m map mapping match matched materialized max max_cardinality maxvalue member merge message message_length message_octet_length message_text method min minute minvalue mod mode modifies module month more move multiset mumps name names namespace national natural nchar nclob nesting new next nfc nfd nfkc nfkd nil no none normalize normalized not nothing notice notify notnull nowait nth_value ntile null nullable nullif nulls number numeric object occurrences_regex octet_length octets of off offset oids old on only open operator option options or order ordering ordinality others out outer output over overlaps overlay overriding owned owner p pad parallel parameter parameter_mode parameter_name parameter_ordinal_position parameter_specific_catalog parameter_specific_name parameter_specific_schema parser partial partition pascal passing passthrough password path percent percent_rank percentile_cont percentile_disc perform period permission pg_context pg_datatype_name pg_exception_context pg_exception_detail pg_exception_hint placing plans pli policy portion position position_regex power precedes preceding precision prepare prepared preserve primary print_strict_params prior privileges procedural procedure procedures program public publication query quote raise range rank read reads real reassign recheck recovery recursive ref references referencing refresh regr_avgx regr_avgy regr_count regr_intercept regr_r2 regr_slope regr_sxx regr_sxy regr_syy reindex relative release rename repeatable replace replica requiring reset respect restart restore restrict result result_oid return returned_cardinality returned_length returned_octet_length returned_sqlstate returning returns reverse revoke right role rollback rollup routine routine_catalog routine_name routine_schema routines row row_count row_number rows rowtype rule savepoint scale schema schema_name schemas scope scope_catalog scope_name scope_schema scroll search second section security select selective self sensitive sequence sequences serializable server server_name session session_user set setof sets share show similar simple size skip slice smallint snapshot some source space specific specific_name specifictype sql sqlcode sqlerror sqlexception sqlstate sqlwarning sqrt stable stacked standalone start state statement static statistics stddev_pop stddev_samp stdin stdout storage strict strip structure style subclass_origin submultiset subscription substring substring_regex succeeds sum symmetric sysid system system_time system_user t table table_name tables tablesample tablespace temp template temporary text then ties time timestamp timezone_hour timezone_minute to token top_level_count trailing transaction transaction_active transactions_committed transactions_rolled_back transform transforms translate translate_regex translation treat trigger trigger_catalog trigger_name trigger_schema trim trim_array true truncate trusted type types uescape unbounded uncommitted under unencrypted union unique unknown unlink unlisten unlogged unnamed unnest until untyped update upper uri usage use_column use_variable user user_defined_type_catalog user_defined_type_code user_defined_type_name user_defined_type_schema using vacuum valid validate validator value value_of values var_pop var_samp varbinary varchar variable_conflict variadic varying verbose version versioning view views volatile warning when whenever where while whitespace width_bucket window with within without work wrapper write xml xmlagg xmlattributes xmlbinary xmlcast xmlcomment xmlconcat xmldeclaration xmldocument xmlelement xmlexists xmlforest xmliterate xmlnamespaces xmlparse xmlpi xmlquery xmlroot xmlschema xmlserialize xmltable xmltext xmlvalidate year yes zone"), // https://www.postgresql.org/docs/11/datatype.html builtin: set("bigint int8 bigserial serial8 bit varying varbit boolean bool box bytea character char varchar cidr circle date double precision float8 inet integer int int4 interval json jsonb line lseg macaddr macaddr8 money numeric decimal path pg_lsn point polygon real float4 smallint int2 smallserial serial2 serial serial4 text time without zone with timetz timestamp timestamptz tsquery tsvector txid_snapshot uuid xml"), atoms: set("false true null unknown"), operatorChars: /^[*\/+\-%<>!=&|^\/#@?~]/, backslashStringEscapes: false, dateSQL: set("date time timestamp"), support: set("ODBCdotTable decimallessFloat zerolessFloat binaryNumber hexNumber nCharCast charsetCast escapeConstant") }); // Google's SQL-like query language, GQL CodeMirror.defineMIME("text/x-gql", { name: "sql", keywords: set("ancestor and asc by contains desc descendant distinct from group has in is limit offset on order select superset where"), atoms: set("false true"), builtin: set("blob datetime first key __key__ string integer double boolean null"), operatorChars: /^[*+\-%<>!=]/ }); // Greenplum CodeMirror.defineMIME("text/x-gpsql", { name: "sql", client: set("source"), //https://github.com/greenplum-db/gpdb/blob/master/src/include/parser/kwlist.h keywords: set("abort absolute access action active add admin after aggregate all also alter always analyse analyze and any array as asc assertion assignment asymmetric at authorization backward before begin between bigint binary bit boolean both by cache called cascade cascaded case cast chain char character characteristics check checkpoint class close cluster coalesce codegen collate column comment commit committed concurrency concurrently configuration connection constraint constraints contains content continue conversion copy cost cpu_rate_limit create createdb createexttable createrole createuser cross csv cube current current_catalog current_date current_role current_schema current_time current_timestamp current_user cursor cycle data database day deallocate dec decimal declare decode default defaults deferrable deferred definer delete delimiter delimiters deny desc dictionary disable discard distinct distributed do document domain double drop dxl each else enable encoding encrypted end enum errors escape every except exchange exclude excluding exclusive execute exists explain extension external extract false family fetch fields filespace fill filter first float following for force foreign format forward freeze from full function global grant granted greatest group group_id grouping handler hash having header hold host hour identity if ignore ilike immediate immutable implicit in including inclusive increment index indexes inherit inherits initially inline inner inout input insensitive insert instead int integer intersect interval into invoker is isnull isolation join key language large last leading least left level like limit list listen load local localtime localtimestamp location lock log login mapping master match maxvalue median merge minute minvalue missing mode modifies modify month move name names national natural nchar new newline next no nocreatedb nocreateexttable nocreaterole nocreateuser noinherit nologin none noovercommit nosuperuser not nothing notify notnull nowait null nullif nulls numeric object of off offset oids old on only operator option options or order ordered others out outer over overcommit overlaps overlay owned owner parser partial partition partitions passing password percent percentile_cont percentile_disc placing plans position preceding precision prepare prepared preserve primary prior privileges procedural procedure protocol queue quote randomly range read readable reads real reassign recheck recursive ref references reindex reject relative release rename repeatable replace replica reset resource restart restrict returning returns revoke right role rollback rollup rootpartition row rows rule savepoint scatter schema scroll search second security segment select sequence serializable session session_user set setof sets share show similar simple smallint some split sql stable standalone start statement statistics stdin stdout storage strict strip subpartition subpartitions substring superuser symmetric sysid system table tablespace temp template temporary text then threshold ties time timestamp to trailing transaction treat trigger trim true truncate trusted type unbounded uncommitted unencrypted union unique unknown unlisten until update user using vacuum valid validation validator value values varchar variadic varying verbose version view volatile web when where whitespace window with within without work writable write xml xmlattributes xmlconcat xmlelement xmlexists xmlforest xmlparse xmlpi xmlroot xmlserialize year yes zone"), builtin: set("bigint int8 bigserial serial8 bit varying varbit boolean bool box bytea character char varchar cidr circle date double precision float float8 inet integer int int4 interval json jsonb line lseg macaddr macaddr8 money numeric decimal path pg_lsn point polygon real float4 smallint int2 smallserial serial2 serial serial4 text time without zone with timetz timestamp timestamptz tsquery tsvector txid_snapshot uuid xml"), atoms: set("false true null unknown"), operatorChars: /^[*+\-%<>!=&|^\/#@?~]/, dateSQL: set("date time timestamp"), support: set("ODBCdotTable decimallessFloat zerolessFloat binaryNumber hexNumber nCharCast charsetCast") }); // Spark SQL CodeMirror.defineMIME("text/x-sparksql", { name: "sql", keywords: set("add after all alter analyze and anti archive array as asc at between bucket buckets by cache cascade case cast change clear cluster clustered codegen collection column columns comment commit compact compactions compute concatenate cost create cross cube current current_date current_timestamp database databases datata dbproperties defined delete delimited deny desc describe dfs directories distinct distribute drop else end escaped except exchange exists explain export extended external false fields fileformat first following for format formatted from full function functions global grant group grouping having if ignore import in index indexes inner inpath inputformat insert intersect interval into is items join keys last lateral lazy left like limit lines list load local location lock locks logical macro map minus msck natural no not null nulls of on optimize option options or order out outer outputformat over overwrite partition partitioned partitions percent preceding principals purge range recordreader recordwriter recover reduce refresh regexp rename repair replace reset restrict revoke right rlike role roles rollback rollup row rows schema schemas select semi separated serde serdeproperties set sets show skewed sort sorted start statistics stored stratify struct table tables tablesample tblproperties temp temporary terminated then to touch transaction transactions transform true truncate unarchive unbounded uncache union unlock unset use using values view when where window with"), builtin: set("tinyint smallint int bigint boolean float double string binary timestamp decimal array map struct uniontype delimited serde sequencefile textfile rcfile inputformat outputformat"), atoms: set("false true null"), operatorChars: /^[*\/+\-%<>!=~&|^]/, dateSQL: set("date time timestamp"), support: set("ODBCdotTable doubleQuote zerolessFloat") }); // Esper CodeMirror.defineMIME("text/x-esper", { name: "sql", client: set("source"), // http://www.espertech.com/esper/release-5.5.0/esper-reference/html/appendix_keywords.html keywords: set("alter and as asc between by count create delete desc distinct drop from group having in insert into is join like not on or order select set table union update values where limit after all and as at asc avedev avg between by case cast coalesce count create current_timestamp day days delete define desc distinct else end escape events every exists false first from full group having hour hours in inner insert instanceof into irstream is istream join last lastweekday left limit like max match_recognize matches median measures metadatasql min minute minutes msec millisecond milliseconds not null offset on or order outer output partition pattern prev prior regexp retain-union retain-intersection right rstream sec second seconds select set some snapshot sql stddev sum then true unidirectional until update variable weekday when where window"), builtin: {}, atoms: set("false true null"), operatorChars: /^[*+\-%<>!=&|^\/#@?~]/, dateSQL: set("time"), support: set("decimallessFloat zerolessFloat binaryNumber hexNumber") }); }); /* How Properties of Mime Types are used by SQL Mode ================================================= keywords: A list of keywords you want to be highlighted. builtin: A list of builtin types you want to be highlighted (if you want types to be of class "builtin" instead of "keyword"). operatorChars: All characters that must be handled as operators. client: Commands parsed and executed by the client (not the server). support: A list of supported syntaxes which are not common, but are supported by more than 1 DBMS. * ODBCdotTable: .tableName * zerolessFloat: .1 * doubleQuote * nCharCast: N'string' * charsetCast: _utf8'string' * commentHash: use # char for comments * commentSlashSlash: use // for comments * commentSpaceRequired: require a space after -- for comments atoms: Keywords that must be highlighted as atoms,. Some DBMS's support more atoms than others: UNKNOWN, INFINITY, UNDERFLOW, NaN... dateSQL: Used for date/time SQL standard syntax, because not all DBMS's support same temporal types. */ index.html 0000644 00000006150 15030146453 0006544 0 ustar 00 <!doctype html> <title>CodeMirror: SQL Mode for CodeMirror</title> <meta charset="utf-8"/> <link rel=stylesheet href="../../doc/docs.css"> <link rel="stylesheet" href="../../lib/codemirror.css" /> <script src="../../lib/codemirror.js"></script> <script src="../../addon/edit/matchbrackets.js"></script> <script src="sql.js"></script> <link rel="stylesheet" href="../../addon/hint/show-hint.css" /> <script src="../../addon/hint/show-hint.js"></script> <script src="../../addon/hint/sql-hint.js"></script> <style> .CodeMirror { border-top: 1px solid black; border-bottom: 1px solid black; } </style> <div id=nav> <a href="https://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png" alt=""></a> <ul> <li><a href="../../index.html">Home</a> <li><a href="../../doc/manual.html">Manual</a> <li><a href="https://github.com/codemirror/codemirror">Code</a> </ul> <ul> <li><a href="../index.html">Language modes</a> <li><a class=active href="#">SQL Mode for CodeMirror</a> </ul> </div> <article> <h2>SQL Mode for CodeMirror</h2> <form> <textarea id="code" name="code">-- SQL Mode for CodeMirror SELECT SQL_NO_CACHE DISTINCT @var1 AS `val1`, @'val2', @global.'sql_mode', 1.1 AS `float_val`, .14 AS `another_float`, 0.09e3 AS `int_with_esp`, 0xFA5 AS `hex`, x'fa5' AS `hex2`, 0b101 AS `bin`, b'101' AS `bin2`, DATE '1994-01-01' AS `sql_date`, { T "1994-01-01" } AS `odbc_date`, 'my string', _utf8'your string', N'her string', TRUE, FALSE, UNKNOWN FROM DUAL -- space needed after '--' # 1 line comment /* multiline comment! */ LIMIT 1 OFFSET 0; </textarea> </form> <p><strong>MIME types defined:</strong> <code><a href="?mime=text/x-sql">text/x-sql</a></code>, <code><a href="?mime=text/x-mysql">text/x-mysql</a></code>, <code><a href="?mime=text/x-mariadb">text/x-mariadb</a></code>, <code><a href="?mime=text/x-cassandra">text/x-cassandra</a></code>, <code><a href="?mime=text/x-plsql">text/x-plsql</a></code>, <code><a href="?mime=text/x-mssql">text/x-mssql</a></code>, <code><a href="?mime=text/x-hive">text/x-hive</a></code>, <code><a href="?mime=text/x-pgsql">text/x-pgsql</a></code>, <code><a href="?mime=text/x-gql">text/x-gql</a></code>, <code><a href="?mime=text/x-gpsql">text/x-gpsql</a></code>. <code><a href="?mime=text/x-esper">text/x-esper</a></code>. </p> <script> window.onload = function() { var mime = 'text/x-mariadb'; // get mime type if (window.location.href.indexOf('mime=') > -1) { mime = window.location.href.substr(window.location.href.indexOf('mime=') + 5); } window.editor = CodeMirror.fromTextArea(document.getElementById('code'), { mode: mime, indentWithTabs: true, smartIndent: true, lineNumbers: true, matchBrackets : true, autofocus: true, extraKeys: {"Ctrl-Space": "autocomplete"}, hintOptions: {tables: { users: ["name", "score", "birthDate"], countries: ["name", "population", "size"] }} }); }; </script> </article>
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings