a
    ‘ÐOcH5  ã                   @   sÞ   d Z ddl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 d¡Zed	d
ƒZdd„ ZG dd„ dejƒZG dd„ dƒZG dd„ dƒZddd„Zdd„ Zdd„ ZG d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                 c   s&   | V  |   ¡ D ]}t|ƒE d H  qd S ©N)Ú__subclasses__Ú
subclasses©ÚclsÚsubclass© r   úS/var/www/html/gsl.tools/lib/python3.9/site-packages/django/db/models/query_utils.pyr      s    r   c                       sŠ   e Zd ZdZdZdZdZeZdZdddœ‡ fd	d
„
Z	dd„ Z
dd„ Zdd„ Zdd„ Zdd„ Zddd„Zdd„ Zefdd„Zdd„ Z‡  ZS )ÚQze
    Encapsulate filters as objects that can then be combined logically (using
    `&` and `|`).
    ÚANDÚORÚXORTNF)Ú
_connectorÚ_negatedc                   s&   t ƒ jg |¢t| ¡ ƒ¢||d� d S )N)ÚchildrenÚ	connectorÚnegated)ÚsuperÚ__init__ÚsortedÚitems)Úselfr   r   ÚargsÚkwargs©Ú	__class__r   r   r   1   s
    ýz
Q.__init__c                 C   sœ   t |tƒs"t|ddƒdu s"t|ƒ‚| sBt|dƒr8| ¡ S t |¡S t |tƒrp|sp|  ¡ \}}}t| ƒ|i |¤ŽS t| ƒƒ }||_| 	| |¡ | 	||¡ |S )NÚconditionalFTÚcopy)
Ú
isinstancer   ÚgetattrÚ	TypeErrorÚhasattrr&   ÚdeconstructÚtyper   Úadd)r    ÚotherÚconnÚ_r!   r"   Úobjr   r   r   Ú_combine8   s    
z
Q._combinec                 C   s   |   || j¡S r   )r2   r   ©r    r.   r   r   r   Ú__or__H   s    zQ.__or__c                 C   s   |   || j¡S r   )r2   r   r3   r   r   r   Ú__and__K   s    z	Q.__and__c                 C   s   |   || j¡S r   )r2   r   r3   r   r   r   Ú__xor__N   s    z	Q.__xor__c                 C   s$   t | ƒƒ }| | | j¡ | ¡  |S r   )r,   r-   r   Únegate)r    r1   r   r   r   Ú
__invert__Q   s    
zQ.__invert__c                 C   s&   |j | ||ddd�\}}| |¡ |S )NF)Úallow_joinsZ
split_subqZcheck_filterable)Z_add_qZpromote_joins)r    Úqueryr9   ÚreuseZ	summarizeZfor_saveZclauseZjoinsr   r   r   Úresolve_expressionW   s    û

zQ.resolve_expressionc                 c   sH   | V  | j D ]6}t|tƒr"|d }t|dƒr<| ¡ E dH  q|V  qdS )zg
        Recursively yield this Q object and all subexpressions, in depth-first
        order.
        é   ÚflattenN)r   r'   Útupler*   r>   )r    Úchildr   r   r   r>   f   s    


z	Q.flattenc              
   C   s
  ddl m}m} ddlm} ddlm} ddlm} |dƒ}| 	¡ D ]*\}	}
t
|
dƒs^||
ƒ}
|j|
|	dd	� qD| |d
ƒd¡ t| jjr¨| t|| d|ƒ d�ƒ¡ n
| | ¡ |j|d�}z| |¡duW S  t�y } zt d| |¡ W Y d}~dS d}~0 0 dS )z|
        Do a database query to check if the expressions of the Q instance
        matches against the expressions.
        r   )ÚBooleanFieldÚValue)ÚCoalesce)ÚQuery)ÚSINGLENr<   F)Úselectr=   Ú_checkT)Úoutput_field)Úusingz.Got a database error calling check() on %r: %s)Zdjango.db.modelsrA   rB   Zdjango.db.models.functionsrC   Zdjango.db.models.sqlrD   Zdjango.db.models.sql.constantsrE   r   r*   Zadd_annotationr   ÚfeaturesZsupports_comparing_boolean_exprZadd_qr   Zget_compilerZexecute_sqlr   ÚloggerÚwarning)r    ZagainstrI   rA   rB   rC   rD   rE   r:   ÚnameÚvalueÚcompilerÚer   r   r   Úchecku   s&    

