sqlglot 27.13.2__py3-none-any.whl → 27.15.0__py3-none-any.whl

sqlglot/dialects/snowflake.py

@@ -6,6 +6,7 @@ from sqlglot import exp, generator, jsonpath, parser, tokens, transforms
 from sqlglot.dialects.dialect import (
     Dialect,
     NormalizationStrategy,
+    annotate_with_type_lambda,
     build_timetostr_or_tochar,
     binary_from_function,
     build_default_decimal_type,
@@ -32,6 +33,7 @@ from sqlglot.dialects.dialect import (
 )
 from sqlglot.generator import unsupported_args
 from sqlglot.helper import find_new_name, flatten, is_float, is_int, seq_get
+from sqlglot.optimizer.annotate_types import TypeAnnotator
 from sqlglot.optimizer.scope import build_scope, find_all_in_scope
 from sqlglot.tokens import TokenType
 
@@ -376,6 +378,7 @@ def _qualify_unnested_columns(expression: exp.Expression) -> exp.Expression:
 
         taken_source_names = set(scope.sources)
         column_source: t.Dict[str, exp.Identifier] = {}
+        unnest_to_identifier: t.Dict[exp.Unnest, exp.Identifier] = {}
 
         unnest_identifier: t.Optional[exp.Identifier] = None
         orig_expression = expression.copy()
@@ -428,6 +431,7 @@ def _qualify_unnested_columns(expression: exp.Expression) -> exp.Expression:
             if not isinstance(unnest_identifier, exp.Identifier):
                 return orig_expression
 
+            unnest_to_identifier[unnest] = unnest_identifier
             column_source.update({c.lower(): unnest_identifier for c in unnest_columns})
 
         for column in scope.columns:
@@ -441,6 +445,15 @@ def _qualify_unnested_columns(expression: exp.Expression) -> exp.Expression:
                 and len(scope.sources) == 1
                 and column.name.lower() != unnest_identifier.name.lower()
             ):
+                unnest_ancestor = column.find_ancestor(exp.Unnest, exp.Select)
+                ancestor_identifier = unnest_to_identifier.get(unnest_ancestor)
+                if (
+                    isinstance(unnest_ancestor, exp.Unnest)
+                    and ancestor_identifier
+                    and ancestor_identifier.name.lower() == unnest_identifier.name.lower()
+                ):
+                    continue
+
                 table = unnest_identifier
 
             column.set("table", table and table.copy())
@@ -482,6 +495,15 @@ def _eliminate_dot_variant_lookup(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
+def _annotate_reverse(self: TypeAnnotator, expression: exp.Reverse) -> exp.Reverse:
+    expression = self._annotate_by_args(expression, "this")
+    if expression.is_type(exp.DataType.Type.NULL):
+        # Snowflake treats REVERSE(NULL) as a VARCHAR
+        self._set_type(expression, exp.DataType.Type.VARCHAR)
+
+    return expression
+
+
 class Snowflake(Dialect):
     # https://docs.snowflake.com/en/sql-reference/identifiers-syntax
     NORMALIZATION_STRATEGY = NormalizationStrategy.UPPERCASE
@@ -496,13 +518,59 @@ class Snowflake(Dialect):
     ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN = False
     TRY_CAST_REQUIRES_STRING = True
 
+    TYPE_TO_EXPRESSIONS = {
+        **Dialect.TYPE_TO_EXPRESSIONS,
+        exp.DataType.Type.INT: {
+            *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.INT],
+            exp.Length,
+        },
+        exp.DataType.Type.VARCHAR: {
+            *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.VARCHAR],
+            exp.MD5,
+            exp.AIAgg,
+            exp.AISummarizeAgg,
+            exp.RegexpExtract,
+            exp.RegexpReplace,
+            exp.Repeat,
+            exp.Replace,
+            exp.SHA,
+            exp.SHA2,
+            exp.Space,
+            exp.Uuid,
+        },
+        exp.DataType.Type.BINARY: {
+            *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.BINARY],
+            exp.MD5Digest,
+            exp.SHA1Digest,
+            exp.SHA2Digest,
+        },
+        exp.DataType.Type.BIGINT: {
+            *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.BIGINT],
+            exp.MD5NumberLower64,
+            exp.MD5NumberUpper64,
+        },
+        exp.DataType.Type.ARRAY: {
+            exp.Split,
+        },
+    }
+
     ANNOTATORS = {
         **Dialect.ANNOTATORS,
+        **{
+            expr_type: annotate_with_type_lambda(data_type)
+            for data_type, expressions in TYPE_TO_EXPRESSIONS.items()
+            for expr_type in expressions
+        },
         **{
             expr_type: lambda self, e: self._annotate_by_args(e, "this")
-            for expr_type in (exp.Reverse,)
+            for expr_type in (
+                exp.Left,
+                exp.Right,
+                exp.Substring,
+            )
         },
         exp.ConcatWs: lambda self, e: self._annotate_by_args(e, "expressions"),
+        exp.Reverse: _annotate_reverse,
     }
 
     TIME_MAPPING = {
@@ -622,6 +690,10 @@ class Snowflake(Dialect):
             ),
             "HEX_DECODE_BINARY": exp.Unhex.from_arg_list,
             "IFF": exp.If.from_arg_list,
