
     h;                     F   d Z ddlZddlZddlZddlmZ ddlmZ ddlm	Z	m
Z
mZ ddlmZ ddlmZ  ej        d          Z ed	d
          Zd Z G d dej                  Z G d d          Z G d d          Z G d d          ZddZd Zd Z G d d          ZdS )z
Various data structures used in query construction.

Factored out from django.db.models.query to avoid making the main module very
large and/or so that they can be used by other modules without getting into
circular import difficulties.
    N)
namedtuple)
FieldError)DEFAULT_DB_ALIASDatabaseErrorconnections)
LOOKUP_SEP)treedjango.db.modelsPathInfozGfrom_opts to_opts target_fields join_field m2m direct filtered_relationc              #   j   K   | V  |                                  D ]}t          |          E d {V  d S N)__subclasses__
subclassesclssubclasss     [/var/www/surfInsights/venv3-11/lib/python3.11/site-packages/django/db/models/query_utils.pyr   r      sW      
III&&(( ( (h''''''''''( (    c                   |     e Zd ZdZdZdZdZeZdZddd fd	
Z	d
 Z
d Zd Zd Zd Z	 ddZd ZefdZd Z xZS )Qze
    Encapsulate filters as objects that can then be combined logically (using
    `&` and `|`).
    ANDORXORTNF)
_connector_negatedc                    t                                          g |t          |                                          ||           d S )N)children	connectornegated)super__init__sorteditems)selfr   r   argskwargs	__class__s        r   r!   z
Q.__init__0   sQ    5t5fV\\^^445  	 	
 	
 	
 	
 	
r   c                 P   t          |dd          du rt          |          | s|                                S |s)t          |t                    r|                                 S |                     |          }|                    | |           |                    ||           |S )NconditionalF)r   )getattr	TypeErrorcopy
isinstancer   createadd)r$   otherconnobjs       r   _combinez
Q._combine7   s    5-//588E""" 	 ::<< 	E1-- 	99;;kkDk))dt
r   c                 8    |                      || j                  S r   )r3   r   r$   r0   s     r   __or__zQ.__or__D   s    }}UDG,,,r   c                 8    |                      || j                  S r   )r3   r   r5   s     r   __and__z	Q.__and__G       }}UDH---r   c                 8    |                      || j                  S r   )r3   r   r5   s     r   __xor__z	Q.__xor__J   r9   r   c                 V    |                                  }|                                 |S r   )r,   negate)r$   r2   s     r   
__invert__zQ.__invert__M   s!    iikk


r   c                 l    |                     | ||dd|          \  }}|                    |           |S )NF)allow_joins
split_subqcheck_filterable	summarize)_add_qpromote_joins)r$   queryr@   reuserC   for_saveclausejoinss           r   resolve_expressionzQ.resolve_expressionR   sM    
 #" % 
 
 	E"""r   c              #      K   | V  | j         D ]N}t          |t                    r|d         }t          |d          r|                                E d{V  J|V  OdS )zg
        Recursively yield this Q object and all subexpressions, in depth-first
        order.
           flattenN)r   r-   tuplehasattrrN   )r$   childs     r   rN   z	Q.flattenb   s      
 


] 	 	E%'' !aui((  ==??********	 	r   c           
         ddl m}m} ddlm} ddlm} ddlm}  |d          }|	                                D ]8\  }	}
t          |
d          s ||
          }
|                    |
|	d	           9|                     |d
          d           t          |         j        j        r7|                    t!           || d |                                           n|                    |            |                    |          }	 |                    |          duS # t&          $ r'}t(                              d| |           Y d}~dS d}~ww xY w)z|
        Do a database query to check if the expressions of the Q instance
        matches against the expressions.
        r   )BooleanFieldValue)Coalesce)Query)SINGLENrK   F)selectrM   _checkT)output_field)usingz.Got a database error calling check() on %r: %s)django.db.modelsrS   rT   django.db.models.functionsrU   django.db.models.sqlrV   django.db.models.sql.constantsrW   r#   rP   add_annotationr   featuressupports_comparing_boolean_expradd_qr   get_compilerexecute_sqlr   loggerwarning)r$   againstr[   rS   rT   rU   rV   rW   rF   namevaluecompileres                r   checkzQ.checkq   s    	98888888777777......999999d"==?? 	< 	<KD%5"677 %e  U ;;;;UU1XXx000u&F 	KK((4LLNNKKKLLMMMMKK%%E%22	''//t;; 	 	 	NNKTSTUUU44444	s   D# #
E-EEc                    | j         j        d| j         j        }|                    d          r|                    dd          }t          | j                  }i }| j        | j        k    r
| j        |d<   | j	        rd|d<   |||fS )N.zdjango.db.models.query_utilsr
   r   Tr   )
r'   
__module____name__
startswithreplacerO   r   r   defaultr   )r$   pathr%   r&   s       r   deconstructzQ.deconstruct   s    .333T^5L5LM??9:: 	T<< >@RSSDT]##>T\))#'>F< < 	&!%F:T6!!r   )NTNFF)rq   rp   __qualname____doc__r   r   r   rt   r)   r!   r3   r6   r8   r;   r>   rK   rN   r   rm   rv   __classcell__)r'   s   @r   r   r   #   s	         C	B
CGK)- 
 
 
 
 
 
 
  - - -. . .. . .   SX       $4    :
" 
" 
" 
" 
" 
" 
"r   r   c                   &    e Zd ZdZd ZddZd ZdS )DeferredAttributez
    A wrapper for a deferred-loading field. When the value is read from this
    object the first time, the query is executed.
    c                     || _         d S r   )field)r$   r}   s     r   r!   zDeferredAttribute.__init__   s    


r   Nc                     || S |j         }| j        j        }||vr4|                     |          }||                    |g           n|||<   ||         S )zx
        Retrieve and caches the value from the datastore on the first lookup.
        Return the cached value.
        N)fields)__dict__r}   attname_check_parent_chainrefresh_from_db)r$   instancer   data
field_namevals         r   __get__zDeferredAttribute.__get__   sw    
 K Z'
T!! **844C{(((====#&Z Jr   c                     |j         }|                    | j        j                  }| j        j        r | j        |k    rt          ||j                  S dS )z
        Check if the field value can be fetched from a parent field already
        loaded in the instance. This can be done if the to-be fetched
        field is a primary key field.
        N)_metaget_ancestor_linkr}   modelprimary_keyr*   r   )r$   r   opts
link_fields       r   r   z%DeferredAttribute._check_parent_chain   sT     ~++DJ,<==
:! 	9djJ&>&>8Z%7888tr   r   )rq   rp   rw   rx   r!   r   r    r   r   r{   r{      sP         
         &
 
 
 
 
r   r{   c                       e Zd ZdZd Zd ZdS )class_or_instance_methodz
    Hook used in RegisterLookupMixin to return partial functions depending on
    the caller type (instance or class of models.Field).
    c                 "    || _         || _        d S r   )class_methodinstance_method)r$   r   r   s      r   r!   z!class_or_instance_method.__init__   s    (.r   c                 n    |t          j        | j        |          S t          j        | j        |          S r   )	functoolspartialr   r   )r$   r   owners      r   r   z class_or_instance_method.__get__   s4    $T%6>>> !5x@@@r   N)rq   rp   rw   rx   r!   r   r   r   r   r   r      sA         
/ / /A A A A Ar   r   c                   0   e Zd Zd Z ej        d          d             Zd Z eee          Z	 e
e          Zd Zd Zed             Ze
d	             Zdd
ZddZ eee          Z e
e          ZddZddZ eee          Z e
e          ZdS )RegisterLookupMixinc                 R    |                                                      |d           S r   )get_lookupsget)r$   lookup_names     r   _get_lookupzRegisterLookupMixin._get_lookup   s$    !!%%k4888r   N)maxsizec                 h    d t          j        |           D             }|                     |          S )Nc                 D    g | ]}|j                             d i           S )class_lookups)r   r   ).0parents     r   
<listcomp>z9RegisterLookupMixin.get_class_lookups.<locals>.<listcomp>   s7     
 
 
9?FO44
 
 
r   )inspectgetmromerge_dicts)r   r   s     r   get_class_lookupsz%RegisterLookupMixin.get_class_lookups   s?    
 
CJ>RUCVCV
 
 
 }---r   c                 `    |                                  }t          | dd           x}ri ||S |S Ninstance_lookups)r   r*   )r$   r   r   s      r   get_instance_lookupsz(RegisterLookupMixin.get_instance_lookups   sE    ..00&t-?FFF 	98m8'788r   c                     ddl m} |                     |          }|*t          | d          r| j                            |          S |t          ||          sd S |S )Nr   )LookuprZ   )django.db.models.lookupsr   r   rP   rZ   
get_lookup
issubclass)r$   r   r   founds       r   r   zRegisterLookupMixin.get_lookup   sp    333333  --=WT>::=$//<<<Zv%>%>4r   c                     ddl m} |                     |          }|*t          | d          r| j                            |          S |t          ||          sd S |S )Nr   )	TransformrZ   )r   r   r   rP   rZ   get_transformr   )r$   r   r   r   s       r   r   z!RegisterLookupMixin.get_transform   sp    666666  --=WT>::=$22;???Zy%A%A4r   c                 X    i }t          |           D ]}|                    |           |S )z
        Merge dicts in reverse to preference the order of the original list. e.g.,
        merge_dicts([a, b]) will preference the keys in 'a' over those in 'b'.
        )reversedupdate)dictsmergedds      r   r   zRegisterLookupMixin.merge_dicts   s8     % 	 	AMM!r   c                 \    t          |           D ]}|j                                         d S r   )r   r   cache_clearr   s     r   _clear_cached_class_lookupsz/RegisterLookupMixin._clear_cached_class_lookups  s9    "3 	5 	5H&224444	5 	5r   c                 t    ||j         }d| j        vri | _        || j        |<   |                                  |S )Nr   )r   r   r   r   r   lookupr   s      r   register_class_lookupz)RegisterLookupMixin.register_class_lookup  sI     ,K#,.. "C)/+&'')))r   c                 L    ||j         }d| j        vri | _        || j        |<   |S r   )r   r   r   r$   r   r   s      r   register_instance_lookupz,RegisterLookupMixin.register_instance_lookup  s7     ,KT]22$&D!-3k*r   c                 P    ||j         }| j        |= |                                  dS )zn
        Remove given lookup from cls lookups. For use in tests only as it's
        not thread-safe.
        N)r   r   r   r   s      r   _unregister_class_lookupz,RegisterLookupMixin._unregister_class_lookup"  s5    
  ,Kk*'')))))r   c                 (    ||j         }| j        |= dS )zs
        Remove given lookup from instance lookups. For use in tests only as
        it's not thread-safe.
        N)r   r   r   s      r   _unregister_instance_lookupz/RegisterLookupMixin._unregister_instance_lookup,  s#    
  ,K!+...r   r   )rq   rp   rw   r   r   	lru_cacher   r   r   r   classmethodr   r   staticmethodr   r   r   r   register_lookupr   r   _unregister_lookupr   r   r   r   r      s       9 9 9 Y&&&. . '&.   +*+<>RSSK#$566       \ 5 5 [5       /.7 O (K(=>>* * * */ / / / 21 "=   +{+CDDr   r   Fc                    | j         sdS | j         j        r|sdS |r'|r|                                 |vrdS |s| j        |vrdS |s	| j        rdS |r9|r7| j        |v r.| |vr*t          d| j        j        j         d| j         d          dS )af  
    Return True if this field should be used to descend deeper for
    select_related() purposes. Used by both the query construction code
    (compiler.get_related_selections()) and the model instance creation code
    (compiler.klass_info).

    Arguments:
     * field - the field to be checked
     * restricted - a boolean field, indicating if the field list has been
       manually restricted using a requested clause)
     * requested - The select_related() dictionary.
     * select_mask - the dictionary of selected fields.
     * reverse - boolean, True if we are checking a reverse select related
    FzField ro   zM cannot be both deferred and traversed using select_related at the same time.T)	remote_fieldparent_linkrelated_query_nameri   nullr   r   r   object_name)r}   
restricted	requestedselect_maskreverses        r   select_related_descendr   ;  s      u% g u  	u//11BB5 	5:Y665 %* u	
	
 J)##$$LU[&2 L LUZ L L L
 
 	
 4r   c                     t          dt          |           dz             D ]A}t          j        | d|                   }|                    |          r|| |d         fc S BdS )z
    Check if the lookup_parts contains references to the given annotations set.
    Because the LOOKUP_SEP is contained in the default annotation names, check
    each prefix of the lookup_parts for a match.
    rM   r   N)Nr   )rangelenr   joinr   )lookup_partsannotationsnlevel_n_lookups       r   refs_expressionr   b  sz     1c,''!+,, 4 4#ac):;;??>** 	4!<#33333	48r   c                 p      fd} ||          p%t          |dd          o ||j        j                  S )z
    Check that self.model is compatible with target_opts. Compatibility
    is OK if:
      1) model and opts match (where proxy inheritance is removed)
      2) model is parent of opts' model or the other way around
    c                     j         j        | j        k    p5| j        j                                         v p|                                 v S r   )r   concrete_modelget_parent_list)r   r   s    r   rm   z-check_rel_lookup_compatibility.<locals>.checkw  sO    K&$*== /"ek&A&A&C&CC/,,...	
r   r   F)r*   r   r   )r   target_optsr}   rm   s   `   r   check_rel_lookup_compatibilityr   o  sX    
 
 
 
 
  5 }e,,Iu{7H1I1Ir   c                   F    e Zd ZdZ e            ddZd Zd Zd Zd Z	dS )	FilteredRelationz7Specify custom filtering in the ON clause of SQL joins.	conditionc                    |st          d          || _        d | _        t          |t                    st          d          || _        g | _        d S )Nzrelation_name cannot be empty.z*condition argument must be a Q() instance.)
ValueErrorrelation_namealiasr-   r   r   ru   )r$   r   r   s      r   r!   zFilteredRelation.__init__  s\     	?=>>>*
)Q'' 	KIJJJ"			r   c                     t          || j                  st          S | j        |j        k    o| j        |j        k    o| j        |j        k    S r   )r-   r'   NotImplementedr   r   r   r5   s     r   __eq__zFilteredRelation.__eq__  sQ    %00 	"!!%"55 2
ek)2%/1	
r   c                 |    t          | j        | j                  }| j        |_        | j        d d          |_        |S )Nr   )r   r   r   r   ru   )r$   clones     r   r   zFilteredRelation.clone  s8     !3t~NNNjYqqq\
r   c                      t          d          )zz
        QuerySet.annotate() only accepts expression-like arguments
        (with a resolve_expression() method).
        z0FilteredRelation.resolve_expression() is unused.)NotImplementedError)r$   r%   r&   s      r   rK   z#FilteredRelation.resolve_expression  s    
 ""TUUUr   c                     |j         }|                    | j        t          | j                            }|                    |          S )N)rG   )rF   build_filtered_relation_qr   setru   compile)r$   rk   
connectionrF   wheres        r   as_sqlzFilteredRelation.as_sql  s?    //c$)nn/UU&&&r   N)
rq   rp   rw   rx   r   r!   r   r   rK   r  r   r   r   r   r     s{        AA34133     
 
 
  V V V' ' ' ' 'r   r   )F)rx   r   r   loggingcollectionsr   django.core.exceptionsr   	django.dbr   r   r   django.db.models.constantsr   django.utilsr	   	getLoggerrf   r   r   Noder   r{   r   r   r   r   r   r   r   r   r   <module>r
     s          " " " " " " - - - - - - B B B B B B B B B B 1 1 1 1 1 1      		-	.	.
 :M ( ( (u" u" u" u" u"	 u" u" u"p& & & & & & & &RA A A A A A A A dE dE dE dE dE dE dE dEN$ $ $ $N
 
 
  :'' '' '' '' '' '' '' '' '' ''r   