o
    8Di                     @  s  U d dl mZ d dlZd dlZd dlZd dlZd dlZd dlm	Z	m
Z
 d dlmZ d dlZd dlmZmZ d dlmZmZmZ d dlmZmZ ejrcd dlmZ ejejejeeejgejej f Ze d	Z!d
Z"dZ#dZ$d Z%dZ&G dd de'Z(			ddddZ)dd Z*dddZ+ej,ej-ej.ej/ej/ej.ej-ej,ej0ej1ej1ej0iZ2ej3ej4ej4ej3iZ5dd  Z6d!d" Z7dd$d%Z8ej,ej/fZ9ej.ej-fZ:g e9e:ej0ej1ej;R Z<ej,ej.ej.ej,ej/ej-ej-ej/iZ=d&e>d'< ej?ej@fZAejBejCfZDdd(d)ZEdd*d+ZFdd,d-ZGdd.d/ZHdd0d1ZIejJejKejLejMejNejKejOejMiZPd&e>d2< i ePejMejKejKejMiZQd&e>d3< dd4d5ZRdd6d7ZSe*eTe(dd8d9ZUdd:d;ZVejWejXejYfZZdd=d>Z[d?d@ Z\dAdB Z]ddCdDZ^ddEdFZ_ddGdHZ`ejaejbfZcdIdJ ZddKdL ZeddMdNZfejgejejf ZhddUdVZidd\d]Zjdd_d`ZkddadbZlej,dcdd ej.dedd ej/dfdd ej-dgdd ej0ekej1eliZmdhe>di< ejnhemZoejpejqfZrddkdlZse*eTe(ddmdnZtddodpZuh dqZvdrds Zwdtdu Zxdvdw Zydxdy Zzdzd{ Z{dd}d~Z|dddZ}dd Z~dddZdddZdddZdddZdddZdd Zdd ZdddZddddZdddZdddZdd ZdddZddddZG dd dZdS )    )annotationsN)dequedefaultdict)reduce)Dialectexp)firstmerge_rangeswhile_changing)find_all_in_scopewalk_in_scope)DialectTypesqlglotfinali      c                   @  s   e Zd ZdS )UnsupportedUnitN)__name__
__module____qualname__ r   r   S/var/www/Datamplify/venv/lib/python3.10/site-packages/sqlglot/optimizer/simplify.pyr   #   s    r   F
expressionexp.Expressionconstant_propagationboolcoalesce_simplificationdialectr   c                   s0   t  fdd}t| |} t|  | S )a  
    Rewrite sqlglot AST to simplify expressions.

    Example:
        >>> import sqlglot
        >>> expression = sqlglot.parse_one("TRUE AND TRUE")
        >>> simplify(expression).sql()
        'TRUE'

    Args:
        expression: expression to simplify
        constant_propagation: whether the constant propagation rule should be used
        coalesce_simplification: whether the simplify coalesce rule should be used.
            This rule tries to remove coalesce functions, which can be useful in certain analyses but
            can leave the query more verbose.
    Returns:
        sqlglot.Expression: simplified expression
    c                   s   | g}g }|r|  }|jtrq|jd}|r[t|dr[t|j}d|jt< |jD ]}|	 D ]}||v r?d|jt<  nq2q,|jd}|r[|	 D ]}||v rZd|jt<  nqM|j
}	|| u }
t|}t||
}t||
}t|}t|}rt||
}||ur|| |dd |jddD  |||	f |s|r|  \}}	|| u }
t|j D ]
\}}||| qt|}t|}t||
}t||
} rt|}|	|_
t||
}t|}t|}t|}t |}t!|}||ur|| |s|S )NgroupselectsThavingc                 s  s     | ]}|j ts|V  qd S N)metagetFINAL).0nr   r   r   	<genexpr>q   s    
z.simplify.<locals>._simplify.<locals>.<genexpr>)reverse)"popr"   r#   r$   argshasattrsetexpressionsr   walkparentrewrite_between	uniq_sortabsorb_and_eliminatesimplify_concatsimplify_conditionalspropagate_constantsreplaceextenditer_expressionsappendtupleitemssimplify_notflattensimplify_connectorsremove_complementssimplify_coalescesimplify_literalssimplify_equalitysimplify_parenssimplify_datetruncsort_comparisonsimplify_startswith)r   pre_transformation_stackpost_transformation_stacknoder   groupssr&   r    r/   rootnew_nodekvr   r   r   r   r   	_simplifyB   s|   










0





zsimplify.<locals>._simplify)r   get_or_raiser
   remove_where_true)r   r   r   r   rQ   r   rP   r   simplify'   s
   