+            "MD5_HEX": exp.MD5.from_arg_list,
+            "MD5_BINARY": exp.MD5Digest.from_arg_list,
+            "MD5_NUMBER_LOWER64": exp.MD5NumberLower64.from_arg_list,
+            "MD5_NUMBER_UPPER64": exp.MD5NumberUpper64.from_arg_list,
             "LAST_DAY": lambda args: exp.LastDay(
                 this=seq_get(args, 0), unit=map_date_part(seq_get(args, 1))
             ),
@@ -629,12 +701,17 @@ class Snowflake(Dialect):
             "LENGTH": lambda args: exp.Length(this=seq_get(args, 0), binary=True),
             "NULLIFZERO": _build_if_from_nullifzero,
             "OBJECT_CONSTRUCT": _build_object_construct,
+            "OCTET_LENGTH": exp.ByteLength.from_arg_list,
             "REGEXP_EXTRACT_ALL": _build_regexp_extract(exp.RegexpExtractAll),
             "REGEXP_REPLACE": _build_regexp_replace,
             "REGEXP_SUBSTR": _build_regexp_extract(exp.RegexpExtract),
             "REGEXP_SUBSTR_ALL": _build_regexp_extract(exp.RegexpExtractAll),
             "REPLACE": build_replace_with_optional_replacement,
             "RLIKE": exp.RegexpLike.from_arg_list,
+            "SHA1_BINARY": exp.SHA1Digest.from_arg_list,
+            "SHA1_HEX": exp.SHA.from_arg_list,
+            "SHA2_BINARY": exp.SHA2Digest.from_arg_list,
+            "SHA2_HEX": exp.SHA2.from_arg_list,
             "SQUARE": lambda args: exp.Pow(this=seq_get(args, 0), expression=exp.Literal.number(2)),
             "TABLE": lambda args: exp.TableFromRows(this=seq_get(args, 0)),
             "TIMEADD": _build_date_time_add(exp.TimeAdd),
@@ -664,7 +741,8 @@ class Snowflake(Dialect):
             "TO_TIMESTAMP_LTZ": _build_datetime("TO_TIMESTAMP_LTZ", exp.DataType.Type.TIMESTAMPLTZ),
             "TO_TIMESTAMP_NTZ": _build_datetime("TO_TIMESTAMP_NTZ", exp.DataType.Type.TIMESTAMP),
             "TO_TIMESTAMP_TZ": _build_datetime("TO_TIMESTAMP_TZ", exp.DataType.Type.TIMESTAMPTZ),
-            "TO_VARCHAR": exp.ToChar.from_arg_list,
+            "TO_VARCHAR": build_timetostr_or_tochar,
+            "TO_JSON": exp.JSONFormat.from_arg_list,
             "VECTOR_L2_DISTANCE": exp.EuclideanDistance.from_arg_list,
             "ZEROIFNULL": _build_if_from_zeroifnull,
         }
@@ -1273,6 +1351,7 @@ class Snowflake(Dialect):
             exp.ParseJSON: lambda self, e: self.func(
                 "TRY_PARSE_JSON" if e.args.get("safe") else "PARSE_JSON", e.this
             ),