zQ.checkc                 C   sf   d| j j| j jf }| d¡r*| dd¡}t| jƒ}i }| j| jkrN| j|d< | j	r\d|d< |||fS )Nz%s.%szdjango.db.models.query_utilsr	   r   Tr   )
r$   Ú
__module__Ú__name__Ú
startswithÚreplacer?   r   r   Údefaultr   )r    Úpathr!   r"   r   r   r   r+   ’   s    


zQ.deconstruct)NTNFF)rS   rR   Ú__qualname__Ú__doc__r   r   r   rV   r%   r   r2   r4   r5   r6   r8   r<   r>   r   rQ   r+   Ú__classcell__r   r   r#   r   r   $   s"    ÿ
r   c                   @   s*   e Zd ZdZdd„ Zd	dd„Zd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                 C   s
   || _ d S r   )Úfield)r    r\   r   r   r   r   ¥   s    zDeferredAttribute.__init__Nc                 C   sT   |du r| S |j }| jj}||vrL|  |¡}|du rD|j|gd� 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_chainZrefresh_from_db)r    Úinstancer   ÚdataÚ
field_nameÚvalr   r   r   Ú__get__¨   s    
zDeferredAttribute.__get__c                 C   s6   |j }| | jj¡}| jjr2| j|kr2t||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)Ú_metaZget_ancestor_linkr\   ÚmodelÚprimary_keyr(   r_   )r    ra   ÚoptsZ
link_fieldr   r   r   r`   »   s
    z%DeferredAttribute._check_parent_chain)N)rS   rR   rX   rY   r   re   r`   r   r   r   r   r[   Ÿ   s   
r[   c                   @   st   e Zd Zedd„ ƒZeejdd�dd„ ƒƒZdd„ Zd	d
„ Z	e
dd„ ƒZedd„ ƒZeddd„ƒZeddd„ƒZdS )ÚRegisterLookupMixinc                 C   s   |   ¡  |d ¡S r   )Úget_lookupsÚget)r   Úlookup_namer   r   r   Ú_get_lookupÉ   s    zRegisterLookupMixin._get_lookupN)Úmaxsizec                 C   s   dd„ t  | ¡D ƒ}|  |¡S )Nc                 S   s   g | ]}|j  d i ¡‘qS )Úclass_lookups)r^   rl   )Ú.0Úparentr   r   r   Ú
<listcomp>Ð   s   z3RegisterLookupMixin.get_lookups.<locals>.<listcomp>)ÚinspectÚgetmroÚmerge_dicts)r   rp   r   r   r   rk   Í   s    ÿzRegisterLookupMixin.get_lookupsc                 C   sN   ddl m} |  |¡}|d u r4t| dƒr4| j |¡S |d urJt||ƒsJd S |S )Nr   )ÚLookuprH   )Údjango.db.models.lookupsrw   rn   r*   rH   Ú
get_lookupÚ
issubclass)r    rm   rw   Úfoundr   r   r   ry   Õ   s    
zRegisterLookupMixin.get_lookupc                 C   sN   ddl m} |  |¡}|d u r4t| dƒr4| j |¡S |d urJt||ƒsJd S |S )Nr   )Ú	TransformrH   )rx   r|   rn   r*   rH   Úget_transformrz   )r    rm   r|   r{   r   r   r   r}   ß   s    
z!RegisterLookupMixin.get_transformc                 C   s    i }t | ƒD ]}| |¡ q|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)ZdictsÚmergedÚdr   r   r   rv   é   s    zRegisterLookupMixin.merge_dictsc                 C   s   t | ƒD ]}|j ¡  qd S r   )r   rk   Úcache_clearr   r   r   r   Ú_clear_cached_lookupsô   s    z)RegisterLookupMixin._clear_cached_lookupsc                 C   s4   |d u r|j }d| jvri | _|| j|< |  ¡  |S )Nrp   )rm   r^   rp   rƒ   ©r   Úlookuprm   r   r   r   Úregister_lookupù   s    