TrT   c                    s    fdd}|S )zRDecorator that ignores a simplification function if any of `exceptions` are raisedc                   s    fdd}|S )Nc                   s0   z| g|R i |W S   y   |  Y S w r!   r   )r   r*   kwargs)
exceptionsfuncr   r   wrapped   s
   z)catch.<locals>.decorator.<locals>.wrappedr   )rW   rX   rV   )rW   r   	decorator   s   zcatch.<locals>.decoratorr   )rV   rZ   r   rY   r   catch   s   	r[   returnc                 C  sl   t | tjr4t | jtj}tjtj| j | j	d dtj
| j | j	d ddd} |r4tj| dd} | S )zRewrite x between y and z to x >= y AND x <= z.

    This is done because comparison simplification is only done on lt/lte/gt/gte.
    lowthisr   highFcopy)
isinstancer   Betweenr/   Notand_GTEr_   rb   r*   LTEparen)r   negater   r   r   r0      s   r0   c                 C  s0  t | tjr| j}t|rt S |jtv r1|j}t	
|j}|r'||jd}t|j |j|dS t |tjr}| }t |tjrXttjtj|jddtj|jddddS t |tjruttjtj|jddtj|jddddS t|r}t S t|rt S t|rt S t |tjr|jS | S )z`
    Demorgan's Law
    NOT (x OR y) -> NOT x AND NOT y
    NOT (x AND y) -> NOT x OR NOT y
    )r_   r^   Fra   )rc   r   re   r_   is_nullnull	__class__COMPLEMENT_COMPARISONSr   COMPLEMENT_SUBQUERY_PREDICATESr#   ParenunnestAndri   or_not_leftrightOrrf   always_truefalseis_falsetrue)r   r_   rv   complement_subquery_predicate	conditionr   r   r   r<      sJ   
r<   c                 C  s>   t | tjr| j D ]}| }t || jr|| q| S )zK
    A AND (B AND C) -> A AND B AND C
    A OR (B OR C) -> A OR B OR C
    )rc   r   	Connectorr*   valuesrq   rm   r6   )r   rI   childr   r   r   r=      s   
r=   Tc                 C  s$   dd }t | tjrt| ||S | S )Nc                 S  s8  t | tjrHt|st|rt S t|st|rt S t|s&t|r*t S t|r6t|r6t	 S t|r<|S t|rB|S t
| ||S t | tjrt|sVt|rZt	 S t|rbt|srt|rjt|srt|rvt|rvt S t|r||S t|r|S t
| ||ddS t | tjr||krt S d S d S )NT)rs   )rc   r   rr   rz   ry   is_zerork   rl   rx   r{   _simplify_comparisonrw   always_falseXor)r   ru   rv   r   r   r   _simplify_connectors  sP   z1simplify_connectors.<locals>._simplify_connectors)rc   r   r~   _flat_simplify)r   rL   r   r   r   r   r>   
  s   !r>   z6t.Dict[t.Type[exp.Expression], t.Type[exp.Expression]]INVERSE_COMPARISONSc                 C  s  t |tr}t |tr}|j \}}|j \}}||h}||h}	||	@ }
dd |
D }|
r}|r}zt|| }t|	| }W n tyL   |  Y S w |jr\|jr\| }| }n&|jri|jri|j	}|j	}nt
|}|sqd S t
|}|syd S t|t|}}t||f||ffD ]\\}}\}}t |trt |tr|r||kr|  S ||kr|  S |  S t |trt |tr|r||k r|  S ||kr|  S |  S |s|t |tjrt |tr||krt   S qt |tjrt |tr||krt   S qt |tjr|t |tjr$||kr t   S |  S t |tjr:||kr6t   S |  S t |tjrP||krLt   S |  S t |tjrf||k rbt   S |  S t |tjr|||krxt   S |  S qd S )Nc                 S  s"   h | ]}t |s|jt s|qS r   )_is_constantfindNONDETERMINISTIC)r%   mr   r   r   	<setcomp>P  s   " z'_simplify_comparison.<locals>.<setcomp>)rc   COMPARISONSr*   r   r   StopIteration	is_numberto_py	is_stringnameextract_datecast_as_datetime	itertoolspermutationsLT_LTEGT_GTEr   LTry   GTEQrh   rg   NEQ)r   ru   rv   rs   lllrrlrrlargsrargsmatchingcolumnslraavbbvr   r   r   r   G  sl   
&,,
r   c                 C  sh   t | tr2|s
| js2t|  }|D ]}t |tjr1|j|v r1t | tjr+t	   S t
   S q| S )zP
    Removing complements.

    A AND NOT A -> FALSE
    A OR NOT A -> TRUE
    )rc   AND_ORsame_parentr,   r=   r   re   r_   rr   ry   r{   )r   rL   opsopr   r   r   r?     s   $r?   c           	      C  s   t | tjrz|s| jszt|  }t | tjr&tj}d}tdd |D }nt | tjr/tj	ntj
}dd |D }t| }t|dd D ]\}\}}||| d k rf|dd t|D d	d
i}  | S qG|rzt|t|k rz|| d	d
i} | S )zN
    Uniq and sort a connector.

    C AND A AND B AND B -> A AND B AND C
    Nc                 s  s    | ]	}t ||fV  qd S r!   genr%   er   r   r   r'     s    zuniq_sort.<locals>.<genexpr>c                 S  s   i | ]}t ||qS r   r   r   r   r   r   
