o
    8Di                     @  s  d dl mZ d dlZd dlZd dlmZmZ d dlm	Z	m
Z
 d dlmZ d dlmZmZ d dlmZ d dlmZmZmZmZ d d	lmZ d d
lmZmZ ejrUd dlmZ 					didjddZdkddZ dld#d$Z!dmd(d)Z"dnd/d0Z#	dodpd3d4Z$dqd5d6Z%drd7d8Z&	dodsd=d>Z'dtdBdCZ(drdDdEZ)dudFdGZ*dvdJdKZ+dwdQdRZ,dxdUdVZ-dydYdZZ.dzd]d^Z/d{dadbZ0d|d}dddeZ1d~dfdgZ2G dhd- d-Z3dS )    )annotationsN)aliasexp)DialectDialectType)OptimizeError)seq_getSingleValuedMapping)TypeAnnotator)Scopebuild_scopetraverse_scopewalk_in_scope)simplify_parens)Schemaensure_schema)ETF
expressionexp.Expressionschemat.Dict | Schemaexpand_alias_refsboolexpand_starsinfer_schemat.Optional[bool]allow_partial_qualificationdialectr   returnc                 C  sJ  t ||d}t|}|du r|jn|}t|j}|j}|dk}	t| D ]~}
|
j}t	|t
j}|rD|jdrD|jdd dd |
  t|