+            exp.JSONFormat: rename_func("TO_JSON"),
             exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
             exp.PercentileCont: transforms.preprocess(
                 [transforms.add_within_group_for_percentiles]
@@ -1297,6 +1376,10 @@ class Snowflake(Dialect):
                 ]
             ),
             exp.SHA: rename_func("SHA1"),
+            exp.MD5Digest: rename_func("MD5_BINARY"),
+            exp.MD5NumberLower64: rename_func("MD5_NUMBER_LOWER64"),
+            exp.MD5NumberUpper64: rename_func("MD5_NUMBER_UPPER64"),
+            exp.LowerHex: rename_func("TO_CHAR"),
             exp.SortArray: rename_func("ARRAY_SORT"),
             exp.StarMap: rename_func("OBJECT_CONSTRUCT"),
             exp.StartsWith: rename_func("STARTSWITH"),
@@ -1334,6 +1417,7 @@ class Snowflake(Dialect):
             exp.VarMap: lambda self, e: var_map_sql(self, e, "OBJECT_CONSTRUCT"),
             exp.WeekOfYear: rename_func("WEEKOFYEAR"),
             exp.Xor: rename_func("BOOLXOR"),
+            exp.ByteLength: rename_func("OCTET_LENGTH"),
         }
 
         SUPPORTED_JSON_PATH_PARTS = {
@@ -1344,9 +1428,10 @@ class Snowflake(Dialect):
 
         TYPE_MAPPING = {
             **generator.Generator.TYPE_MAPPING,
+            exp.DataType.Type.BIGDECIMAL: "DOUBLE",
             exp.DataType.Type.NESTED: "OBJECT",
             exp.DataType.Type.STRUCT: "OBJECT",
-            exp.DataType.Type.BIGDECIMAL: "DOUBLE",
+            exp.DataType.Type.TEXT: "VARCHAR",
         }
 
         TOKEN_MAPPING = {

sqlglot/dialects/sqlite.py

@@ -110,6 +110,7 @@ class SQLite(Dialect):
         STRING_ALIASES = True
         ALTER_RENAME_REQUIRES_COLUMN = False
         JOINS_HAVE_EQUAL_PRECEDENCE = True
+        ADD_JOIN_ON_TRUE = True
 
         FUNCTIONS = {
             **parser.Parser.FUNCTIONS,

sqlglot/dialects/tsql.py

@@ -650,6 +650,16 @@ class TSQL(Dialect):
             "NEXT": lambda self: self._parse_next_value_for(),
         }
 
+        FUNCTION_PARSERS: t.Dict[str, t.Callable] = {
+            **parser.Parser.FUNCTION_PARSERS,
+            "JSON_ARRAYAGG": lambda self: self.expression(
+                exp.JSONArrayAgg,
+                this=self._parse_bitwise(),
+                order=self._parse_order(),
+                null_handling=self._parse_on_handling("NULL", "NULL", "ABSENT"),
+            ),
+        }
+
         # The DCOLON (::) operator serves as a scope resolution (exp.ScopeResolution) operator in T-SQL
         COLUMN_OPERATORS = {
             **parser.Parser.COLUMN_OPERATORS,

sqlglot/expressions.py

@@ -134,6 +134,11 @@ class Expression(metaclass=_Expression):
 
         return hash((self.__class__, self.hashable_args))
 
+    def __reduce__(self) -> t.Tuple[t.Callable, t.Tuple[t.List[t.Dict[str, t.Any]]]]:
+        from sqlglot.serde import dump, load
+
+        return (load, (dump(self),))
+
     @property
     def this(self) -> t.Any:
         """
@@ -259,7 +264,7 @@ class Expression(metaclass=_Expression):
         return self.type is not None and self.type.is_type(*dtypes)
 
     def is_leaf(self) -> bool:
-        return not any(isinstance(v, (Expression, list)) for v in self.args.values())
+        return not any(isinstance(v, (Expression, list)) and v for v in self.args.values())
 
     @property
     def meta(self) -> t.Dict[str, t.Any]:
@@ -1646,6 +1651,12 @@ class Show(Expression):
         "position": False,
         "types": False,
         "privileges": False,
+        "for_table": False,
+        "for_group": False,
+        "for_user": False,
+        "for_role": False,
+        "into_outfile": False,
+        "json": False,
     }
 
 
@@ -2054,7 +2065,7 @@ class ProjectionPolicyColumnConstraint(ColumnConstraintKind):
 # computed column expression
 # https://learn.microsoft.com/en-us/sql/t-sql/statements/create-table-transact-sql?view=sql-server-ver16
 class ComputedColumnConstraint(ColumnConstraintKind):
-    arg_types = {"this": True, "persisted": False, "not_null": False}
+    arg_types = {"this": True, "persisted": False, "not_null": False, "data_type": False}
 
 
 class Constraint(Expression):
@@ -2197,7 +2208,7 @@ class Copy(DML):
     arg_types = {
         "this": True,
         "kind": True,
-        "files": True,
+        "files": False,
         "credentials": False,
         "format": False,
         "params": False,
@@ -5755,6 +5766,15 @@ class ArrayUniqueAgg(AggFunc):
     pass
 
 
+class AIAgg(AggFunc):
+    arg_types = {"this": True, "expression": True}
+    _sql_names = ["AI_AGG"]
+
+
+class AISummarizeAgg(AggFunc):
+    _sql_names = ["AI_SUMMARIZE_AGG"]
+
+
 class ArrayAll(Func):
     arg_types = {"this": True, "expression": True}
 
@@ -6694,11 +6714,26 @@ class JSONBContains(Binary, Func):
     _sql_names = ["JSONB_CONTAINS"]
 
 
+# https://www.postgresql.org/docs/9.5/functions-json.html
+class JSONBContainsAnyTopKeys(Binary, Func):
+    pass
+
+
+# https://www.postgresql.org/docs/9.5/functions-json.html
+class JSONBContainsAllTopKeys(Binary, Func):
+    pass
+
+
 class JSONBExists(Func):
     arg_types = {"this": True, "path": True}
     _sql_names = ["JSONB_EXISTS"]
 
 
+# https://www.postgresql.org/docs/9.5/functions-json.html
+class JSONBDeleteAtPath(Binary, Func):
+    pass
+
+
 class JSONExtract(Binary, Func):
     arg_types = {
         "this": True,
@@ -6925,6 +6960,16 @@ class MD5Digest(Func):
     _sql_names = ["MD5_DIGEST"]
 
 
+# https://docs.snowflake.com/en/sql-reference/functions/md5_number_lower64
+class MD5NumberLower64(Func):
+    pass
+
+
+# https://docs.snowflake.com/en/sql-reference/functions/md5_number_upper64
+class MD5NumberUpper64(Func):
+    pass
+
+
 class Median(AggFunc):
     pass
 
@@ -6963,6 +7008,11 @@ class Predict(Func):
     arg_types = {"this": True, "expression": True, "params_struct": False}
 
 
+# https://cloud.google.com/bigquery/docs/reference/standard-sql/bigqueryml-syntax-translate#mltranslate_function
+class MLTranslate(Func):
+    arg_types = {"this": True, "expression": True, "params_struct": True}
+
+
 # https://cloud.google.com/bigquery/docs/reference/standard-sql/bigqueryml-syntax-feature-time
 class FeaturesAtTime(Func):
     arg_types = {"this": True, "time": False, "num_rows": False, "ignore_feature_nulls": False}
@@ -6970,7 +7020,11 @@ class FeaturesAtTime(Func):
 
 # https://cloud.google.com/bigquery/docs/reference/standard-sql/bigqueryml-syntax-generate-embedding
 class GenerateEmbedding(Func):
-    arg_types = {"this": True, "expression": True, "params_struct": False}
+    arg_types = {"this": True, "expression": True, "params_struct": False, "is_text": False}
+
+
+class MLForecast(Func):
+    arg_types = {"this": True, "expression": False, "params_struct": False}
 
 
 # https://cloud.google.com/bigquery/docs/reference/standard-sql/search_functions#vector_search
@@ -7166,6 +7220,16 @@ class SHA2(Func):
     arg_types = {"this": True, "length": False}
 
 
+# Represents the variant of the SHA1 function that returns a binary value
+class SHA1Digest(Func):
+    pass
+
+
+# Represents the variant of the SHA2 function that returns a binary value
+class SHA2Digest(Func):
+    arg_types = {"this": True, "length": False}
+
+
 class Sign(Func):
     _sql_names = ["SIGN", "SIGNUM"]
 

sqlglot/generator.py

@@ -160,6 +160,9 @@ class Generator(metaclass=_Generator):
         exp.Intersect: lambda self, e: self.set_operations(e),
         exp.IntervalSpan: lambda self, e: f"{self.sql(e, 'this')} TO {self.sql(e, 'expression')}",
         exp.Int64: lambda self, e: self.sql(exp.cast(e.this, exp.DataType.Type.BIGINT)),
+        exp.JSONBContainsAnyTopKeys: lambda self, e: self.binary(e, "?|"),
+        exp.JSONBContainsAllTopKeys: lambda self, e: self.binary(e, "?&"),
+        exp.JSONBDeleteAtPath: lambda self, e: self.binary(e, "#-"),
         exp.LanguageProperty: lambda self, e: self.naked_property(e),
         exp.LocationProperty: lambda self, e: self.naked_property(e),
         exp.LogProperty: lambda _, e: f"{'NO ' if e.args.get('no') else ''}LOG",
@@ -4214,21 +4217,32 @@ class Generator(metaclass=_Generator):
     def opclass_sql(self, expression: exp.Opclass) -> str:
         return f"{self.sql(expression, 'this')} {self.sql(expression, 'expression')}"
 
-    def predict_sql(self, expression: exp.Predict) -> str:
+    def _ml_sql(self, expression: exp.Func, name: str) -> str:
         model = self.sql(expression, "this")
         model = f"MODEL {model}"
-        table = self.sql(expression, "expression")
-        table = f"TABLE {table}" if not isinstance(expression.expression, exp.Subquery) else table
-        parameters = self.sql(expression, "params_struct")
-        return self.func("PREDICT", model, table, parameters or None)
+        expr = expression.expression
+        if expr:
+            expr_sql = self.sql(expression, "expression")
+            expr_sql = f"TABLE {expr_sql}" if not isinstance(expr, exp.Subquery) else expr_sql
+        else:
+            expr_sql = None
+
+        parameters = self.sql(expression, "params_struct") or None
+
+        return self.func(name, model, expr_sql, parameters)
+
+    def predict_sql(self, expression: exp.Predict) -> str:
+        return self._ml_sql(expression, "PREDICT")
 
     def generateembedding_sql(self, expression: exp.GenerateEmbedding) -> str:
-        model = self.sql(expression, "this")
-        model = f"MODEL {model}"
-        table = self.sql(expression, "expression")
-        table = f"TABLE {table}" if not isinstance(expression.expression, exp.Subquery) else table
-        parameters = self.sql(expression, "params_struct")
-        return self.func("GENERATE_EMBEDDING", model, table, parameters or None)
+        name = "GENERATE_TEXT_EMBEDDING" if expression.args.get("is_text") else "GENERATE_EMBEDDING"
+        return self._ml_sql(expression, name)
+
+    def mltranslate_sql(self, expression: exp.MLTranslate) -> str:
+        return self._ml_sql(expression, "TRANSLATE")
+
+    def mlforecast_sql(self, expression: exp.MLForecast) -> str:
+        return self._ml_sql(expression, "FORECAST")
 
     def featuresattime_sql(self, expression: exp.FeaturesAtTime) -> str:
         this_sql = self.sql(expression, "this")
@@ -4579,8 +4593,8 @@ class Generator(metaclass=_Generator):
 
         credentials = self.sql(expression, "credentials")
         credentials = self.seg(credentials) if credentials else ""
-        kind = self.seg("FROM" if expression.args.get("kind") else "TO")
         files = self.expressions(expression, key="files", flat=True)
+        kind = self.seg("FROM" if expression.args.get("kind") else "TO") if files else ""
 
         sep = ", " if self.dialect.COPY_PARAMS_ARE_CSV else " "
         params = self.expressions(
@@ -4596,7 +4610,7 @@ class Generator(metaclass=_Generator):
         if params:
             if self.COPY_PARAMS_ARE_WRAPPED:
                 params = f" WITH ({params})"
-            elif not self.pretty:
+            elif not self.pretty and (files or credentials):
                 params = f" {params}"
 
         return f"COPY{this}{kind} {files}{credentials}{params}"

sqlglot/optimizer/annotate_types.py

@@ -193,6 +193,12 @@ class TypeAnnotator(metaclass=_TypeAnnotator):
         # Caches the ids of annotated sub-Expressions, to ensure we only visit them once
         self._visited: t.Set[int] = set()
 
+        # Caches NULL-annotated expressions to set them to UNKNOWN after type inference is completed
+        self._null_expressions: t.Dict[int, exp.Expression] = {}
+
+        # Databricks and Spark ≥v3 actually support NULL (i.e., VOID) as a type
+        self._supports_null_type = schema.dialect in ("databricks", "spark")
+
         # Maps an exp.SetOperation's id (e.g. UNION) to its projection types. This is computed if the
         # exp.SetOperation is the expression of a scope source, as selecting from it multiple times
         # would reprocess the entire subtree to coerce the types of its operands' projections
@@ -201,13 +207,33 @@ class TypeAnnotator(metaclass=_TypeAnnotator):
     def _set_type(
         self, expression: exp.Expression, target_type: t.Optional[exp.DataType | exp.DataType.Type]
     ) -> None:
+        prev_type = expression.type
+        expression_id = id(expression)
+
         expression.type = target_type or exp.DataType.Type.UNKNOWN  # type: ignore
-        self._visited.add(id(expression))
+        self._visited.add(expression_id)
+
+        if (
+            not self._supports_null_type
+            and t.cast(exp.DataType, expression.type).this == exp.DataType.Type.NULL
+        ):
+            self._null_expressions[expression_id] = expression
+        elif prev_type and t.cast(exp.DataType, prev_type).this == exp.DataType.Type.NULL:
+            self._null_expressions.pop(expression_id, None)
 
     def annotate(self, expression: E) -> E:
         for scope in traverse_scope(expression):
             self.annotate_scope(scope)
-        return self._maybe_annotate(expression)  # This takes care of non-traversable expressions
+
+        # This takes care of non-traversable expressions
+        expression = self._maybe_annotate(expression)
+
+        # Replace NULL type with UNKNOWN, since the former is not an actual type;
+        # it is mostly used to aid type coercion, e.g. in query set operations.
+        for expr in self._null_expressions.values():
+            expr.type = exp.DataType.Type.UNKNOWN
+
+        return expression
 
     def annotate_scope(self, scope: Scope) -> None:
         selects = {}
@@ -567,14 +593,18 @@ class TypeAnnotator(metaclass=_TypeAnnotator):
     def _annotate_struct_value(
         self, expression: exp.Expression
     ) -> t.Optional[exp.DataType] | exp.ColumnDef:
-        alias = expression.args.get("alias")
-        if alias:
+        # Case: STRUCT(key AS value)
+        if alias := expression.args.get("alias"):
             return exp.ColumnDef(this=alias.copy(), kind=expression.type)
 
-        # Case: key = value or key := value
+        # Case: STRUCT(key = value) or STRUCT(key := value)
         if expression.expression:
             return exp.ColumnDef(this=expression.this.copy(), kind=expression.expression.type)
 
+        # Case: STRUCT(c)
+        if isinstance(expression, exp.Column):
+            return exp.ColumnDef(this=expression.this.copy(), kind=expression.type)
+
         return expression.type
 
     def _annotate_struct(self, expression: exp.Struct) -> exp.Struct:

sqlglot/optimizer/qualify_columns.py

@@ -351,11 +351,15 @@ def _expand_alias_refs(
             alias_to_expression[projection.alias] = (projection.this, i + 1)
 
     parent_scope = scope
-    while parent_scope.is_union:
+    on_right_sub_tree = False
+    while parent_scope and not parent_scope.is_cte:
+        if parent_scope.is_union:
+            on_right_sub_tree = parent_scope.parent.expression.right is parent_scope.expression
         parent_scope = parent_scope.parent
 
     # We shouldn't expand aliases if they match the recursive CTE's columns
-    if parent_scope.is_cte:
+    # and we are in the recursive part (right sub tree) of the CTE
+    if parent_scope and on_right_sub_tree:
         cte = parent_scope.expression.parent
         if cte.find_ancestor(exp.With).recursive:
             for recursive_cte_column in cte.args["alias"].columns or cte.this.selects: