|
Server : Apache System : Linux cvar2.toservers.com 3.10.0-962.3.2.lve1.5.73.el7.x86_64 #1 SMP Wed Aug 24 21:31:23 UTC 2022 x86_64 User : njnconst ( 1116) PHP Version : 8.4.18 Disable Function : NONE Directory : /usr/lib64/python2.7/site-packages/django/db/models/sql/ |
Upload File : |
�
r�\c @ s� d Z d d l Z d d l m Z d d l m Z d d l m Z d d l m Z d d l
m Z m Z d d l
m Z d d l m Z d d
l m Z d d l m Z d d l m Z d d
l m Z d d l m Z m Z m Z m Z m Z m Z d d l! m" Z" m# Z# m$ Z$ d d l% m& Z& d d l' m( Z( m) Z) m* Z* m+ Z+ m, Z, m- Z- m. Z. d d l/ m0 Z0 d d g Z1 d e2 f d � � YZ3 d e2 f d � � YZ4 d d � Z5 d � Z6 d � Z7 d � Z8 d S( sW
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.
i����N( t
SortedDict( t
force_text( t Node( t six( t connectionst DEFAULT_DB_ALIAS( t
LOOKUP_SEP( t refs_aggregate( t ExpressionNode( t FieldDoesNotExist( t PathInfo( t
aggregates( t QUERY_TERMSt ORDER_DIRt SINGLEt
ORDER_PATTERNt JoinInfot
SelectInfo( t EmptyResultSett Emptyt MultiJoin( t SQLEvaluator( t WhereNodet
Constraintt EverythingNodet
ExtraWheret ANDt ORt
EmptyWhere( t
FieldErrort Queryt RawQueryc B sP e Z d Z d d � Z d � Z d � Z d � Z d � Z d � Z d � Z
RS( s
A single raw SQL query
c C sR | p d | _ | | _ | | _ d | _ d \ | _ | _ i | _ i | _ d S( Ni ( ( i N( t paramst sqlt usingt Nonet cursort low_markt high_markt extra_selectt aggregate_select( t selfR! R" R ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt __init__' s c C s t | j | d | j �S( NR ( R R! R ( R) R" ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt clone3 s c C s | j j | | � S( s� Convert the database-returned value into a type that is consistent
across database backends.
By default, this defers to the underlying backend operations, but
it can be overridden by Query classes for specific backends.
( t opst convert_values( R) t valuet fieldt
connection( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR- 6 s c C sV | j d k r | j � n t | j j j } g | j j D] } | | d � ^ q< S( Ni ( R$ R# t _execute_queryR R" t
introspectiont table_name_convertert description( R) t convertert column_meta( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt get_columns? s
c C sB | j � t | j j j s/ t | j � } n | j } t | � S( N( R1 R R" t featurest can_use_chunked_readst listR$ t iter( R) t result( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt __iter__F s
c C s d | j t | j � S( Ns <RawQuery: %r>( R! t tupleR ( R) ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt __repr__R s c C s3 t | j j � | _ | j j | j | j � d S( N( R R" R$ t executeR! R ( R) ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR1 U s N( t __name__t
__module__t __doc__R# R* R+ R- R7 R= R? R1 ( ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR " s c B s� e Z d Z d Z d Z d Z e Z e Z d Z
e d � Z d � Z
d � Z d � Z d � Z dI dI d
� Z d � Z dI dI d � Z d
� Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z e d � Z d � Z d d � Z e d � Z! d � Z" d � Z# d � Z$ dJ d � Z% d � Z& d � Z' dI e e dI d � Z( d! � Z) d" � Z* d# � Z+ d$ � Z, e e dI d% � Z- d& � Z. d' � Z/ e d( � Z0 d) � Z1 e e d* � Z2 d+ � Z3 dI e4 e e d, � Z5 d- � Z6 d. � Z7 d/ � Z8 d0 � Z9 dI dI d1 � Z: d2 � Z; d3 � Z< d4 � Z= d5 � Z> d6 � Z? e4 d7 � Z@ d8 � ZA d9 � ZB d: � ZC d; � ZD d< � ZE d= � ZF d> � ZG d? � ZH d@ � ZI dA � ZJ dB � ZK dC � ZL dD � ZM dE � ZN eO eN � ZP dF � ZQ eO eQ � ZR dG � ZS dH � ZT RS(K s
A single SQL query.
s
INNER JOINs LEFT OUTER JOINt Tt SQLCompilerc C s` | | _ i | _ i | _ i | _ i | _ t | _ t | _ t | _ t � | _
t | _ i | _
g | _ g | _ g | _ | � | _ | | _ d | _ | � | _ g | _ d \ | _ | _ t | _ g | _ t | _ t | _ t | _ t � | _ d | _ d | _! d | _" t � | _# d | _$ d | _% d | _& d | _' t � t f | _( d S( Ni i ( i N( ( () t modelt alias_refcountt alias_mapt table_mapt join_mapt Truet default_colst default_orderingt standard_orderingt sett used_aliasest Falset filter_is_stickyt included_inherited_modelst selectt related_select_colst tablest wheret where_classR# t group_byt havingt order_byR% R& t distinctt distinct_fieldst select_for_updatet select_for_update_nowaitt select_relatedR R t aggregate_select_maskt _aggregate_select_cachet max_deptht extrat extra_select_maskt _extra_select_cachet extra_tablest extra_order_byt deferred_loading( R) RF RW ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR* i sF c C s | j � \ } } | | S( s)
Returns 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.
( t sql_with_params( R) R! R ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt __str__� s c C s | j t � j � S( sw
Returns the query as an SQL string and the parameters that will be
subsituted into the query.
( t get_compilerR t as_sql( R) ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyRj � s c C s& | j d | � } | | t | � <| S( Nt memo( R+ t id( R) Rn R< ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt __deepcopy__� s c C s | S( N( ( R) ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt prepare� s c C s� | d k r' | d k r' t d � � n | r: t | } n x- | j j � D] \ } } | j j | � qJ W| j j | j � | | | � S( Ns Need either using or connection( R# t
ValueErrorR R( t itemsR, t check_aggregate_supportt compiler( R) R" R0 t aliast aggregate( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyRl � s
c C s
| j j S( s�
Returns the Options instance (the model._meta) from which to start
processing. Normally, this is self.model._meta, but it can be changed
by subclasses.
( RF t _meta( R) ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt get_meta� s c K s� t � } | p | j | _ | j | _ | j j � | _ | j j � | _ | j j � | _ | j j � | _ | j | _ | j | _ | j
| _
| j j � | _ | j | _ g | _
| j | _ | j j � | _ | j | _ | j d k rd | _ n
| j | _ | j j � | _ | j | _ | j | j | _ | _ | j | _ | j | _ | j | _ | j | _ | j | _ g | _
| j j � | _ | j d k r�d | _ n | j j � | _ d | _ | j | _ | j! j � | _! | j" d k r
d | _" n | j" j � | _" | j# d k r:d | _# n | j# j � | _# | j$ | _$ | j% | _% t j | j& d � | j& d f | _& | j' r�| j( r�| j( j � | _( n t) � | _( t* | _' | j+ j, | � t- | d � r�| j. � n | S( s�
Creates a copy of the current instance. The 'kwargs' parameter can be
used by clients to update attributes after copying has taken place.
i i t _setup_queryN(/ R t __class__RF RG t copyRH RI RJ RL RM RN RS RT RU RV RW R+ RX RY R# RZ R[ R% R& R\ R] R^ R_ R` R Ra Rb Rc Rd Re Rf Rg Rh Ri RR RP RO RQ t __dict__t updatet hasattrRz ( R) t klassRn t kwargst obj( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR+ � sh
&
c C s | j j | | � S( s� Convert the database-returned value into a type that is consistent
across database backends.
By default, this defers to the underlying backend operations, but
it can be overridden by Query classes for specific backends.
( R, R- ( R) R. R/ R0 ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR- s c C s] | d k r | j r d S| S| j r0 t | � S| j rC t | � S| j | | j | � Sd S( s� Resolve the value of aggregates returned by the database to
consistent (and reasonable) types.
This is required because of the predisposition of certain backends
to return Decimal and long types when they are not needed.
i N( R# t
is_ordinalt intt is_computedt floatR- R/ ( R) R. Rw R0 ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt resolve_aggregate# s
c
C s� | j s
i S| j d k r� d d l m } | | j � } | j � } x@ | j j � D]/ \ } } | j rW | | j | <| j | =qW qW Wy | j | | � Wq� t
k
r� t d � | j D� � SXn+ | } g | _ t
| _ i | _ | j � | j t � | j � t
| _ t
| _ g | _ | j | � j t � } | d k rog | j j � D] } d ^ qZ} n t g t | j j � | � D]4 \ \ } } } | | j | | d t | �f ^ q�� S( sV
Returns the dictionary with the values of the existing aggregations.
i����( t AggregateQueryc s s | ] } | d f Vq d S( N( R# ( t .0Rv ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pys <genexpr>T s R0 N( R( RY R# t django.db.models.sql.subqueriesR� RF R+ Rs t
is_summaryt add_subqueryR t dictRT RQ RL Rd t remove_inherited_modelst clear_orderingRK t clear_limitsR^ R` RU Rl t execute_sqlR t zipR� R (
R) R" R� t queryR� Rv Rw R< t qt val( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt get_aggregation9 s@
%c C s | j � } t | j � d k s< | j s< | j r� | j r� d d l m } | } | j t � | j
� | | j � } y | j | d | �Wq� t
k
r� d SXn | j � | j d | � d } t d | | j � } | j d k rt | | j | j � } n | S( sP
Performs a COUNT() query using the current filter constraints.
i i����( R� R" i N( R+ t lenRT R( R\ R] R� R� R� RK R� RF R� R t add_count_columnR� R# t maxR% R& t min( R) R" R� R� t subqueryt number( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt get_countn s" 0
c C s� | j � } | j � | j i d d 6d d d d d � | j d g � | j t � | j d d � | j d | � } t | j
t � � S( Ni t at highR" ( R+ t clear_select_clauset add_extraR# t set_extra_maskR� RK t
set_limitsRl t boolR� R ( R) R" R� Ru ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt has_results� s
#
c C s | j | j k s t d � � | j � s6 t d � � | j | j k sT t d � � | j | j k sr t d � � | j � i } | t k } | r� t � n t | j � } | j � x� | j d D]� } | j
| \ } } } }
} } }
| | j k } | j |
|
� }
| j
|
| | f d | d | d | d |
�} | rW| j | g � n | j | � | | | <| j | s� | j | � q� q� W| s�t | j � � } g | j D] } | | k r�| ^ q�} | j | t � n | j r,| j j � } | j | � | j sc| j j t � t � qcn7 | j rW| j � } | j t � t � n | j � } | j j | | � g | _ x� | j D]� \ } } t | t t f � r�| j | d
| d
� | d f } | j j t | | � � q�| j | � } | j j t | | � � q�W| t! k rF| j" rF| j" rFt# d � � qFn | j" j$ | j" � t � } | j% d k r�| j$ | j% � n | j% d k r�| j$ | j% � n | r�| j' | � n | j( | j( 7_( | j) r�| j) n | j) | _) | j* p�| j* | _* d S(
sN
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.
s4 Cannot combine queries on two different base models.s3 Cannot combine queries once a slice has been taken.s6 Cannot combine a unique query with a non-unique query.s6 Cannot combine queries with different distinct fields.i t reuset outer_if_firstt nullablet
join_fieldi sS When merging querysets using 'or', you cannot have extra(select=...) on both sides.N(+ RF t AssertionErrort
can_filterR\ R] R� R RO RV t get_initial_aliasRH t LOUTERt gett joint
promote_joinst discardRG t unref_aliast valuesRK RW R+ t relabel_aliasest addR RX RT t
isinstanceR: R> t appendR t relabeled_cloneR Rd Rr R~ Re R# R� Rg R[ Rh ( R) t rhst connectort
change_mapt conjunctionR� Rv t tablet _t join_typet lhst join_colsR� R� t promotet new_aliast rhs_used_joinst
to_promotet wt colR/ t new_colRe ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt combine� s~
"
$ c C s� | j \ } } | s d S| j � } i } i t | j g � | j 6} x
| D]} | j t � } | j }
| } x� | d D] } |
}
| j | � d } t | � r� | j }
n | j
j }
|
j } t | � s� | |
j
| � n t | |
| j � q} W| j | d � \ } } } } | d k r4|
} n t | � sN t | | | � qN qN W| r>i } xe t j | � D]T \ } } xE | j j � D]4 \ } } | | k r�q�n t | | p�| | � q�WqsWx= t j | � D], \ } } | | k r�| | j | � q�q�Wx� t j | � D] \ } } | | | | � qWn� xG t j | � D]6 \ } } | | k rz| | j | � qN| | | <qNWx0 | j � D]" } | | k r�t � | | <q�q�Wx- t j | � D] \ } } | | | | � q�Wd S( s
Converts 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 initialised on each
model. Models that have all their fields included aren't mentioned in
the result, only those that have field restrictions in place.
The "target" parameter is the instance that is populated (in place).
The "callback" is a function that is called whenever a (model, field)
pair need to be added to "target". It accepts three parameters:
"target", and the model and list of fields being added for that model.
Ni����i ( Ri Ry RO t pkt concrete_modelt splitR RF t get_field_by_namet is_reverse_o2ot relt toRx R� t add_to_dictR# R t iteritemst get_fields_with_modelR~ t get_parent_list( R) t targett callbackt field_namest defert orig_optst seent must_includet
field_namet partst cur_modelt optst namet old_modelt sourceR/ RF R� t worksetR� t m( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt deferred_to_data s\
c C sQ | j j } | | k r( t � | | <n x" | D] } | | j | j � q/ Wd S( sr
Callback used by deferred_to_columns(). The "target" parameter should
be a set instance.
N( Rx t db_tableRO R� t column( R) R� RF t fieldsR� R/ ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt deferred_to_columns_cbk s
c C s� | j j | � } | rF | rF | d } | j | c d 7<| t f S| r| d | j t | j � d f } | j | � n | } | g | j | <d | j | <| j j | � | t f S( s
Returns 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.
i i s %s%d(
RI R� RG RQ t alias_prefixR� RH R� RV RK ( R) t
table_namet createt currentRv ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt table_aliasw s
c C s | j | c d 7<d S( s/ Increases the reference count for this alias. i N( RG ( R) Rv ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt ref_alias� s i c C s | j | c | 8<d S( s/ Decreases the reference count for this alias. N( RG ( R) Rv t amount( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR� � s c s t � � � x � r� j d � � � j � j d d d k rH q n � j � j } | ot � j | j � j k } � j � j � j k } | s� � j � j s� | r | r � j � j d � j � } | � j � <� j
� � � f d � � j j � D� � q q Wd S( sM
Promotes recursively the join type of given aliases and its children to
an outer join. If 'unconditional' is False, the join is only promoted if
it is nullable or the parent join is an outer join.
Note about join promotion: When promoting any alias, we make sure all
joins which start from that alias are promoted, too. When adding a join
in join(), we make sure any join added to already existing LOUTER join
is generated as LOUTER. This ensures we don't ever have broken join
chains which contain first a LOUTER join, then an INNER JOIN, that is
this kind of join should never be generated: a LOUTER b INNER c. The
reason for avoiding this type of join chain is that the INNER after
the LOUTER will effectively remove any effect the LOUTER had.
i i R� c 3 s7 | ]- } � j | j � k r | � k r | Vq d S( N( RH t lhs_alias( R� R� ( Rv t aliasesR) ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pys <genexpr>� s N( R: t popRH R� R# R� R� R� R� t _replacet extendt keys( R) R� t
unconditionalt parent_aliast
parent_loutert already_loutert data( ( Rv R� R) s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR� � s
c C sP xI | j j � j � D]2 \ } } | | j | d � } | j | | � q Wd S( s�
This method will reset reference counts for aliases so that they match
the value passed in :param to_counts:.
i N( RG R| Rs R� R� ( R) t to_countsRv t cur_refcountt unref_amount( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt reset_refcounts� s "c C sL xE | j � D]7 \ } } | | k r
| | k r
| j | g � q
q
Wd S( s+
This method is to be used for promoting joins in ORed filters.
The principle for promotion is: any alias which is used (it is in
alias_usage_counts), is not used by every child of the ORed filter,
and isn't pre-existing needs to be promoted to LOUTER join.
N( Rs R� ( R) t aliases_beforet alias_usage_countst
num_childsRv t use_count( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt promote_disjunction� s c sP t � j � � j t � j � � � t � k s6 t � � f d � � | j j � � | j j � � | j r� g | j D] } � | � ^ qx | _ n g | j D]! } t
� | j � | j � ^ q� | _ t
� f d � | j j � D� � | _ x� | j j � D]s \ } } | j | =t g | D] } � j | | � ^ q"� } � j | d | d � f | d } | | j | <qWx� t j � � D]� \ } } | j | } | j d | � } | j | | j | <| j | =| | j | <| j | =| j | j }
x4 t |
� D]& \ } } | | k r| |
| <PqqWx: t | j � D]) \ } } | | k r@| | j | <Pq@q@Wq�Wx= | j j � D], \ }
} | � k r�� | | j |
<q�q�Wx[ t j | j � D]G \ } } | j } | � k r�| j d � | � } | | j | <q�q�Wt | d � rLg | j D] } � j | | � ^ q(| _ n d S( s�
Changes the aliases in change_map (which maps old-alias -> new-alias),
relabelling any references to them in select columns and the where
clause.
c sJ t | t t f � r9 | d } � j | | � | d f S| j � � Sd S( Ni i ( R� R: R> R� R� ( R� t old_alias( R� ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt relabel_column� s
c 3 s' | ] \ } } | � | � f Vq d S( N( ( R� t keyR� ( R ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pys <genexpr>� s i i t rhs_aliasR� t
_lookup_joinsN( RO R� t intersectionR� R� RW R� RZ RY RT R R� R/ R R Rs RJ R> R� R R� RH R� RG RI R� t enumerateRV RS R� R R ( R) R� R� t st identR� R� R R� t
alias_datat
table_aliasest posRv R R� R� t lj( ( R� R s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt change_aliases� sR 6 (1%
+%
c C s� t | j � } | t d � k s' t � t | d � } | | _ t � } xV t | j � D]E \ } } | | k rw qY n d | | f } | | | <| | j | <qY W| j | � d S( s@
Changes the alias prefix to the next letter in the alphabet and
relabels all the aliases. Even tables that previously had no alias will
get an alias after this call (it's mostly used for nested queries and
the outer query will already be using the non-aliased table name).
Subclasses who create their own prefix should override this method to
produce a similar result (a new prefix and relabelled aliases).
The 'exceptions' parameter is a container that holds alias names which
should not be changed.
t Zi s %s%dN( t ordR� R� t chrR R RV R ( R) t
exceptionsR� t prefixR� R Rv R� ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt bump_prefix s
c C sK | j r& | j d } | j | � n! | j d | j � j d f � } | S( sg
Returns the first alias for this query, after increasing its reference
count.
i N( RV R� R� R# Ry R� ( R) Rv ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR� - s
!c C s, t g | j j � D] } | r d ^ q � S( s�
Returns the number of tables in this query with a non-zero reference
count. Note that after execution, the reference counts are zeroed, so
tables added in compiler will not be seen by this method.
i ( R� RG R� ( R) t count( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt count_active_tables9 s c C s� | \ } } } | d k s- | d k s- t � | j j | d � } | d k rW | } n% g | D] }
|
| k r^ |
^ q^ } x> | D]6 } | r� | j | j | k r� q� n | j | � | SW| j | t � \ } } | s� d }
n4 | s| j | j | j
k r| j
}
n | j }
t | | |
| | p0d | | � } | | j | <| | j k rq| j | c | f 7<n | f | j | <| S( s�
Returns an alias for the join in 'connection', either reusing an
existing alias for that join or creating a new one. 'connection' is a
tuple (lhs, table, join_cols) where 'lhs' is either an existing
table alias or a table name. 'join_cols' is a tuple of tuples containing
columns to join on ((l_id1, r_id1), (l_id2, r_id2)). The join corresponds
to the SQL equivalent of::
lhs.l_id1 = table.r_id1 AND lhs.l_id2 = table.r_id2
The 'reuse' parameter can be either None which means all joins
(matching the connection) are reusable, or it can be a set containing
the aliases that can be reused.
If 'outer_if_first' is True and a new join is created, it will have the
LOUTER join type.
A join is always created as LOUTER if the lhs alias is LOUTER to make
sure we do not generate chains like t1 LOUTER t2 INNER t3.
If 'nullable' is True, the join can potentially involve NULL values and
is a candidate for promotion (to "left outer") when combining querysets.
The 'join_field' is the field we are joining along (if any).
N( ( NN( ( NN(
R# R� RJ R� RH R� R� R� RK R� R� t INNERR ( R) R0 R� R� R� R� R� R� R� t existingR� Rv R� R� R� ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR� A s0 %
c C su | j � } | j d } i | d 6} x? | j � D]1 \ } } | | k r3 | j | | | | � q3 q3 W| | _ d S( s�
If the model that is the basis for this QuerySet inherits other models,
we need to ensure that those other models have their tables included in
the query.
We do this as a separate step so that subclasses know which
tables are going to be active in the query, without needing to compute
all the select columns (this method is called from pre_sql_setup(),
whereas column determination is a later part, and side-effect, of
as_sql()).
i N( Ry RV R# R� t join_parent_modelRS ( R) R� t
root_aliasR� R/ RF ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt setup_inherited_models� s
c C s� | | k r | | S| j | � } | d k r3 | S| } x� | D]� } | | k rZ | | S| j | sv | j } q@ n | j | � } | j | j g | | � \ } } } }
} | j } |
d } | | <q@ W| p� | d S( s~
Makes 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.
i����N( t get_base_chainR# t parentsRx t get_ancestor_linkt setup_joinsR� ( R) R� RF Rv R� t chaint curr_optst int_modelt
link_fieldR� t joins( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR � s$
$ c C sC x3 | j j � D]" \ } } | r | j | � q q Wi | _ d S( s�
Undoes the effects of setup_inherited_models(). Should be called
whenever select columns (self.select) are set explicitly.
N( RS Rs R� ( R) R Rv ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR� � s c
C s� | j } | j j t � } t | � d k r� | j | j k r� | d } | } | j | } | svt d | j | | f � � qvn� t | � d k s� | d g | j D] }
|
j ^ q� k s� | j d k s� | rW| j | | | j � � \ } } } }
} | j
| |
| � \ } } }
| j |
t � | d j } | d } |
d | f } n | d } | j | � } | } | j | | d | d | d | �d S( sA
Adds a single aggregate expression to the Query
i i s- Cannot compute %s('%s'): '%s' is an aggregatei����R� R� R� N( Rx t lookupR� R R� R R R� R� RY R# R# R� t
trim_joinsR� RK R� t get_fieldt add_to_query( R) Rw RF Rv R� R� t
field_listR� R� R� t iR/ t sourcest join_listt patht targetsR� ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt
add_aggregate� s0 $
)$
c C sG | \ } } | j t � } | s4 t d | � � n d } t | � } t | � d k r | d | j k r | | j k r | j }
x� t | � D]� \ } } y |
j j | � }
Wn t
k
r� | j � } Pn X| d | k r� y |
j j
}
Wqt k
r| j � } PqXq� q� Wn | j � } | d k r`| d k rQt d � � n d } t } n? t | � rx| � } n' t | t � r�t | | d | �} n t t j j r�| d k r�| d k r�t } d } n xY | j j � D]H \ } } | | d t j | � f k r�| j | | | f t � | Sq�W| j � } | j � } | } yY | j! | | | | | d
t �\ } } } } } | d k r�| j" | � n | | _# Wn9 t$ k
r�} | j% | t j | | j& � | | j' � SX| d k r'| t k r'| r't | � d k r'| j( | � n | j) | | | � \ } } } t* | d � rx| j+ | j | | | | | � } n" t, | | d j- | � | | f } | j | t � | rC| d k s�| t. k rC| j( | � | d k rC| j/ | d � s| j0 | d j1 | j2 k rC| j t, | | d j- d � d t. f t � qCn | S(
s?
Builds a WhereNode for a single filter clause, but doesn't add it
to this Query. Query.add_q() will then add this filter to the where
or having 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_netageted 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.
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.
s Cannot parse keyword query %rt exacti i����s Cannot use None as a query valuet isnullR� t i t allow_explicit_fkt get_lookup_constraintN(3 R� R R R� t query_termsR RF R Rx R+ R R� R� R� t AttributeErrorRX R# Rr RK t callableR� R R R R R8 t! interprets_empty_strings_as_nullsRs R� R� R Ry R� R# R~ R R t
split_excludet levelt names_with_pathR� R* R R8 R R� RQ t is_nullableRH R� R� ( R) t filter_exprt branch_negatedt current_negatedt can_reuset argR. R� t lookup_typet num_partst lookup_modelt counterR� t lookup_fieldt clauseRv Rw R� t
allow_manyR/ R/ R0 R1 t eR2 t
constraint( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt build_filter� s� %
"
2c C s | j j | j | � d � d S( NR ( RW R� RO ( R) t
filter_clause( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt
add_filter} s c sr t | t � sU t | d j t � � j � pT t | d d � oT | d j � j � St � f d � | j D� � S( s|
Returns whether or not all elements of this q_object need to be put
together in the HAVING clause.
i i t contains_aggregatec 3 s | ] } � j | � Vq d S( N( t need_having( R� t c( R) ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pys <genexpr>� s (
R� R R R� R R R RR t anyt children( R) R� ( ( R) s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyRS � s
c C s� g } x� | j D]� } t | t � r� | j | A} | j t k rz | j | � rz | j j | � | j | � | | _ q� | j | j
| | � d � q | j | � r | j j | � | j d | g d | � } | j | � q q W| | f S( s�
Returns a list of q_objects which need to go into the having clause
instead of the where clause. Removes the splitted out nodes from the
given q_object. Note that the q_object is altered, so cloning it is
needed.
i RV t negated( RV R� R RW R� R RS t removeR� R� t split_having_partsRX ( R) t q_objectRW t having_partsRT t
in_negatedt new_q( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyRY � s
c C s� | j | � s | g } } n! | j | j � | j � \ } } | j } | j | | � } | j j | t � x3 | D]+ } | j | | � } | j j | t � qu W| j
r� | | _ n d S( s�
A preprocessor for the internal _add_q(). Responsible for
splitting the given q_object into where and having parts and
setting up some internal variables.
N( RS RY R+ RW RP t _add_qRW R� R RZ RR ( R) RZ t
where_partR[ RP RK t hp( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt add_q� s
c
C s� | j } | | j A} | p" | j } | j d | d | j � } | } | rg | t k r^ t n t } n | t k r� t � } t | j � } n x� | j D]� }
| t k r� | j j
� } n t |
t � r� | j
|
| | | � } n! | j |
d | d | d | �} | j | | � | t k r� t | | j � }
x+ |
D] } | j | d � d | | <q<Wq� q� W| t k r�| j | | t | j � � n | S( s8
Adds a Q-object to the current filter.
R� RW RD RB RC i i ( R� RW RX R R R� RO RV RV RG R| R� R R^ RO R� t
alias_diffR� R R� ( R) RZ RP RB RC R� t
target_clauset effective_connectorR R t childt refcounts_beforet child_clauset usedRv ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR^ � s<
% c
C s g g } } x�t | � D]�\ } } | g f } | d k rM | j j } n y | j | � \ }
} } }
Wn� t k
rx� | j D]= } | r� | | j k r� | j | j � \ }
} } }
Pq� q� W| j � t | j � } t
d | d j | � f � � n X| r�| j } x� | j
| � D]� } | | k r@| j } q"| j | } | j j � f } | j } | j t | j j | | | t t � � | d j t | j j | | | t t � � q"Wn t |
d � r�|
j � } | sLxe t | � D]T \ } } | j r�| d j | d | d !� | j | � t | d | � � q�q�Wn | d } | j | � | j } | j } | j } | d j | � | j | � q |
} |
f } Pq W| t | � d k r| t | � d k r t
d | | | d f � � qt
d
| � � n | | | f S( s=
Walks the names path and turns them PathInfo tuples. Note that a
single name in 'names' can generate multiple PathInfos (m2m for
example).
'names' is the path of names to travle, 'opts' is the model Options we
start the name resolving from, 'allow_many' and 'allow_explicit_fk'
are as for setup_joins().
Returns a list of PathInfo tuples. In addition returns the final field
(the last used join field), and target (which is a field guaranteed to
contain the same value as the final field).
R� s5 Cannot resolve keyword %r into field. Choices are: %ss , i t
get_path_infoi i����i sH Join on field %r not permitted. Did you misspell %r for the lookup type?s Join on field %r not permitted.( R R� R� R� R R� t attnamet get_all_field_namesR: R( R R� R� R Rx R! R� t get_related_fieldR� R
RF RQ RK R Ri t m2mR� R R� t to_optst
target_fieldsR� ( R) t namesR� RL R7 R1 R? R R� t cur_names_with_pathR/ RF t directRm t ft availablet
proxied_modelR& t final_fieldR2 t pathinfost inner_post pt last( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt
names_to_path� sd
(3
c C s | g } | j | | | | � \ } }
} x� t | � D]� \ } }
|
j } |
j rj | j |
j � } n t } | | j |
j j � f } |
j r� | n d } | j | d | d | d |
j d | �} | j | � q7 Wt
|
d � r� |
j }
n |
| | | | f S( s
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().
If 'allow_many' is False, then any reverse foreign key seen will
generate a MultiJoin exception.
The 'allow_explicit_fk' controls if field.attname is allowed in the
lookups.
Returns the final field involved in the joins, the target field (used
for any 'where' constraint), the final 'opts' value, the joins and the
field path travelled to generate the joins.
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).
R� R� R� R� R/ N( R{ R Rn Rr R@ R� RK R� t get_joining_columnsRm R# R� R� R R/ ( R) Rp R� Rv RD RL R7 R� R( R1 Rv R2 R R� R� R0 R� ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR# 3 s" c s� x� t t | � � D]� \ } } t | � d k s; | j r? Pn t d � | j j D� � } t d � | D� � � � j | � s� Pn t � f d � | j j D� � } | j
| j � � q W| | d | f S( s
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.
Returns the final target field and table alias and the new active
joins.
We will always trim any direct join if we have the target column
available already in the previous table. Reverse joins can't be
trimmed as we don't know if there is anything on the other side of
the join.
i c s s | ] } | j Vq d S( N( R� ( R� t t( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pys <genexpr>x s c s s | ] } | j Vq d S( N( R� ( R� R} ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pys <genexpr>y s c 3 s, | ]" } | d j � k r | d Vq d S( i i N( R� ( R� t r( t cur_targets( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pys <genexpr>| s i����( R t reversedR� Rr RO R� t foreign_related_fieldst issubsetR> t related_fieldsR� R� ( R) R2 R( R1 R t infot join_targets( ( R s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR* g s "c C s8 t | j � } | j j | j | � t � | j � | j t � | j | � \ } } | j
� | j | j d j
� r� | j d j \ } } | j j t | | | j d j
� d t f t � n | j d | | f d t d t d | �}
| r4| j d | t f d t d t d | �} |
j | t � n |
S( s\
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.
As an example we could have original filter ~Q(child__name='foo').
We would get here with filter_expr = child__name, prefix = child and
can_reuse is a set of joins usable for filters in the original query.
We will turn this into equivalent of:
WHERE NOT (pk IN (SELECT parent_id FROM thetable
WHERE name = 'foo' AND parent_id IS NOT NULL))
It might be worth it to consider using WHERE NOT EXISTS as that has
saner null handling, and is easier for the backend's optimizer to
handle.
i R5 s %s__inRC RB RD s
%s__isnull( R RF RW R� RO R R R� RK t
trim_startR� R@ RT R/ R� R RQ R ( R) RA R RD R? R� t trimmed_prefixt contains_louterRv R� t conditiont or_null_condition( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR= � s$
5c C s t � | _ t � | _ d S( N( R RW RZ ( R) ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt set_empty� s c C s" t | j t � p! t | j t � S( N( R� RW R RZ ( R) ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt is_empty� s c C s� | d k rM | j d k r: t | j | j | � | _ qM | j | | _ n | d k r� | j d k r� t | j | j | � | _ q� | j | | _ n d S( s�
Adjusts the limits on the rows retrieved. We use low/high to set these,
as it makes it more Pythonic to read and write. When the SQL query is
created, they are converted to the appropriate offset and limit values.
Any limits passed in here are applied relative to the existing
constraints. So low is added to the current low value and both will be
clamped to any existing high value.
N( R# R& R� R% ( R) t lowR� ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR� � s
c C s d \ | _ | _ d S( s-
Clears any existing limits.
i N( i N( R# R% R& ( R) ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR� � s c C s | j o | j d k S( s�
Returns True if adding filters to this instance is still possible.
Typically, this means no limits or offsets have been put on the results.
N( R% R& R# ( R) ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR� � s c C s9 g | _ t | _ t | _ | j d � | j d � d S( s8
Removes all fields from SELECT clause.
N( ( ( RT RQ RL R` R� t set_aggregate_mask( R) ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR� � s
c C s
g | _ d S( s�
Clears the list of fields to select (but not extra_select columns).
Some queryset types completely replace any existing list of select
columns.
N( RT ( R) ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt clear_select_fields� s c G s | | _ t | _ d S( sY
Adds and resolves the given fields to the query's "distinct on" clause.
N( R] RK R\ ( R) R� ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt add_distinct_fields� s c C s | j � } | j � } y� x� | D]� } | j | j t � | | d | d t d t �\ } } } } }
| j | | d |
� \ } } } | d | } | j | d � x0 | D]( }
| j j
t | |
j f |
� � q� Wq" WWn� t
k
rt d | � � nn t k
rpt | k r"� qqt | j � t | j � t | j � � } t d | d j | � f � � n X| j � d S( s|
Adds the given (model) fields to the select set. The field names are
added in the order specified.
R7 R� i����i s Invalid field name: '%s's5 Cannot resolve keyword %r into field. Choices are: %ss , N( R� Ry R# R� R R# RK R* R� RT R� R R� R R t sortedRk R: Rd R( R� R� ( R) R� t allow_m2mRv R� R� R/ R2 t u2R( R1 t final_aliast remaining_joinsR� Rp ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt
add_fields� s,
"
.
) c G su g } x- | D]% } t j | � s
| j | � q
q
W| rO t d | � � n | rh | j j | � n t | _ d S( sk
Adds 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 ordinals,
corresponding to column positions in the 'select' list.
If 'ordering' is empty, all ordering is cleared from the query.
s Invalid order_by arguments: %sN( R t matchR� R R[ R� RQ RM ( R) t orderingt errorst item( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt add_ordering s
c C s( g | _ d | _ | r$ t | _ n d S( s�
Removes any ordering settings. If 'force_empty' is True, there will be
no ordering in the resulting query (not even the model's default).
N( ( R[ Rh RQ RM ( R) t force_empty( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR� / s c C s7 g | _ x' | j D] \ } } | j j | � q Wd S( s@
Expands 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( RY RT R� ( R) R� R� ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt set_group_by9 s c C sA | j st | j s- | j j d d t �} qt | j � d k sU t d | j � � | j j | j d j � } n� | j � } | j s� | j j | j d | j d f � | j j
f d t d t �} nC t | j � d k s� t d � � | j j | j d j d t �} t | _ i | d 6| _ | j d � d | _ d S( sn
Converts the query to do count(...) or count(distinct(pk)) in order to
get its size.
t *R� i s7 Cannot add count col with multiple cols in 'select': %ri R\ s4 Cannot add count col with multiple cols in 'select'.N( R\ RT t aggregates_modulet CountRK R� R� R� Ry R� R# R� R� R� RQ R R� RY ( R) R R� ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR� G s$ ' "
c C s_ i } x@ | D]8 } | } x) | j t � D] } | j | i � } q) Wq
W| | _ g | _ d S( s�
Sets up the select_related data structure so that we only select
certain related models (as opposed to all models, when
self.select_related=True).
N( R� R t
setdefaultR` RU ( R) R� t
field_dictR/ t dt part( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt add_select_relatedj s
c
C s, | r� t � } | r$ t | � } n t g � } x� | j � D]y \ } }
t |
� }
g } |
j d � } x9 | d k r� | j t | � � |
j d | d � } qm W|
| f | | <q= W| j j | � n | s� | r� | j j
t | | � t � n | r| j
t | � 7_
n | r(| | _ n d S( sn
Adds data to the various extra_* attributes for user-created additions
to the query.
s %si����i N( R R; Rs R t findR� t nextRd R~ RW R� R R Rg R> Rh (
R) RT t
select_paramsRW R RV R[ t select_pairst
param_iterR� t entryt entry_paramsR ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR� x s( c C s t � t f | _ d S( sB
Remove any fields from the deferred loading set.
N( RO RK Ri ( R) ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt clear_deferred_loading� s c C sL | j \ } } | r0 | j | � t f | _ n | j | � t f | _ d S( sp
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. The new field names are added 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).
N( Ri t unionRK t
differenceRQ ( R) R� R R� ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt add_deferred_loading� s c C s� | j \ } } t | � } d | k rP | j d � | j | j � j j � n | rq | j | � t f | _ n | t f | _ d S( s
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, those
names are removed 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� N( Ri RO RX R� Ry R� R� R� RQ ( R) R� R R� ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt add_immediate_loading� s
c C sF y | j SWn4 t k
rA i } | j | | j � | | _ | SXd S( sI
If any fields are marked to be deferred, returns a dictionary mapping
models to a set of names in those fields that will be loaded. If a
model is not in the returned dictionary, none of it's fields are
deferred.
If no fields are marked for deferral, returns an empty dictionary.
N( t _loaded_field_names_cacheR: R� t get_loaded_field_names_cb( R) t
collection( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt get_loaded_field_names� s
c C s* t g | D] } | j ^ q
� | | <d S( s>
Callback used by get_deferred_field_names().
N( RO R� ( R) R� RF R� Rs ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR� � s c C s4 | d k r d | _ n t | � | _ d | _ d S( sG Set the mask of aggregates that will actually be returned by the SELECTN( R# Ra RO Rb ( R) Rp ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR� � s c C s4 | d k r d | _ n t | � | _ d | _ d S( s�
Set the mask of extra select items that will be returned by SELECT,
we don't actually remove them from the Query since they might be used
later
N( R# Re RO Rf ( R) Rp ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR� � s c C s} | j d k r | j S| j d k rr t g | j j � D]' \ } } | | j k r8 | | f ^ q8 � | _ | j S| j Sd S( s� The SortedDict of aggregate columns that are not masked, and should
be used in the SELECT clause.
This result is cached for optimization purposes.
N( Rb R# Ra R R Rs ( R) t kt v( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt _aggregate_select� s 'c C s} | j d k r | j S| j d k rr t g | j j � D]' \ } } | | j k r8 | | f ^ q8 � | _ | j S| j Sd S( N( Rf R# Re R Rd Rs ( R) R� R� ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt
_extra_select s 'c C s` g } x! | D] \ } } | j | � q
Wt } g | j D]. } | | j k sb | | j d k r: | ^ q: } xb t | � D]T \ } } | j r� Pn | j | | d j | j k r� t } n | j
| | � q{ W| j j }
| } g } xK | D]C \ }
} | t
| � d k rPn | j |
� | t
| � 8} q� W| j |
j d j � t j | � } | j | | d j | j k r�g |
j D] } | d ^ q�} | | d } | j
| | � |
j | j d | | d � } | r(| j j | t � q(n* g |
j D] } | d ^ q} | | } g | D] } t | | j f | � ^ q/| _ | | f S( s�
Trims 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 sets 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().
Returns a lookup usable for doing outerq.filter(lookup=self). Returns
also if the joins in the prefix contain a LEFT OUTER join.
_i i N( R� RQ RV R R Rm RH R� R� RK R� R� R/ R� R� R� R� R R� R� t get_extra_restrictionRX R# RW R� R R R� RT ( R) R? t all_pathsR� t pathsR� R} t
lookup_tablest
trimmed_pathsR1 R� t paths_in_prefixR� R� R~ t
select_fieldst select_aliast extra_restrictionRs ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR� sD
> !
!
.c C s( t t j j r | j r t S| j Sd S( s%
A helper to 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.
N( R R R8 R< t empty_strings_allowedRK t null( R) R/ ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR@ R s
N( (U RA RB RC R R� R� R R9 t base_aggregates_moduleR� Ru R R* Rk Rj Rp Rq R# Rl Ry R+ R- R� R� R� R� R� R� R� RQ R� R� R� R� R� R R R R� R R� R R R� R3 RO RQ RS RY Ra R^ R{ RK 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� t propertyR( R� R' R� R@ ( ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR Z s� > E 5 #
} S &
> @ 1 � & P3 5
#
# <t ASCc C s: t | } | d d k r, | d | d f S| | d f S( s
Returns 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.
i t -i ( R
( R/ t defaultt dirn( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt
get_order_dire s
c C s7 | | k r | | j | � n t | g � | | <d S( ss
A helper function to add "value" to the set of values for "key", whether or
not "key" already exists.
N( R� RO ( R� R R. ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR� s s c C s t | d � o | j j S( s�
A little helper to check if the given field is reverse-o2o. The field is
expected to be some sort of relation field or related object.
R� ( R R/ t unique( R/ ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyR� } s c s t � � f d � � D� � S( sw
Given the before and after copies of refcounts works out which aliases
have been added to the after copy.
c 3 s1 | ]' } � | � j | d � k r | Vq d S( i����N( R� ( R� R} ( t refcounts_afterRf ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pys <genexpr>� s ( RO ( Rf R� ( ( R� Rf s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyRb � s (9 RC R| t django.utils.datastructuresR t django.utils.encodingR t django.utils.treeR t django.utilsR t django.dbR R t django.db.models.constantsR t django.db.models.aggregatesR t django.db.models.expressionsR t django.db.models.fieldsR t django.db.models.relatedR
t django.db.models.sqlR R� t django.db.models.sql.constantsR R
R R R R t# django.db.models.sql.datastructuresR R R t django.db.models.sql.expressionsR t django.db.models.sql.whereR R R R R R R t django.core.exceptionsR t __all__t objectR R R� R� R� Rb ( ( ( s< /tmp/pip-install-XxeQeY/django/django/db/models/sql/query.pyt <module> s> . 4 8� � � � � � �