||d	}t|
j t|
j t|
|}|js`|jrj|rjt|
|||	d
 t|
| t|
||d |js|rt|
|| |r|rt|
|||| t|
 t|
| t|
| |	r||
 q$| S )a  
    Rewrite sqlglot AST to have fully qualified columns.

    Example:
        >>> import sqlglot
        >>> schema = {"tbl": {"col": "INT"}}
        >>> expression = sqlglot.parse_one("SELECT col FROM tbl")
        >>> qualify_columns(expression, schema).sql()
        'SELECT tbl.col AS col FROM tbl'

    Args:
        expression: Expression to qualify.
        schema: Database schema.
        expand_alias_refs: Whether to expand references to aliases.
        expand_stars: Whether to expand star queries. This is a necessary step
            for most of the optimizer's rules to work; do not set to False unless you
            know what you're doing!
        infer_schema: Whether to infer the schema if missing.
        allow_partial_qualification: Whether to allow partial qualification.

    Returns:
        The qualified expression.

    Notes:
        - Currently only handles a single PIVOT or UNPIVOT operator
    )r   Nbigqueryconnectc                 S  s    t | tjr| jdkr| jS | S )NLEVEL)
isinstancer   Columnnamethis)n r'   Z/var/www/Datamplify/venv/lib/python3.10/site-packages/sqlglot/optimizer/qualify_columns.py<lambda>E   s     z!qualify_columns.<locals>.<lambda>Fcopy)r   )expand_only_groupby)r   )r   r
   emptyr   get_or_raiser   PSEUDOCOLUMNSr   r   r"   r   Selectargsget	transformclear_cacheResolver_pop_table_column_aliasesctesderived_tables_expand_usingFORCE_EARLY_ALIAS_REF_EXPANSION_expand_alias_refs_convert_columns_to_dots_qualify_columns_expand_starsqualify_outputs_expand_group_by _expand_order_by_and_distinct_onannotate_scope)r   r   r   r   r   r   r   	annotatorpseudocolumnsr   scopescope_expression	is_selectresolverusing_column_tablesr'   r'   r(   qualify_columns   s\   #







rJ   r   c                   s   g }t | D ]R}t|jtjrX|j}|jr6|js6|js6|jd }|j	r*d|j	 dnd}t
d| d| |rS|jrS|jd jrStt|jd   fdd|D }|| q|rbt
d	| | S )
z8Raise an `OptimizeError` if any columns aren't qualifiedr   z for table: '' zColumn 'z' could not be resolvedc                      g | ]}| vr|qS r'   r'   .0cunpivot_columnsr'   r(   
<listcomp>       z,validate_qualify_columns.<locals>.<listcomp>zAmbiguous columns: )r   r"   r   r   r0   unqualified_columnsexternal_columnsis_correlated_subquerypivotstabler   unpivotset_unpivot_columnsextend)r   all_unqualified_columnsrE   rU   column	for_tabler'   rQ   r(   validate_qualify_columnst   s    

ra   rZ   	exp.Pivott.Iterator[exp.Column]c                 C  s,   dd | j D }dd | jD }t||S )Nc                 S  s,   g | ]}t |tjrt |jtjr|jqS r'   )r"   r   Inr%   r#   )rO   fieldr'   r'   r(   rS      s    
z$_unpivot_columns.<locals>.<listcomp>c                 s  s&    | ]}| tjD ]}|V  q
qd S N)find_allr   r#   rO   erP   r'   r'   r(   	<genexpr>   s   $ z#_unpivot_columns.<locals>.<genexpr>)fieldsexpressions	itertoolschain)rZ   name_columnsvalue_columnsr'   r'   r(   r\      s
   r\   r8   t.List[exp.CTE | exp.Subquery]Nonec                 C  sD   | D ]}t |jtjr|jjrq|jd}|r|jdd qdS )z
    Remove table column aliases.

    For example, `col1` and `col2` will be dropped in SELECT ... FROM (SELECT ...) AS foo(col1, col2)
    r   columnsN)r"   parentr   With	recursiver1   r2   pop)r8   derived_tabletable_aliasr'   r'   r(   r6      s   r6   rE   r   rH   r5   t.Dict[str, t.Any]c              
     s  i dfdd}t | tj}dd |D fd	d
| jD }r2|s2td d| j i }|D ]}|| q6t|D ]\}}|d }	|	rO||	 |j}
|	|
 |j
d}|s`qA|
}g }t|}|j}|D ]}j}|r|vrrdvr|rtd |p|	}|dks|dkrtj|d}n%fdd
|d d D }t|dkrtjdg|R  }ntj|d}|	|tj|
d |i }|s||vrd ||< |
|vrd ||
< qp|j
d |dtj|ddi qA|rV| jD ]N  jsT j|v rT| j } fdd
|D }tjdg|R  }t jtjr;t| jdd}nt jtjrNtjt j|d}|   | q|S )Nsource_namestrr   rr   c                   s$    | D ]
}| vr|  |< qd S rf   get_source_columns)r{   column_name)rs   rH   r'   r(   _update_source_columns   s
   z-_expand_using.<locals>._update_source_columnsc                 S     h | ]}|j qS r'   alias_or_name)rO   joinr'   r'   r(   	<setcomp>       z _expand_using.<locals>.<setcomp>c                   rM   r'   r'   )rO   key)namesr'   r(   rS      rT   z!_expand_using.<locals>.<listcomp>zJoins z missing source table using*zCannot automatically join: r      rY   c                   s(   g | ]}  |v rtj |d qS r   )r~   r   r_   )rO   t)
identifierrH   r'   r(   rS      s
    coalesceonr+   Fc                   s   g | ]
}t j j|d qS r   )r   r_   r$   rO   rY   )r_   r'   r(   rS          r   r+   )r%   r   )r{   r|   r   rr   )!listrg   r   Joinselected_sourcesr   r   	enumerater   appendr1   r2   r~   lenis_semi_or_anti_joinr$   r_   funceq
setdefaultrw   r[   and_rs   rY   r"   rt   r0   r   Struct
PropertyEQto_identifierreplace)rE   rH   r   joinsorderedcolumn_tablesr{   ir   source_table
join_tabler   join_columns
conditionsusing_identifier_countr   rY   lhscoalesce_columnstablescoalesce_argsreplacementr'   )r_   rs   r   r   rH   r(   r9      s~   






r9   r   r,   c                   s`  | j }t|tjrdkrdS i  dd |jD 	dd fdd}t|jD ]\}}|| t|tjrC|j|d f |j< q+| }|j	rO|j
}|j	sI|jrq|j j
}	|	tjjrq|	jd jpf|	jjD ]	}
 |
jd qg||jd ||jddd ||jddd ||jddd dkr|jdpg D ]}|| q|   dS )z
    Expand references to aliases.
    Example:
        SELECT y.foo AS bar, bar * 2 AS baz FROM y
     => SELECT y.foo AS bar, y.foo * 2 AS baz FROM y
    oracleNc                 S  r   r'   r   rO   sr'   r'   r(   r     r   z%_expand_alias_refs.<locals>.<setcomp>Fnodet.Optional[exp.Expression]resolve_tabler   literal_indexr   rr   c                   sz  t | tj}t | tj}| rr|sd S t| dd dD ]}t |tjs%qr/|r/|j| ur/qd}|r<|js<|j	nd } 
|j	d\}}	|r{t|tjob|tjobt |tjtjtj }|r{dkr{|pztfdd|tjD }|r|r|r|d	| q|js|r|st |tjr|s|r|r|tj|	 q|t|}t|}
|
|ur||
 qd S )
Nc                 S  s   | j S rf   )is_star)r   r'   r'   r(   r)   #  s    z=_expand_alias_refs.<locals>.replace_columns.<locals>.<lambda>)pruneF)Nr   r   c                 3       | ]}|j d  j v V  qdS r   Npartsr$   )rO   r   )projectionsr'   r(   rj   =  
    
z>_expand_alias_refs.<locals>.replace_columns.<locals>.<genexpr>rY   )r"   r   GroupHavingr   r#   rt   rY   	get_tabler$   r2   r   findAggFuncfind_ancestorWindowr0   anyrg   r[   Literalr   numberparenr   )r   r   r   is_group_by	is_havingr_   skip_replacerY   
alias_exprr   
simplifiedalias_to_expressionr   r,   r   rH   r'   r(   replace_columns  sH   
	

z+_expand_alias_refs.<locals>.replace_columnsr   r   wheregroupT)r   having)r   qualify	snowflaker   )FF)r   r   r   r   r   r   r   rr   )r   r"   r   r0   selectsr   Aliasr%   r   is_unionrt   is_cter   ru   rv   r1   rs   rw   output_namer2   r4   )rE   rH   r   r,   r   r   r   
projectionparent_scopecterecursive_cte_columnr   r'   r   r(   r;   
  s:   	3
r;   c                 C  s@   | j }|jd}|sd S |dt| |j| |d| d S )Nr   rl   )r   r1   r2   r[   _expand_positional_referencesrl   )rE   r   r   r   r'   r'   r(   r@   l  s   r@   c              
   C  s  dD ]}| j j|}t|tjr|jd}t|tjsq|j}|dkr,dd |D }t|t	| ||j
jddD ](\}}|tjD ]}|tjD ]}|jsZ|d||j qKqC|| q9| j jd	rd
d | j jD }	|D ]}
|
|
jrtt| |
jn|	|
|
 qtqd S )N)orderdistinctr   r   c                 S     g | ]}|j qS r'   r%   )rO   r   r'   r'   r(   rS     r   z4_expand_order_by_and_distinct_on.<locals>.<listcomp>Tr   rY   r   c                 S  s   i | ]
}|j t|jqS r'   )r%   r   r_   r   r   r'   r'   r(   
<dictcomp>  r   z4_expand_order_by_and_distinct_on.<locals>.<dictcomp>)r   r1   r2   r"   r   Distinct
Expressionrl   zipr   r   r   rg   r   r#   rY   r[   r   r$   r   r   is_intr   _select_by_posr   )rE   rH   modifier_keymodifiermodifier_expressionsoriginalexpandedaggcolr   r   r'   r'   r(   rA   v  s@   
rA   rl   t.Iterable[exp.Expression]r   t.List[exp.Expression]c                   s   g }d  |D ]j}|j rktttj|}|r%|t|jd 	  q|j
}|dkrK d u r;fddjjD  t fdd|tjD }nd}t|tjs]|tjtjs]|rc|| q||	  q|| q|S )Nr   r   c                   s   h | ]}|j  jv r|j qS r'   )r   r   r   )rE   r'   r(   r     s
    z0_expand_positional_references.<locals>.<setcomp>c                 3  r   r   r   )rO   r_   )ambiguous_projectionsr'   r(   rj     r   z0_expand_positional_references.<locals>.<genexpr>F)r   r   r   castr   r   r   r_   r1   r+   r%   r   r   r   rg   r#   r"   	CONSTANTSr   ExplodeUnnest)rE   rl   r   r   	new_nodesr   select	ambiguousr'   )r   rE   r(   r     s6   



r   r   exp.Literal	exp.Aliasc                 C  s@   z| j jt|jd  tjW S  ty   td|j	 w )Nr   zUnknown output column: )
r   r   intr%   	assert_isr   r   
IndexErrorr   r$   )rE   r   r'   r'   r(   r     s
    r   c              	   C  s   d}t | j| jD ]L}t|tjrq
|j}|rV|| jvrV| j	r)|| j	jvs)| j
sV|j^}}|j| jv r;|}|^}}n||j}|rVd}|tjtj||dg| q
|r_|   dS dS )a  
    Converts `Column` instances that represent struct field lookup into chained `Dots`.

    Struct field lookups look like columns (e.g. "struct"."field"), but they need to be
    qualified separately and represented as Dot(Dot(...(<table>.<column>, field1), field2, ...)).
    FTr   N)rm   rn   rs   starsr"   r   DotrY   sourcesrt   rW   r   r$   r   r   buildr_   r4   )rE   rH   	convertedr_   column_tablerootr   r'   r'   r(   r<     s2   


"r<   c                 C  s.  | j D ]k}|j}|j}|r*|| jv r*||}|s*|r*||vr*d|vr*td| |sn| jrC|tj	sC|
dt| jd j q||}|rQ|
d| q|jjdkrnt|jdkrn|| jv rn| |tj|jd q| jD ]"}|tjD ]}|js|j|jv r||j}|r|
d| qzqrdS )	z=Disambiguate columns, ensuring each column specifies a sourcer   zUnknown column: rY   r   r   r   r   N)rs   rY   r$   r  r~   r   rX   r   r   Pivotr[   r   r   r   r   r   r   r   r   r   TableColumnr%   rg   r#   all_columns)rE   rH   r   r_   r
  r   source_columnspivotr'   r'   r(   r=     sB   




r=   exp.Dott.List[exp.Alias]c                 C  s  t tj| tj}|tjjjsg S |	 }tj
|j|jd}| jdd }|dd D ]2}t tj|jjD ]"}t|jtjsIg     S |j|jkr\|jtjjjr\|} nq:g   S q/t }g }t tj|jjD ]O}|j}||v st|jtjsg   S || |j	 }	dd t||	gD ^}
}tjt tj|
|jdt t jtj |d}|t||	d	d
 qp|S )z@[BigQuery] Expand/Flatten foo.bar.* where bar is a struct column)r%   kindr   r   Nc                 S  s   g | ]}|  qS r'   r*   )rO   partr'   r'   r(   rS   O      z(_expand_struct_stars.<locals>.<listcomp>rY   )rY   rk   Fr*   )r   r   r   r#   r   is_typeDataTypeTypeSTRUCTr+   	ColumnDefr%   typer   r  rl   r"   
Identifierr$   r[   addrm   rn   r_   r1   r2   Listr   r   )r   
dot_columnstarting_struct	dot_partsr  re   taken_namesnew_selectionsr$   r%   r  r   
new_columnr'   r'   r(   _expand_struct_stars$  s@   


r%  rI   rD   
t.Set[str]rC   r
   c              
     s  g }i }i }i }t  }	|jj}
d}t  ttjtj t| j	dt
tjrrjsrjrOdd tD }jD ]}t
|tjrMdd |jD  q:n#t dd tjD dd jd	g D }|srd
d jD }|
dk}|rtdd | jD r||  | jjD ]@}g }t
|tjr|| j t||| t||| t ||| n3|j!rt
|tj"s|#|j$ t|j%|| t|j%|| t |j%|| n|rt&|}|r|| q|s|#| q|D ]}|| j'vrt(d| |j)|dd}|p| j*}rfdd|D }|rd|v r  dS t+|}||p+t   ||i }||i }rd|rPrPfdd|D }|| nj}|rd| fdd|D  q|D ]d v sr|	v rtqf|v r|| v r|	, | }fdd|D }|#t-tj.dg|R  dd qf|}|ptj/|d}|#|krt-||ddn| qfqq|rt
| jtj0r| j d| dS dS dS )z*Expand stars to lists of column selectionsNr   c                 S  r   r'   r   rN   r'   r'   r(   rS   q  r   z!_expand_stars.<locals>.<listcomp>c                 s  s(    | ]}| tjD ]}|jV  q
qd S rf   )rg   r   r#   r   rh   r'   r'   r(   rj   u  s    z _expand_stars.<locals>.<genexpr>c                 s  s    | ]}|j V  qd S rf   r'  rN   r'   r'   r(   rj   z  s    c                 S  r   r'   r'  rN   r'   r'   r(   rS   |  r   rs   c                 S  r   r'   r   rN   r'   r'   r(   rS   ~  r   r   c                 s  s    | ]	}t |tjV  qd S rf   )r"   r   r  rO   r   r'   r'   r(   rj     s    Unknown table: T)only_visiblec                   s   g | ]
}|   vr|qS r'   )upperrO   r$   )rD   r'   r(   rS     r   r   c                   rM   r'   r'   rN   )pivot_exclude_columnsr'   r(   rS     rT   c                 3  s2    | ]}| vrt tj|j d |ddV  qdS )r   Fr*   N)r   r   r_   r,  )columns_to_excluder  r'   r(   rj     s    c                   s   g | ]	}t j |d qS r   )r   r_   r   r$   r'   r(   rS     s    r   Fr   r   r*   rl   )1r[   r   r   r   r   Optionalr   r  r   rX   r"   alias_column_namesrZ   r\   rk   rd   updaterl   rg   r#   r1   r2   r   r  rB   r   r   Starr]   r   _add_except_columns_add_replace_columns_add_rename_columnsr   r  r   rY   r%   r%  r  r   r~   outer_columnsidr  r   r   r_   r0   )rE   rH   rI   rD   rC   r#  except_columnsr   rename_columnscoalesced_columnsr   pivot_output_columnsre   is_bigqueryr   r   struct_fieldsrY   rs   table_idrenamed_columnsreplaced_columnspivot_columnsr   alias_selection_exprr'   )r.  r$   r  r-  rD   r(   r>   Z  s   	







6r>   r9  t.Dict[int, t.Set[str]]c                 C  <   | j d}|s
d S dd |D }|D ]}||t|< qd S )Nexceptc                 S  r   r'   r/  rO   ri   r'   r'   r(   r     r   z&_add_except_columns.<locals>.<setcomp>r1   r2   r8  )r   r   r9  except_rs   rY   r'   r'   r(   r4       r4  r:  t.Dict[int, t.Dict[str, str]]c                 C  rF  )Nrenamec                 S  s   i | ]}|j j|jqS r'   )r%   r$   r   rH  r'   r'   r(   r     rT   z'_add_rename_columns.<locals>.<dictcomp>rI  )r   r   r:  rM  rs   rY   r'   r'   r(   r6    rK  r6  r   #t.Dict[int, t.Dict[str, exp.Alias]]c                 C  rF  )Nr   c                 S  s   i | ]}|j |qS r'   r   rH  r'   r'   r(   r     r  z(_add_replace_columns.<locals>.<dictcomp>rI  )r   r   r   r   rs   rY   r'   r'   r(   r5    rK  r5  scope_or_expressionScope | exp.Expressionc              	   C  s  t | tjrt| }t |tsdS n| }g }tt|jj	|j
D ]R\}\}}|du s1t |tjr3 nAt |tjrM|jsL|dtjtd| d nt |tjsc|jsct||jp_d| dd}|rn|dt| || q!|rt |jtjr|jd| dS dS dS )z%Ensure all output columns are aliasedNr   _col_r   Fr   rl   )r"   r   r   r   r   r   rm   zip_longestr   r   r7  QueryTransformSubqueryr   r[   
TableAliasr   r   r   r   r   r0   )rO  rE   r#  r   	selectionaliased_columnr'   r'   r(   r?      s8   
 r?   identifyc                 C  s   | j t|j|ddS )z=Makes sure all identifiers that need to be quoted are quoted.F)rX  r+   )r3   r   r.   quote_identifier)r   r   rX  r'   r'   r(   quote_identifiers"  s   rZ  c                 C  sx   |  tjD ]3}|jr9g }t|j|jjD ]\}}t|tjr&|	d| nt
||d}|| q|j	d| q| S )a|  
    Pushes down the CTE alias columns into the projection,

    This step is useful in Snowflake where the CTE alias columns can be referenced in the HAVING.

    Example:
        >>> import sqlglot
        >>> expression = sqlglot.parse_one("WITH y (c) AS (SELECT SUM(a) FROM ( SELECT 1 a ) AS x HAVING c > 0) SELECT c FROM y")
        >>> pushdown_cte_alias_columns(expression).sql()
        'WITH y(c) AS (SELECT SUM(a) AS c FROM (SELECT 1 AS a) AS x HAVING c > 0) SELECT c FROM y'

    Args:
        expression: Expression to pushdown.

    Returns:
        The expression with the CTE aliases pushed down into the projection.
    r   r   rl   )rg   r   CTEr1  r   r%   rl   r"   r   r[   r   r   )r   r   new_expressions_aliasr   r'   r'   r(   pushdown_cte_alias_columns)  s   r^  c                   @  sT   e Zd ZdZd"d#d	d
Zd$ddZed%ddZd&d'ddZd(ddZ	d)dd Z
d!S )*r5   z
    Helper for resolving columns.

    This is a class so we can lazily load some things and easily share them across functions.
    TrE   r   r   r   r   r   c                 C  s.   || _ || _d | _d | _d | _|| _i | _d S rf   )rE   r   _source_columns_unambiguous_columns_all_columns_infer_schema_get_source_columns_cache)selfrE   r   r   r'   r'   r(   __init__P  s   
zResolver.__init__r   r|   r   t.Optional[exp.Identifier]c                 C  s   | j du r| |  | _ | j |}|s/| jr/tdd |   D }t|dkr/|d }|| jj	vr:t
|S | jj	|\}}t|t
jrZ|rZ|j|krZ|j}|rZ|j|ksP|jd}|rht
|jS t
|S )z
        Get the table for a column name.

        Args:
            column_name: The column name to find the table for.
        Returns:
            The table name if it can be found/inferred.
        Nc                 s  s$    | ]\}}|rd |v r|V  qdS )r   Nr'   )rO   sourcers   r'   r'   r(   rj   j  s    z%Resolver.get_table.<locals>.<genexpr>r   r   r   )r`  _get_unambiguous_columns_get_all_source_columnsr2   rb  tupleitemsr   rE   r   r   r   r"   Queryr   rt   r1   r%   )rd  r   
table_namesources_without_schemar   _
node_aliasr'   r'   r(   r   Y  s,   
	



zResolver.get_tabler&  c                 C  s(   | j du rdd |   D | _ | j S )z2All available columns of all sources in this scopeNc                 S  s   h | ]	}|D ]}|qqS r'   r'   )rO   rs   r_   r'   r'   r(   r     s
    z'Resolver.all_columns.<locals>.<setcomp>)ra  ri  valuesrd  r'   r'   r(   r    s
   

zResolver.all_columnsFr$   r*  t.Sequence[str]c                 C  s:  ||f}|| j vr|| jjvrtd| | jj| }t|tjr+| j||}nt|t	r\t|j
tjtjfr\|j
j}| jjdkr[|j
tjjjr[|j
jjD ]}||j qRnt|t	rt|j
tjr|j
}|jd}|r{dd |D }nh|js|jr|j}	|j}
|jj}|jj}|	dkr|}nM|	dkrtt || }n?|
dkrtt |! t |! @ }n*|j}n&t"|j
j#d	}t|tj$r|jd
}|rdd |jD nddg}n|j
j}| jj%|pd\}}t|t	r|j
j&}nt|tj'r|j&}ng }|rdd t()||D }|| j |< | j | S )z5Resolve the source columns for a given source `name`.r)  r   r   c                 S  r   r'   r/  r(  r'   r'   r(   rS     r   z/Resolver.get_source_columns.<locals>.<listcomp>LEFTFULLINNERr   r   c                 S  r   r'   r/  rN   r'   r'   r(   rS     r   r   value)NNc                 S  s   g | ]\}}|p	|qS r'   r'   )rO   r$   r   r'   r'   r(   rS     s    )*rc  rE   r  r   r"   r   Tabler   column_namesr   r   Valuesr   named_selectsr   r  r  r  r  r  rl   r   r$   SetOperationr1   r2   sider  leftrightr   dictfromkeyskeysr   r   rS  r   r1  r   rm   rR  )rd  r$   r*  	cache_keyrg  rs   kset_opon_column_listr}  r  r~  r  r   r   r   ro  column_aliasesr'   r'   r(   r~     sf    




zResolver.get_source_columnst.Dict[str, t.Sequence[str]]c                   s<    j d u r fddt jj  jj D  _  j S )Nc                   s   i | ]
\}}|  |qS r'   r}   )rO   r{   rg  rr  r'   r(   r     s    
z4Resolver._get_all_source_columns.<locals>.<dictcomp>)r_  rm   rn   rE   r   rk  lateral_sourcesrr  r'   rr  r(   ri    s   

z Resolver._get_all_source_columnsr  t.Mapping[str, str]c                   s   |si S t | }|d \ }t|dkrt| S  fdd|D }t|}|dd D ])\}}t|}||}	|| |	D ]}
||
d qB||	D ]}
|||
< qPq.|S )z
        Find all the unambiguous columns in sources.

        Args:
            source_columns: Mapping of names to source columns.

        Returns:
            Mapping of column name to source name.
        r   r   c                   s   i | ]}| qS r'   r'   r(  first_tabler'   r(   r     r   z5Resolver._get_unambiguous_columns.<locals>.<dictcomp>N)	r   rk  r   r	   r[   intersectionr2  rw   
difference)rd  r  source_columns_pairsfirst_columnsunambiguous_columnsr  rY   rs   uniquer   r_   r'   r  r(   rh    s$   



z!Resolver._get_unambiguous_columnsN)T)rE   r   r   r   r   r   )r   r|   r   rf  )r   r&  F)r$   r|   r*  r   r   rs  )r   r  )r  r  r   r  )__name__
__module____qualname____doc__re  r   propertyr  r~   ri  rh  r'   r'   r'   r(   r5   I  s    
	(
O
)TTNFN)r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   )r   r   r   r   )rZ   rb   r   rc   )r8   rq   r   rr   )rE   r   rH   r5   r   rz   r  )
rE   r   rH   r5   r   r   r,   r   r   rr   )rE   r   r   r   r   rr   )rE   r   rH   r5   r   rr   )
rE   r   rl   r   r   r   r   r   r   r   )rE   r   r   r   r   r  )rE   r   rH   r5   r   r   r   rr   )r   r  r   r  )rE   r   rH   r5   rI   rz   rD   r&  rC   r
   r   rr   )r   r   r9  rE  r   rr   )r   r   r:  rL  r   rr   )r   r   r   rN  r   rr   )rO  rP  r   rr   )NT)r   r   r   r   rX  r   r   r   )r   r   r   r   )4
__future__r   rm   typingr   sqlglotr   r   sqlglot.dialects.dialectr   r   sqlglot.errorsr   sqlglot.helperr   r	    sqlglot.optimizer.annotate_typesr
   sqlglot.optimizer.scoper   r   r   r   sqlglot.optimizer.simplifyr   sqlglot.schemar   r   TYPE_CHECKINGsqlglot._typingr   rJ   ra   r\   r6   r9   r;   r@   rA   r   r   r<   r=   r%  r>   r4  r6  r5  r?   rZ  r^  r5   r'   r'   r'   r(   <module>   sR    
a


c
b

&
.

)
+
6
|


"
 