<dictcomp>      zuniq_sort.<locals>.<dictcomp>   r   c                 s  s    | ]\}}|V  qd S r!   r   )r%   _r   r   r   r   r'         rb   F)rc   r   r~   r   r:   r=   r   xorrr   rf   rs   r;   	enumeratesortedlenr   )	r   rL   	flattenedresult_funcdedupedarrisqlr   r   r   r   r1     s$   r1   c                   s  t | tr|s| jst | tjrtjntj}t|  }t }t	t
 t	t
}|D ]U}|| t ||s@ | |h q+t| }|D ]	} | | qH| \}	}
t |	tjrl|t|	j|
f ||
f t |
tjr|t|	|
jf ||	f q+|D ]}t ||sq| \}	}
t |	tjr|	j|v r|	|tjkrt nt  qt |
tjr|
j|v r|
|tjkrt nt  qt| t fddD r||tjkrt nt  q|t|	|
f D ]\}}|| || qq| S )z
    absorption:
        A AND (A OR B) -> A
        A OR (A AND B) -> A
        A AND (NOT A OR B) -> A AND B
        A OR (NOT A AND B) -> A OR B
    elimination:
        (A AND B) OR (A AND NOT B) -> A
        (A OR B) AND (A OR NOT B) -> A
    c                 3  s*    | ]}t fd d | D V  qdS )c                 3  s    | ]}| k V  qd S r!   r   )r%   subset)supersetr   r   r'     r   z1absorb_and_eliminate.<locals>.<genexpr>.<genexpr>N)any)r%   r   subopsr   r   r   r'     s   ( z'absorb_and_eliminate.<locals>.<genexpr>)rc   r   r   r   rr   rw   r:   r=   r,   r   listaddr9   unnest_operandsre   	frozensetr_   r6   r{   ry   r   )r   rL   kindr   op_setpairsr   r   r   r   r   other
complementr   r   r   r2     sN   


   
r2   c           
      C  s   t | tjrw|s| jswtjjj| ddrwi }t| dd dD ]#}t |tj	rA|j
|j}}t |tjrAt |tjrAt||f||< q|rwt| tjD ],}|j}||pUd\}}	|durvt||krvt |tjrot |jtjsv||	  qJ| S )z
    Propagate constants for conjunctions in DNF:

    SELECT * FROM t WHERE a = b AND b = 5 becomes
    SELECT * FROM t WHERE a = 5 AND b = 5

    Reference: https://www.sqlite.org/optoverview.html
    T)dnfc                 S  s   t | tjS r!   )rc   r   If)rI   r   r   r   <lambda>  s    z%propagate_constants.<locals>.<lambda>)prune)NNN)rc   r   rr   r   r   	optimizer	normalize
normalizedr   r   ru   rv   ColumnLiteralidr   r/   r#   Isr   Nullr6   rb   )
r   rL   constant_mappingexprr   r   columnr/   	column_idconstantr   r   r   r5     s8   

r5   INVERSE_DATE_OPSINVERSE_OPSc                 C     | j S r!   )r   r   r   r   r   
_is_number3  s   r   c                 C  s   t | tjot| d uS r!   )rc   r   Intervalextract_intervalr   r   r   r   _is_interval7     r   c                 C  s   t | tro| j| j}}|jtvr| S |jrt}t}nt|r$t}t	}n| S |jt
v r:ttj|}|j}| }nttj|}|j|j}}||sQ||rQn||s_||r_||}}n| S | j|t|j ||ddS | S )a4  
    Use the subtraction and addition properties of equality to simplify expressions:

        x + 1 = 3 becomes x = 2

    There are two binary operations in the above expression: + and =
    Here's how we reference all the operands in the code below:

          l     r
        x + 1 = 3
        a   b
    r^   )rc   r   ru   rv   rm   r   r   r   _is_date_literalr   r   tcastr   
IntervalOpr_   intervalBinary)r   r   r   a_predicateb_predicater   r   r   r   r   rB   ;  s4   



rB   c                 C  sl   t | tjrt | tjst| t|S t | tjr#t | jtjr#| jjS t| t	v r4t| | j| 
 p3| S | S r!   )rc   r   r   r~   r   _simplify_binaryNegr_   typer   r   )r   rL   r   r   r   rA   m  s   rA   r   c                 C  s   t | tjrt | jtjrt| j}n| j}t | tjrN|jrN| }t|  kr-tkr7n n| j	jtj
jv sLt|  krAtkrNn | S | j	jtj
jv rN|S | S r!   )rc   r   Castr_   _simplify_integer_castis_intr   TINYINT_MINTINYINT_MAXtoDataTypeSIGNED_INTEGER_TYPESUTINYINT_MINUTINYINT_MAXUNSIGNED_INTEGER_TYPES)r   r_   numr   r   r   r   }  s   (r   c           	      C  s  t | trt|}t|}t | tjrFt |tjr|j}d}n|}d}t|rEt |tjr7|r3t	 S t
 S t|rE|rAt
 S t	 S nt | trMd S t|sUt|rYt S |jr|jr| }| }t | tjrutj|| S t | tjrtj|| S t | tjr|j|ju rtj|| S d S t | tjrt |trt |ts|j|jurd S tj|| S t| ||}|r|S d S |jr|jrt| |j|j}|r|S d S t|r t |tjr t|t|}}|r|rt | tjtjtjfr	t|| t|S t | tjtj tj!frt|| t|S d S t |tjrMt|rMt|t|}}|rK|rKt | tjrKt|| t|S d S t|rrt|rrt | tj"rrt|t|}}t| ||}|rr|S d S )NTF)#rc   r   r   r   r   re   r_   rk   r   r{   ry   NULL_OKrl   r   r   AddnumberMulSubr/   Divinteval_booleanr   r   r   r   r   DateAddDatetimeAdddate_literalextract_typeDateSubDatetimeSub	Predicate)	r   r   r   crt   num_anum_bbooleandater   r   r   r     sz   

  r   c                 C  s   t | tjs| S | j}| j}t |tj}t |tjstt |tjtjfstt |tj	tj
frrt |tjsrt |tj
sCt |tjtjfrr|rrt |tjrK|rrt |tjrWt |tjsrt |tjrct |tjsrt |tjrtt |tjtjfrt|S | S r!   )rc   r   rp   r_   r/   r  SelectSubqueryPredicateBracket	Conditionr   re   r   r  r  r  )r   r_   r/   parent_is_predicater   r   r   rC     sJ   










rC   c                 C     t | tjp	t| S r!   )rc   r   NONNULL_CONSTANTSr   r   r   r   r   _is_nonnull_constant     r  c                 C  r  r!   )rc   r   	CONSTANTSr   r   r   r   r   r     r  r   c              
   C  s>  t | tjr| jrt| jrt | jtjs| jS |dkr| S t | ts%| S t | j	tjr3| j	}| j
}nt | j
tjrA| j
}| j	}n| S t|sI| S t|jD ]
\}}t|rX nqN| S |d|jd |  |jrk|n|j}ttjtj|t jdd|  ddtj|t t| | | dddddS )Nredshiftr-   Fra   r^   )rc   r   Coalescer-   r  r_   r/   Hintr   ru   rv   r   r   r,   ri   rs   rf   is_rl   rt   rb   r   )r   r   coalescer   	arg_indexargr   r   r   r@      sX   

r@   c           	   	   C  s0  t | trt | tjr| jd js| S t | tjr'| j^}}|j}tj}i }n| j}d}tj}| j	d| j	dd}g }t
|pE|  dd D ]\}}|rb|tj|dd	 |D  qJ|| qJt|d
krw|d jrw|d S |tju r|g| }nt | tjrtdd |S |dd|i|S )zFReduces all groups that contain string literals by concatenating them.r    safer#  )r'  r#  c                 S  r   r!   )r   )r   r   r   r   r   [  s    z!simplify_concat.<locals>.<lambda>c                 s  s    | ]}|j V  qd S r!   )r   )r%   stringr   r   r   r'   ^  s    z"simplify_concat.<locals>.<genexpr>r   c                 S  s   t j| |dS Nr^   )r   DPipe)xyr   r   r   r   h      r-   Nr   )rc   CONCATSr   ConcatWsr-   r   r   Concatr*   r#   r   groupbyr=   r9   r   r(  joinr7   r   r*  r   )	r   sep_exprr-   sepconcat_typer*   new_argsis_string_groupr   r   r   r   r3   C  s>   





$
r3   c                 C  s   t | tjrF| j}| jd D ]5}|j}|r|| |}t|r*|jd   S t	|rC|  | jd sC| j
dp@t   S q| S t | tjrlt | jtjslt| jr]| jd S t	| jrl| j
dpkt S | S )zLSimplifies expressions like IF, CASE if their condition is statically known.ifsr{   defaultry   )rc   r   Caser_   r*   r6   r)   eqrx   r   r#   rl   r   r/   )r   r_   casecondr   r   r   r4   m  s(   



r4   c                 C  s6   t | tjr| jjr| jjrt| j| jjS | S )a  
    Reduces a prefix check to either TRUE or FALSE if both the string and the
    prefix are statically known.

    Example:
        >>> from sqlglot import parse_one
        >>> simplify_startswith(parse_one("STARTSWITH('foo', 'f')")).sql()
        'TRUE'
    )	rc   r   
StartsWithr_   r   r   convertr   
startswithr   r   r   r   rF     s   
rF   r  datetime.dateunitstrr   t.Optional[DateRange]c                 C  s(   t | ||}| |krdS ||t| fS )a  
    Get the date range for a DATE_TRUNC equality comparison:

    Example:
        _datetrunc_range(date(2021-01-01), 'year') == (date(2021-01-01), date(2022-01-01))
    Returns:
        tuple of [min, max) or None if a value can never be equal to `date` for `unit`
    N
date_floorr   )r  rB  r   floorr   r   r   _datetrunc_range  s   	rH  ru   drange	DateRangetarget_typet.Optional[exp.DataType]c                 C  s,   t j| t|d |k| t|d |k ddS )z+Get the logical expression for a date ranger   r   Fra   )r   rf   r  )ru   rI  rK  r   r   r   _datetrunc_eq_expression  s
   rM  t.Optional[exp.Expression]c                 C  s    t |||}|s
d S t| ||S r!   )rH  rM  ru   r  rB  r   rK  rI  r   r   r   _datetrunc_eq  s   rP  c                 C  s@   t |||}|s
d S tj| t|d |k | t|d |kddS )Nr   r   Fra   )rH  r   rf   r  rO  r   r   r   _datetrunc_neq  s   rQ  c                 C  s8   | t |t|||kr||k S t|||t| |k S r!   r  rF  r   r   dtudr   r   r   r   r     s
    r   c                 C  s   | t t|||t| |kS r!   rR  rS  r   r   r   r         c                 C  s   | t t|||t| |k S r!   rR  rS  r   r   r   r     rW  c                 C  s   | t t||||kS r!   )r  	date_ceilrS  r   r   r   r     r   z8t.Dict[t.Type[exp.Expression], DateTruncBinaryTransform]DATETRUNC_BINARY_COMPARISONSrv   c                 C  s   t | tot|S r!   )rc   
DATETRUNCSr   )ru   rv   r   r   r   _is_datetrunc_predicate     r[  c                   s  | j }t| tr&| j}t|}t|}|r%| jr%tt|| jj	
 ||S n|tvr,| S t| tjrf| j| j }t |s@| S ttj   j} jj	
 }t|}|sX| S t| ||||t|pe| S t| tjr| j | j}	|	rt fdd|	D rttj   jj	
 }g }
|	D ]}t|}|s|   S t|||}|r|
| q|
s| S t|
}
t|	 tj fdd|
D ddiS | S )zOSimplify expressions like `DATE_TRUNC('year', x) >= CAST('2021-01-01' AS DATE)`c                 3  s    | ]}t  |V  qd S r!   )r[  )r%   r   )r   r   r   r'     s    z%simplify_datetrunc.<locals>.<genexpr>c                   s   g | ]}t  |qS r   )rM  )r%   rI  r   rK  r   r   
<listcomp>'  s    z&simplify_datetrunc.<locals>.<listcomp>rb   F)rm   rc   rZ  r_   r  r   rB  r  rF  r   lowerDATETRUNC_COMPARISONSr   r   ru   rv   r[  r   r   	DateTruncrY  Inr-   allrH  r9   r	   rs   )r   r   
comparisonr_   
trunc_typer  r   	trunc_argrB  rsrangesrI  r   r]  r   rD     sd   



rD   c                 C  s   | j tv rL| j| j}}t|tj}t|tj}t|}t|}|r$|r.|r(|r.t|tjr0| S |r4|r@|r8|r@t	|t	|krLt
| j | j ||dS | S r)  )rm   rn   r_   r   rc   r   r   r   r  r   r   r#   )r   r   r   l_columnr_columnl_constr_constr   r   r   rE   -  s,   

 rE   >   r&  r&  r&  INNERRIGHTr&  rq  OUTERc                 C  s   |  tjD ]}t|jr|  q|  tjD ]1}t|jdrI|jdsI|jdsI|j	|j
ftv rI|jd   |dd  |dd qd S )Nonusingmethodsider   CROSS)find_allr   Whererx   r_   r)   Joinr*   r#   rw  r   JOINSr,   )r   wherer2  r   r   r   rS   M  s"   


rS   c                 C  s(   t | tjr	| jpt | tjot|  S r!   )rc   r   Booleanr_   r   r   r   r   r   r   rx   ]  s   rx   c                 C  s   t | pt| pt| S r!   )rz   rk   r   r   r   r   r   r   c  r   r   c                 C  s   t | tjo|  dkS )Nr   )rc   r   r   r   r   r   r   r   r   g  r   r   c                 C  s   t |tjo
|j| kS r!   )rc   r   re   r_   r   r   r   r   r   is_complementk     r  r   c                 C  s   t | tju o
| j S r!   )r   r   r~  r_   r   r   r   r   rz   o  r  rz   c                 C  s   t | tju S r!   )r   r   r   r  r   r   r   rk   s  s   rk   c                 C  s   t | tjtjfrt||kS t | tjrt||kS t | tjr't||kS t | tjr3t||kS t | tjr?t||k S t | tj	rKt||kS d S r!   )
rc   r   r   r   boolean_literalr   r   rg   r   rh   )r   r   r   r   r   r   r  w  s   r  valuet.Anyt.Optional[datetime.date]c                 C  sL   t | tjr
|  S t | tjr| S z	tj|  W S  ty%   Y d S w r!   )rc   datetimer  fromisoformat
ValueErrorr  r   r   r   cast_as_date  s   r  t.Optional[datetime.datetime]c                 C  sV   t | tjr| S t | tjrtj| j| j| jdS ztj| W S  ty*   Y d S w )N)yearmonthday)rc   r  r  r  r  r  r  r  r  r   r   r   r     s   r   r   exp.DataType1t.Optional[t.Union[datetime.date, datetime.date]]c                 C  s:   | sd S | tjjjrt| S |j tjj rt| S d S r!   )is_typer   r   TypeDATEr  TEMPORAL_TYPESr   )r  r   r   r   r   
cast_value  s   r  r   c                 C  s   t | tjr
| j}nt | tjr | jds tjtjj	j
}nd S t | jtjr.| jj}nt | jtjtjfr>t| j}nd S t||S )Nformat)rc   r   r   r   TsOrDsToDater*   r#   r   buildr  r  r_   r   r   r   r  )r   r   r  r   r   r   r     s   

r   c                 C  s   t | d uS r!   )r   r   r   r   r   r     s   r   c              
   C  sD   zt | j }| d }t||W S  tttfy!   Y d S w )NrB  )	r  r_   r   textr_  r   r   ModuleNotFoundErrorr  )r   r&   rB  r   r   r   r     s   r   c                  G  s4   d }| D ]}t |tjr|jn|j}|r |S q|S r!   )rc   r   r   r   r   )r-   rK  r   r   r   r   r    s   r  c                 C  sF   |r	|j tjj st| tjrtjjjntjjj}t	tj
| |S r!   )r  r   r   r  rc   r  r  DATETIMEr  r   r   r(  )r  rK  r   r   r   r    s   
r  r   r&   r  c                 C  s   ddl m} | dkr|d| dS | dkr|d| dS | d	kr'|d| dS | d
kr2|d| dS | dkr=|d| dS | dkrH|d| dS | dkrS|d| dS | dkr^|d| dS td|  )Nr   )relativedeltar  r   )yearsquarter   )monthsr  week)weeksr  dayshour)hoursminute)minutessecond)secondsUnsupported unit: )dateutil.relativedeltar  r   )rB  r&   r  r   r   r   r     s$   r   rV  c                 C  s   |dkr| j dddS |dkr:| jdkr| j dddS | jdkr'| j dddS | jdkr3| j d	ddS | j d
ddS |dkrF| j | jddS |dkrW| tj|  |j d S |dkr]| S td| )Nr  r   )r  r  r  r        	      
   r  r  r  r  r  )r6   r  r  	timedeltaweekdayWEEK_OFFSETr   )rV  rB  r   r   r   r   rF    s"   


rF  c                 C  s$   t | ||}|| kr| S |t| S r!   rE  )rV  rB  r   rG  r   r   r   rX    s   rX  c                 C  s   | rt  S t  S r!   )r   r{   ry   )r}   r   r   r   r    r  r  c           	        s   |s j sMg }t jdd}t|}|r=| }|D ]}| ||}|r5| ur5|| ||  nq|| |st||k rMt	 fdd|S  S )NF)rq   c                   s    j | |dS r)  )rm   r  r   r   r   r   *  r-  z _flat_simplify.<locals>.<lambda>)
r   r   r=   r   popleftremove
appendleftr9   	functoolsr   )	r   
simplifierrL   operandsqueuesizer   r   resultr   r   r   r     s(   



r   commentsc                 C  s   t  j| |dS )a~  Simple pseudo sql generator for quickly generating sortable and uniq strings.

    Sorting and deduping sql is a necessary step for optimization. Calling the actual
    generator is expensive so we have a bare minimum sql generator here.

    Args:
        expression: the expression to convert into a SQL string.
        comments: whether to include the expression's comments.
    )r  )Genr   )r   r  r   r   r   r   /  s   
r   c                   @  s  e Zd Zdd Zddd
dZdddZdddZdddZdddZdddZ	dddZ
dd!d"Zdd$d%Zdd'd(Zdd*d+Zdd-d.Zdd0d1Zdd3d4Zdd6d7Zdd9d:Zdd<d=Zdd?d@ZddBdCZddEdFZddHdIZddKdLZddNdOZddQdRZddTdUZddWdXZddZd[Zdd]d^Zdd`daZ ddcddZ!ddfdgZ"ddidjZ#ddldmZ$ddodpZ%ddrdsZ&ddudvZ'ddxdyZ(dd{d|Z)dddZ*dddZ+dddZ,ddddZ-dS )r  c                 C  s   g | _ g | _d S r!   )stacksqls)selfr   r   r   __init__=  s   
zGen.__init__Fr   r   r  r   r\   rC  c                 C  s*  |g| _ | j  | j r| j  }t|tjr_|r*|jr*| j dd	|j d |j
 d}t| |r=t| || nOt|tjrI| | nC|j
 }| j | |r[| dn| n-t|tu rt|D ]}|d urw| j |df qi|r| j   n|d ur| jt| | j sd	| jS )Nz /*,z*/_sql r&  )r  r  clearr)   rc   r   
Expressionr  r9   r2  keyr+   getattrFunc	_functionupper_argsr   r   reversedr7   rC  )r  r   r  rI   exp_handler_namer  r&   r   r   r   r   A  s4   




"
zGen.genr   exp.AddNonec                 C     |  |d d S )Nz + _binaryr  r   r   r   r   add_sqla     zGen.add_sql	exp.Aliasc                 C  s&   | j |jdd|jdf d S )Nalias AS r_   )r  r7   r*   r#   r  r   r   r   	alias_sqld  s   

zGen.alias_sqlexp.Andc                 C  r  )N AND r  r  r   r   r   and_sqlm  r  zGen.and_sqlexp.Anonymousc                 C  sv   |j }t|tr| }n!t|tjr$|j }|jrd| dn| }n
td|jj	 d| j
d|jd|f d S )N"z4Anonymous.this expects a str or an Identifier, got 'z'.)()r_   rc   rC  r  r   
Identifierquotedr  rm   r   r  r7   r-   )r  r   r_   r   r   r   r   anonymous_sqlp  s    

zGen.anonymous_sqlexp.Betweenc                 C  s,   | j |jdd|jdd|jf d S )Nr`   r  r]   z	 BETWEEN )r  r7   r*   r#   r_   r  r   r   r   between_sql  s   

zGen.between_sqlexp.Booleanc                 C  s    | j |jrd d S d d S )NTRUEFALSEr  r9   r_   r  r   r   r   boolean_sql  s    zGen.boolean_sqlexp.Bracketc                 C  s   | j d|jd|jf d S )N][)r  r7   r-   r_   r  r   r   r   bracket_sql  s   zGen.bracket_sql
exp.Columnc                 C  s.   t |jD ]
}| j|df q| j  d S N.)r  partsr  r7   r)   )r  r   pr   r   r   
column_sql  s   zGen.column_sqlr  c                 C  s&   |  |d | j|jj d d S )Nr   r  )r  r  r9   r_   r   r  r   r   r   datatype_sql  s   zGen.datatype_sqlexp.Divc                 C  r  )Nz / r  r  r   r   r   div_sql  r  zGen.div_sqlexp.Dotc                 C  r  r  r  r  r   r   r   dot_sql  r  zGen.dot_sqlexp.EQc                 C  r  )Nz = r  r  r   r   r   eq_sql  r  z
Gen.eq_sqlexp.Fromc                 C  s   | j |jdf d S )NzFROM r  r7   r_   r  r   r   r   from_sql  r  zGen.from_sqlexp.GTc                 C  r  )Nz > r  r  r   r   r   gt_sql  r  z
Gen.gt_sqlexp.GTEc                 C  r  )Nz >= r  r  r   r   r   gte_sql  r  zGen.gte_sqlexp.Identifierc                 C  ,   | j |jrd|j d d S |j d S )Nr  )r  r9   r  r_   r  r   r   r   identifier_sql     ,zGen.identifier_sql	exp.ILikec                 C  r  )Nz ILIKE r  r  r   r   r   	ilike_sql  r  zGen.ilike_sqlexp.Inc                 C  s0   | j d | |d | j dd|jf d S )Nr  r   r  z IN )r  r9   r  r7   r_   r  r   r   r   in_sql  s   z
Gen.in_sql
exp.IntDivc                 C  r  )Nz DIV r  r  r   r   r   
intdiv_sql  r  zGen.intdiv_sqlexp.Isc                 C  r  )Nz IS r  r  r   r   r   is_sql  r  z
Gen.is_sqlexp.Likec                 C  r  )Nz Like r  r  r   r   r   like_sql  r  zGen.like_sqlexp.Literalc                 C  r  )N')r  r9   r   r_   r  r   r   r   literal_sql  r
  zGen.literal_sqlexp.LTc                 C  r  )Nz < r  r  r   r   r   lt_sql  r  z
Gen.lt_sqlexp.LTEc                 C  r  )Nz <= r  r  r   r   r   lte_sql  r  zGen.lte_sqlexp.Modc                 C  r  )Nz % r  r  r   r   r   mod_sql  r  zGen.mod_sqlexp.Mulc                 C  r  )Nz * r  r  r   r   r   mul_sql  r  zGen.mul_sqlexp.Negc                 C  r  )N-_unaryr  r   r   r   neg_sql  r  zGen.neg_sqlexp.NEQc                 C  r  )Nz <> r  r  r   r   r   neq_sql  r  zGen.neq_sqlexp.Notc                 C  r  )NzNOT r"  r  r   r   r   not_sql  r  zGen.not_sqlexp.Nullc                 C  s   | j d d S )NNULL)r  r9   r  r   r   r   null_sql  r  zGen.null_sqlexp.Orc                 C  r  )Nz OR r  r  r   r   r   or_sql  r  z
Gen.or_sql	exp.Parenc                 C  s   | j d|jdf d S Nr  r  r  r  r   r   r   	paren_sql  s   zGen.paren_sqlexp.Subc                 C  r  )Nz - r  r  r   r   r   sub_sql  r  zGen.sub_sqlexp.Subqueryc                 C  s@   |  |d |jd}|r| j| | jd|jdf d S )N   r  r  r  )r  r*   r#   r  r9   r7   r_   )r  r   r  r   r   r   subquery_sql  s
   zGen.subquery_sql	exp.Tablec                 C  sV   |  |d |jd}|r| j| t|jD ]
}| j|df q| j  d S )Nr  r  r  )	r  r*   r#   r  r9   r  r  r7   r)   )r  r   r  r  r   r   r   	table_sql  s   zGen.table_sqlexp.TableAliasc                 C  s2   |j }|r| jd|df | j|jdf d S )Nr  r  r  )r   r  r7   r_   )r  r   r   r   r   r   tablealias_sql  s   zGen.tablealias_sqlexp.Varc                 C  s   | j |j d S r!   r  r  r   r   r   var_sql  r\  zGen.var_sql
exp.Binaryr   c                 C  s   | j |j||jf d S r!   )r  r7   r   r_   r  r   r   r   r   r   r    s   zGen._binary	exp.Unaryc                 C  s   | j |j|f d S r!   r  r=  r   r   r   r#    r  z
Gen._unaryexp.Funcc                 C  s&   | j dt|j d| f d S r/  )r  r7   r   r*   r   sql_namer  r   r   r   r    s   zGen._functionr   rI   r$  r  c                 C  sn   g }|rt |j|d  n|j}|p|D ]}|j|}|d ur*|d| |g q|r5| j| dS dS )N:TF)r   	arg_typesr*   r#   r9   r  )r  rI   r$  kvsrB  rN   rO   r   r   r   r  '  s   z	Gen._argsNF)r   r   r  r   r\   rC  )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  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  )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  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   r1  r\   r  )r   r3  r\   r  )r   r6  r\   r  )r   r8  r\   r  )r   r:  r\   r  )r   r<  r   rC  r\   r  )r   r>  r   rC  r\   r  )r   r?  r\   r  )r   )rI   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  r  r  r$  r&  r(  r+  r-  r0  r2  r5  r7  r9  r;  r  r#  r  r  r   r   r   r   r  <  sX    
 

	






























	


	




r  )FFN)r   r   r   r   r   r   r   r   )r   r   r\   r   )TrD  )r   r   r\   r   )r   r   r\   r   )r   r   r   r   r\   r   )r  rA  rB  rC  r   r   r\   rD  )ru   r   rI  rJ  rK  rL  r\   r   )ru   r   r  rA  rB  rC  r   r   rK  rL  r\   rN  )ru   r   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   )rB  rC  r&   r  )rV  rA  rB  rC  r   r   r\   rA  )r   r  r  r   r\   rC  )
__future__r   r  loggingr  r   typingr   collectionsr   r   r   r   r   r   sqlglot.helperr   r	   r
   sqlglot.optimizer.scoper   r   TYPE_CHECKINGsqlglot.dialects.dialectr   Callabler  r  rC  r   OptionalDateTruncBinaryTransform	getLoggerloggerr$   r   r   r   r   	Exceptionr   rT   r[   r0   r   rg   r   rh   r   r   rn   AllAnyro   r<   r=   r>   r   r   r   r   r   __annotations__RandRandnr   rr   rw   r   r   r?   r1   r2   r5   r	  r  r  r  r
  r  r   r   r   r   r  rB   rA   
NullSafeEQNullSafeNEQ
PropertyEQr  r   r   rC   r  r   r@   r0  r*  r.  r3   r4   rF   TuplerJ  rH  rM  rP  rQ  rY  rb  r`  ra  TimestampTruncrZ  r[  rD   rE   r|  rS   rx   r   r   r  rz   rk   r  r  r   r  r   r   r   r  r  r   rF  rX  r  r   r   r  r   r   r   r   <module>   s   
t

0
'	

>

!
H(


1
H


@*








	

@







	



	