z#RegisterLookupMixin.register_lookupc                 C   s"   |du r|j }| j|= |  ¡  dS )zn
        Remove given lookup from cls lookups. For use in tests only as it's
        not thread-safe.
        N)rm   rp   rƒ   r„   r   r   r   Ú_unregister_lookup  s    z&RegisterLookupMixin._unregister_lookup)N)N)rS   rR   rX   Úclassmethodrn   Ú	functoolsÚ	lru_cacherk   ry   r}   Ústaticmethodrv   rƒ   r†   r‡   r   r   r   r   rj   È   s   






	rj   Fc                 C   sŽ   | j s
dS | j jr|sdS |rD|r2|  ¡ |vr2dS |sD| j|vrDdS |sR| jrRdS |rŠ| j|vrŠ|rŠ| j|v rŠd| jjj| jf }t	|ƒ‚dS )ap  
    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.
     * load_fields - the set of fields to be loaded on this model
     * reverse - boolean, True if we are checking a reverse select related
    FzXField %s.%s cannot be both deferred and traversed using select_related at the same time.T)
Zremote_fieldZparent_linkZrelated_query_namerM   Únullr_   rg   rf   Zobject_namer   )r\   Z
restrictedÚ	requestedZload_fieldsÚreverseÚmsgr   r   r   Úselect_related_descend  s&    

ýr�   c                 C   sV   t dt| ƒd ƒD ]>}t | d|… ¡}||v r|| r|| | |d… f  S qd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.
    r=   r   N)Fr   )ÚrangeÚlenr   Újoin)Zlookup_partsÚannotationsÚnZlevel_n_lookupr   r   r   Úrefs_expression4  s
    r–   c                    s,   ‡ fd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                    s*   ˆ j j| jkp(| jˆ j  ¡ v p(ˆ |  ¡ v S r   )rf   Zconcrete_modelZget_parent_list)ri   ©rg   r   r   rQ   I  s
    ÿ
ýz-check_rel_lookup_compatibility.<locals>.checkrh   F)r(   rg   rf   )rg   Ztarget_optsr\   rQ   r   r—   r   Úcheck_rel_lookup_compatibilityA  s    ÿr˜   c                   @   s@   e Zd ZdZeƒ dœdd„Zdd„ Zdd„ Zd	d
„ Zdd„ Z	dS )ÚFilteredRelationz7Specify custom filtering in the ON clause of SQL joins.©Ú	conditionc                C   s:   |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›   rW   )r    r�   r›   r   r   r   r   a  s    
zFilteredRelation.__init__c                 C   s4   t || jƒstS | j|jko2| j|jko2| j|jkS r   )r'   r$   ÚNotImplementedr�   rž   r›   r3   r   r   r   Ú__eq__k  s    
ÿ
ýzFilteredRelation.__eq__c                 C   s,   t | j| jd�}| j|_| jd d … |_|S )Nrš   )r™   r�   r›   rž   rW   )r    Úcloner   r   r   r¡   t  s    zFilteredRelation.clonec                 O   s   t dƒ‚dS )zz
        QuerySet.annotate() only accepts expression-like arguments
        (with a resolve_expression() method).
        z0FilteredRelation.resolve_expression() is unused.N)ÚNotImplementedError)r    r!   r"   r   r   r   r<   z  s    z#FilteredRelation.resolve_expressionc                 C   s&   |j }|j| jt| jƒd�}| |¡S )N)r;   )r:   Zbuild_filtered_relation_qr›   ÚsetrW   Úcompile)r    rO   Ú
connectionr:   Úwherer   r   r   Úas_sql�  s    zFilteredRelation.as_sqlN)
rS   rR   rX   rY   r   r   r    r¡   r<   r§   r   r   r   r   r™   ^  s   
	r™   )F)rY   r&   r‰   rt   ÚloggingÚcollectionsr   Zdjango.core.exceptionsr   Z	django.dbr   r   r   Zdjango.db.models.constantsr   Zdjango.utilsr   Ú	getLoggerrK   r
   r   ÚNoder   r[   rj   r�   r–   r˜   r™   r   r   r   r   Ú<module>   s,   
þ{)G
%