sqlglotc 30.11.0__tar.gz → 30.12.0__tar.gz

{sqlglotc-30.11.0/sqlglotc.egg-info → sqlglotc-30.12.0}/PKG-INFO

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: sqlglotc
-Version: 30.11.0
+Version: 30.12.0
 Summary: mypyc-compiled extensions for sqlglot
 Author-email: Toby Mao <toby.mao@gmail.com>
 License-Expression: MIT
 Project-URL: Homepage, https://sqlglot.com/
 Project-URL: Repository, https://github.com/tobymao/sqlglot
 Requires-Python: >=3.10
-Requires-Dist: sqlglot==30.11.0
+Requires-Dist: sqlglot==30.12.0
 Provides-Extra: dev
 Requires-Dist: setuptools>=61.0; extra == "dev"
 Requires-Dist: setuptools_scm; extra == "dev"
-Requires-Dist: sqlglot-mypy>=2.1.0.post2; extra == "dev"
+Requires-Dist: sqlglot-mypy>=2.1.0.post3; extra == "dev"
 Dynamic: requires-dist

{sqlglotc-30.11.0 → sqlglotc-30.12.0}/pyproject.toml

@@ -7,7 +7,7 @@ license = "MIT"
 requires-python = ">= 3.10"
 
 [project.optional-dependencies]
-dev = ["setuptools >= 61.0", "setuptools_scm", "sqlglot-mypy >= 2.1.0.post2"]
+dev = ["setuptools >= 61.0", "setuptools_scm", "sqlglot-mypy >= 2.1.0.post3"]
 
 [project.urls]
 Homepage = "https://sqlglot.com/"
@@ -17,7 +17,7 @@ Repository = "https://github.com/tobymao/sqlglot"
 requires = [
     "setuptools >= 61.0",
     "setuptools_scm",
-    "sqlglot-mypy >= 2.1.0.post2",
+    "sqlglot-mypy >= 2.1.0.post3",
     "types-python-dateutil",
     "sqlglot",
 ]

{sqlglotc-30.11.0 → sqlglotc-30.12.0}/sqlglot/expressions/array.py

@@ -114,6 +114,10 @@ class ArrayContainsAll(Expression, Binary, Func):
     _sql_names = ["ARRAY_CONTAINS_ALL", "ARRAY_HAS_ALL"]
 
 
+class ArrayContainedBy(Expression, Binary, Func):
+    pass
+
+
 class ArrayExcept(Expression, Func):
     arg_types = {"this": True, "expression": True, "is_multiset": False}
 

{sqlglotc-30.11.0 → sqlglotc-30.12.0}/sqlglot/expressions/core.py

@@ -10,12 +10,14 @@ import re
 import sys
 import textwrap
 import typing as t
+from builtins import type as Type
 from collections import deque
+from collections.abc import Collection, Iterator, Mapping, MutableMapping, Sequence
 from copy import deepcopy
 from decimal import Decimal
 from functools import reduce
-from collections.abc import Iterator, Sequence, Collection, Mapping, MutableMapping
-from sqlglot._typing import E, T
+
+from sqlglot._typing import E, GeneratorNoDialectArgs, ParserNoDialectArgs, T
 from sqlglot.errors import ParseError
 from sqlglot.helper import (
     camel_to_snake_case,
@@ -24,17 +26,15 @@ from sqlglot.helper import (
     to_bool,
     trait,
 )
-
 from sqlglot.tokenizer_core import Token
-from builtins import type as Type
-from sqlglot._typing import GeneratorNoDialectArgs, ParserNoDialectArgs
 
 if t.TYPE_CHECKING:
-    from typing_extensions import Self, Unpack, Concatenate
+    from typing_extensions import Concatenate, Self, Unpack
+
+    from sqlglot._typing import P
     from sqlglot.dialects.dialect import DialectType
     from sqlglot.expressions.datatypes import DATA_TYPE, DataType, DType, Interval
     from sqlglot.expressions.query import Select
-    from sqlglot._typing import P
 
     R = t.TypeVar("R")
 
@@ -1789,7 +1789,12 @@ class JoinHint(Expression):
 
 
 class Identifier(Expression):
-    arg_types = {"this": True, "quoted": False, "global_": False, "temporary": False}
+    arg_types = {
+        "this": True,
+        "quoted": False,
+        "global_": False,
+        "temporary": False,
+    }
     is_primitive = True
     _hash_raw_args = True
 
@@ -1802,12 +1807,19 @@ class Identifier(Expression):
         return self.name
 
 
+# https://docs.snowflake.com/en/sql-reference/identifier-literal
+# "expressions" holds the arguments when the resolved identifier is invoked as a
+# function, e.g. `IDENTIFIER('my_func')(1, 2)`
+class DynamicIdentifier(Expression, Func):
+    arg_types = {"this": True, "expressions": False}
+
+
 class Opclass(Expression):
     arg_types = {"this": True, "expression": True}
 
 
 class Star(Expression):
-    arg_types = {"except_": False, "replace": False, "rename": False}
+    arg_types = {"except_": False, "replace": False, "rename": False, "ilike": False}
 
     @property
     def name(self) -> str:
@@ -2415,7 +2427,8 @@ def convert(value: t.Any, copy: bool = False) -> Expr:
 
         return _Array(expressions=[convert(v, copy=copy) for v in value])
     if isinstance(value, dict):
-        from sqlglot.expressions.array import Array as _Array, Map as _Map
+        from sqlglot.expressions.array import Array as _Array
+        from sqlglot.expressions.array import Map as _Map
 
         return _Map(
             keys=_Array(expressions=[convert(k, copy=copy) for k in value]),

{sqlglotc-30.11.0 → sqlglotc-30.12.0}/sqlglot/expressions/ddl.py

@@ -370,6 +370,14 @@ class DropPrimaryKey(Expression):
     arg_types = {}
 
 
+class Undrop(Expression):
+    arg_types = {"this": True, "kind": True, "rename": False}
+
+    @property
+    def kind(self) -> str:
+        return self.args["kind"].upper()
+
+
 class Command(Expression):
     arg_types = {"this": True, "expression": False}
 

{sqlglotc-30.11.0 → sqlglotc-30.12.0}/sqlglot/expressions/json.py

@@ -62,6 +62,10 @@ class JSONBDeleteAtPath(Expression, Binary, Func):
     pass
 
 
+class JSONBPathExists(Expression, Binary, Predicate, Func):
+    pass
+
+
 class JSONBExists(Expression, Func):
     arg_types = {"this": True, "path": True}
     _sql_names = ["JSONB_EXISTS"]

{sqlglotc-30.11.0 → sqlglotc-30.12.0}/sqlglot/expressions/properties.py

@@ -5,8 +5,8 @@ from __future__ import annotations
 import typing as t
 from enum import auto
 
+from sqlglot.expressions.core import ColumnConstraintKind, Expression, Literal, convert
 from sqlglot.helper import AutoName
-from sqlglot.expressions.core import Expression, ColumnConstraintKind, Literal, convert
 
 
 class Property(Expression):
@@ -63,6 +63,10 @@ class BlockCompressionProperty(Property):
     }
 
 
+class CalledOnNullInputProperty(Property):
+    arg_types = {}
+
+
 class CatalogProperty(Property):
     arg_types = {}
 

{sqlglotc-30.11.0 → sqlglotc-30.12.0}/sqlglot/expressions/query.py

@@ -1967,7 +1967,7 @@ class JSON(Expression):
 
 
 class JSONPath(Expression):
-    arg_types = {"expressions": True, "escape": False}
+    arg_types = {"expressions": True}
 
     @property
     def output_name(self) -> str:
@@ -1984,7 +1984,7 @@ class JSONPathFilter(JSONPathPart):
 
 
 class JSONPathKey(JSONPathPart):
-    arg_types = {"this": True}
+    arg_types = {"this": True, "quoted": False}
 
 
 class JSONPathRecursive(JSONPathPart):

{sqlglotc-30.11.0 → sqlglotc-30.12.0}/sqlglot/expressions/temporal.py

@@ -437,8 +437,12 @@ class FromISO8601Timestamp(Expression, Func):
     _sql_names = ["FROM_ISO8601_TIMESTAMP"]
 
 
+class FromISO8601Date(Expression, Func):
+    _sql_names = ["FROM_ISO8601_DATE"]
+
+
 class ParseDatetime(Expression, Func):
-    arg_types = {"this": True, "format": False, "zone": False}
+    arg_types = {"this": True, "format": False, "zone": False, "default_year": False}
 
 
 class ParseTime(Expression, Func):

{sqlglotc-30.11.0 → sqlglotc-30.12.0}/sqlglot/generator.py

@@ -9,6 +9,7 @@ from functools import reduce, wraps
 from sqlglot import exp
 from sqlglot.errors import ErrorLevel, UnsupportedError, concat_messages
 from sqlglot.expressions import apply_index_offset
+from sqlglot.expressions.core import maybe_parse
 from sqlglot.helper import csv, name_sequence, seq_get
 from sqlglot.jsonpath import ALL_JSON_PATH_PARTS, JSON_PATH_PART_TRANSFORMS
 from sqlglot.time import format_time
@@ -139,6 +140,7 @@ class Generator:
         ),
         exp.AnalyzeColumns: lambda self, e: self.sql(e, "this"),
         exp.AnalyzeWith: lambda self, e: self.expressions(e, prefix="WITH ", sep=" "),
+        exp.ArrayContainedBy: lambda self, e: self.binary(e, "<@"),
         exp.ArrayContainsAll: lambda self, e: self.binary(e, "@>"),
         exp.ArrayOverlaps: lambda self, e: self.binary(e, "&&"),
         exp.AssumeColumnConstraint: lambda self, e: f"ASSUME ({self.sql(e, 'this')})",
@@ -147,6 +149,7 @@ class Generator:
         exp.CaseSpecificColumnConstraint: lambda _, e: (
             f"{'NOT ' if e.args.get('not_') else ''}CASESPECIFIC"
         ),
+        exp.CalledOnNullInputProperty: lambda *_: "CALLED ON NULL INPUT",
         exp.Ceil: lambda self, e: self.ceil_floor(e),
         exp.CharacterSetColumnConstraint: lambda self, e: f"CHARACTER SET {self.sql(e, 'this')}",
         exp.CharacterSetProperty: lambda self, e: (
@@ -203,6 +206,7 @@ class Generator:
         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.JSONBPathExists: lambda self, e: self.binary(e, "@?"),
         exp.JSONObject: lambda self, e: self._jsonobject_sql(e),
         exp.JSONObjectAgg: lambda self, e: self._jsonobject_sql(e),
         exp.LanguageProperty: lambda self, e: self.naked_property(e),
@@ -489,6 +493,12 @@ class Generator:
     # Whether to escape keys using single quotes in JSON paths
     JSON_PATH_SINGLE_QUOTE_ESCAPE = False
 
+    # Whether a quoted JSON path key (e.g. from a quoted identifier or ['key'] bracket) must be
+    # rendered in bracket form to preserve its case-sensitivity, even if it would otherwise match
+    # SAFE_JSON_PATH_KEY_RE and render as a bare dotted key. Needed for dialects like Databricks
+    # where a bare colon key is case-insensitive but a bracketed key is case-sensitive.
+    JSON_PATH_KEY_QUOTED_FORCES_BRACKETS = False
+
     # The JSONPathPart expressions supported by this dialect
     SUPPORTED_JSON_PATH_PARTS: t.ClassVar = ALL_JSON_PATH_PARTS.copy()
 
@@ -668,6 +678,7 @@ class Generator:
         exp.AutoRefreshProperty: exp.Properties.Location.POST_SCHEMA,
         exp.BackupProperty: exp.Properties.Location.POST_SCHEMA,
         exp.BlockCompressionProperty: exp.Properties.Location.POST_NAME,
+        exp.CalledOnNullInputProperty: exp.Properties.Location.POST_SCHEMA,
         exp.CatalogProperty: exp.Properties.Location.POST_CREATE,
         exp.CharacterSetProperty: exp.Properties.Location.POST_SCHEMA,
         exp.ChecksumProperty: exp.Properties.Location.POST_NAME,
@@ -1007,23 +1018,24 @@ class Generator:
         if not comments or isinstance(expression, self.EXCLUDE_COMMENTS):
             return sql
 
-        comments_sql = " ".join(
-            f"/*{self.sanitize_comment(comment)}*/" for comment in comments if comment
-        )
+        comments_list = [
+            f"/*{self._replace_line_breaks(self.sanitize_comment(comment))}*/"
+            for comment in comments
+            if comment
+        ]
 
-        if not comments_sql:
+        if not comments_list:
             return sql
 
-        comments_sql = self._replace_line_breaks(comments_sql)
-
         if separated or isinstance(expression, self.WITH_SEPARATED_COMMENTS):
+            comments_sql = self.sep().join(comments_list)
             return (
                 f"{self.sep()}{comments_sql}{sql}"
                 if not sql or sql[0].isspace()
                 else f"{comments_sql}{self.sep()}{sql}"
             )
 
-        return f"{sql} {comments_sql}"
+        return f"{sql} {' '.join(comments_list)}"
 
     def wrap(self, expression: exp.Expr | str) -> str:
         this_sql = (
@@ -1945,6 +1957,20 @@ class Generator:
         params = self.sql(expression, "params")
         return f"{unique}{primary}{amp}{index}{name}{table}{params}"
 
+    def dynamicidentifier_sql(self, expression: exp.DynamicIdentifier) -> str:
+        this = expression.this
+        if this and this.is_string:
+            resolved = maybe_parse(this.name).sql(self.dialect)
+            if "expressions" in expression.args:
+                # `IDENTIFIER(...)` invoked as a function, e.g. `IDENTIFIER('my_func')(1, 2)`
+                # We can't safely emit the call to other dialects since name/arg semantics may differ
+                self.unsupported(
+                    "Transpiling dynamically-invoked IDENTIFIER() functions is unsupported"
+                )
+            return resolved
+        self.unsupported("IDENTIFIER() with non-literal arguments is not supported")
+        return self.func("IDENTIFIER", this)
+
     def identifier_sql(self, expression: exp.Identifier) -> str:
         text = expression.name
         lower = text.lower()
@@ -2393,10 +2419,12 @@ class Generator:
         laterals = self.expressions(expression, key="laterals", sep="")
 
         file_format = self.sql(expression, "format")
+        pattern = self.sql(expression, "pattern")
         if file_format:
-            pattern = self.sql(expression, "pattern")
             pattern = f", PATTERN => {pattern}" if pattern else ""
             file_format = f" (FILE_FORMAT => {file_format}{pattern})"
+        elif pattern:
+            file_format = f" (PATTERN => {pattern})"
 
         ordinality = expression.args.get("ordinality") or ""
         if ordinality:
@@ -3371,7 +3399,9 @@ class Generator:
         replace = f"{self.seg('REPLACE')} ({replace})" if replace else ""
         rename = self.expressions(expression, key="rename", flat=True)
         rename = f"{self.seg('RENAME')} ({rename})" if rename else ""
-        return f"*{except_}{replace}{rename}"
+        ilike = self.sql(expression, "ilike")
+        ilike = f"{self.seg('ILIKE')} {ilike}" if ilike else ""
+        return f"*{ilike}{except_}{replace}{rename}"
 
     def parameter_sql(self, expression: exp.Parameter) -> str:
         this = self.sql(expression, "this")
@@ -3719,9 +3749,6 @@ class Generator:
     def jsonpath_sql(self, expression: exp.JSONPath) -> str:
         path = self.expressions(expression, sep="", flat=True).lstrip(".")
 
-        if expression.args.get("escape"):
-            path = self.escape_str(path)
-
         if self.QUOTE_JSON_PATH:
             path = f"{self.dialect.QUOTE_START}{path}{self.dialect.QUOTE_END}"
 
@@ -3975,6 +4002,12 @@ class Generator:
         zone = self.sql(expression, "zone")
         return f"{this} AT TIME ZONE {zone} AT TIME ZONE 'UTC'"
 
+    def fromiso8601date_sql(self, expression: exp.FromISO8601Date) -> str:
+        return self.sql(exp.cast(expression.this, exp.DType.DATE))
+
+    def fromiso8601timestamp_sql(self, expression: exp.FromISO8601Timestamp) -> str:
+        return self.sql(exp.cast(expression.this, exp.DType.TIMESTAMPTZ))
+
     def add_sql(self, expression: exp.Add) -> str:
         return self.binary(expression, "+")
 
@@ -4054,6 +4087,14 @@ class Generator:
     def strtotime_sql(self, expression: exp.StrToTime) -> str:
         return self.func("STR_TO_TIME", expression.this, expression.args.get("format"))
 
+    def parsedatetime_sql(self, expression: exp.ParseDatetime) -> str:
+        return self.func(
+            "PARSE_DATETIME",
+            expression.this,
+            expression.args.get("format"),
+            expression.args.get("zone"),
+        )
+
     def currentdate_sql(self, expression: exp.CurrentDate) -> str:
         zone = self.sql(expression, "this")
         return f"CURRENT_DATE({zone})" if zone else "CURRENT_DATE"
@@ -5228,10 +5269,20 @@ class Generator:
             this = self.json_path_part(this)
             return f".{this}" if this else ""
 
-        if self.SAFE_JSON_PATH_KEY_RE.match(this):
+        quoted = expression.args.get("quoted")
+        if not (
+            quoted and self.JSON_PATH_KEY_QUOTED_FORCES_BRACKETS
+        ) and self.SAFE_JSON_PATH_KEY_RE.match(this):
             return f".{this}"
 
         this = self.json_path_part(this)
+
+        if quoted and self.QUOTE_JSON_PATH:
+            # The whole path is rendered as a single quoted string literal, so the bracketed key
+            # (which may itself contain backslash-escaped quotes, e.g. ["x \"y\"z"]) must be
+            # escaped again for the outer string literal (-> ["x \\"y\\"z"]).
+            this = self.escape_str(this)
+
         return (
             f"[{this}]"
             if self._quote_json_path_key_using_brackets and self.JSON_PATH_BRACKETED_KEY_SUPPORTED

{sqlglotc-30.11.0 → sqlglotc-30.12.0}/sqlglot/generators/clickhouse.py

@@ -280,6 +280,7 @@ class ClickHouseGenerator(generator.Generator):
         exp.ArrayConcat: rename_func("arrayConcat"),
         exp.ArrayContains: rename_func("has"),
         exp.ArrayFilter: lambda self, e: self.func("arrayFilter", e.expression, e.this),
+        exp.Transform: lambda self, e: self.func("arrayMap", e.expression, e.this),
         exp.ArrayRemove: remove_from_array_using_filter,
         exp.ArrayReverse: rename_func("arrayReverse"),
         exp.ArraySlice: rename_func("arraySlice"),
@@ -377,7 +378,9 @@ class ClickHouseGenerator(generator.Generator):
         exp.Levenshtein: unsupported_args("ins_cost", "del_cost", "sub_cost", "max_dist")(
             rename_func("editDistance")
         ),
-        exp.ParseDatetime: rename_func("parseDateTime"),
+        exp.ParseDatetime: lambda self, e: self.func(
+            "parseDateTime", e.this, e.args.get("format"), e.args.get("zone")
+        ),
     }
 
     PROPERTIES_LOCATION = {

{sqlglotc-30.11.0 → sqlglotc-30.12.0}/sqlglot/generators/databricks.py

@@ -15,6 +15,7 @@ class DatabricksGenerator(SparkGenerator):
     COPY_PARAMS_ARE_WRAPPED = False
     COPY_PARAMS_EQ_REQUIRED = True
     JSON_PATH_SINGLE_QUOTE_ESCAPE = False
+    JSON_PATH_KEY_QUOTED_FORCES_BRACKETS = True
     SAFE_JSON_PATH_KEY_RE = exp.SAFE_IDENTIFIER_RE
     QUOTE_JSON_PATH = False
     PARSE_JSON_NAME: str | None = "PARSE_JSON"

{sqlglotc-30.11.0 → sqlglotc-30.12.0}/sqlglot/generators/duckdb.py

@@ -6,7 +6,6 @@ import re
 import typing as t
 
 from sqlglot import exp, generator, transforms
-
 from sqlglot.dialects.dialect import (
     DATETIME_DELTA,
     JSON_EXTRACT_TYPE,
@@ -38,9 +37,12 @@ from sqlglot.dialects.dialect import (
     unit_to_str,
 )
 from sqlglot.generator import unsupported_args
-from sqlglot.helper import is_date_unit, seq_get
+from sqlglot.helper import find_new_name, is_date_unit, seq_get
+from sqlglot.optimizer.scope import find_all_in_scope
 from builtins import type as Type
 
+_CONNECT_BY_ARGS_TO_SKIP = frozenset({"connect", "where", "from_", "with_", "expressions"})
+
 # Regex to detect time zones in timestamps of the form [+|-]TT[:tt]
 # The pattern matches timezone offsets that appear after the time portion
 TIMEZONE_PATTERN = re.compile(r":\d{2}.*?[+\-]\d{2}(?::\d{2})?")
@@ -710,6 +712,124 @@ def _seq_to_range_in_generator(expression: exp.Expr) -> exp.Expr:
     return expression.transform(replace_seq, copy=False)
 
 
+def connect_by_to_recursive_cte(expression: exp.Expr) -> exp.Expr:
+    # Rewrites START WITH ... CONNECT BY PRIOR into WITH RECURSIVE
+    # Falls through unchanged if there are no PRIORs.
+    if not isinstance(expression, exp.Select) or not expression.args.get("connect"):
+        return expression
+
+    connect = expression.args["connect"]
+    connect_pred = connect.args["connect"]
+
+    priors = list(connect_pred.find_all(exp.Prior))
+    if not priors:
+        return expression
+
+    from_ = expression.args.get("from_")
+    if not from_ or expression.args.get("joins"):
+        return expression
+
+    source_table = from_.this
+    base_select_exprs = expression.expressions
+    base_where = expression.args.get("where")
+    base_with = expression.args.get("with_")
+
+    # LEVEL is a Snowflake pseudo-column: it's always computed as a depth counter in the CTE.
+    has_level = any(
+        isinstance(col, exp.Column) and col.name.upper() == "LEVEL"
+        for e in base_select_exprs
+        for col in e.find_all(exp.Column)
+    )
+    has_star = expression.is_star
+
+    # CONNECT_BY_ROOT col yields the value of `col` from the START WITH row that begins each
+    # branch. Each one is threaded through the CTE as an extra column: the anchor binds it to the
+    # row's own value, the recursive arm forwards the parent's value unchanged.
+    root_col_names: list[str] = []
+    anchor_root_cols: list[exp.Expr] = []
+    inner_root_cols: list[exp.Expr] = []
+    roots = [root for e in base_select_exprs for root in e.find_all(exp.ConnectByRoot)]
+
+    for i, root in enumerate(roots):
+        name = f"_connect_by_root_{i}"
+        root_col_names.append(name)
+        anchor_root_cols.append(exp.alias_(root.this, name))
+        inner_root_cols.append(exp.alias_(exp.column(name, "_parent_row"), name))
+        root.replace(exp.column(name))
+
+    # Build the join condition from the full CONNECT BY predicate:
+    # PRIOR(col) → _parent_row.col, unqualified cols → _child_row.col.
+    def _qualify_connect_pred(node: exp.Expression) -> exp.Expression:
+        for col in find_all_in_scope(node, exp.Column):
+            col.set(
+                "table",
+                exp.to_identifier(
+                    "_parent_row" if isinstance(col.parent, exp.Prior) else "_child_row"
+                ),
+            )
+        for prior in find_all_in_scope(node, exp.Prior):
+            prior.replace(prior.this)
+        return node
+
+    # Avoid colliding with any CTE names already on the query.
+    cte_name = find_new_name(
+        {cte.alias for cte in (base_with.expressions if base_with else [])}, "_rootcte"
+    )
+
+    # Anchor: project all source columns + seed LEVEL at 1 + bind each root column to its own value.
+    anchor = exp.select(
+        exp.Star(), exp.alias_(exp.Literal.number(1), "level"), *anchor_root_cols
+    ).from_(source_table)
+    if connect.args.get("start"):
+        anchor = anchor.where(connect.args["start"])
+
+    # Recursive arm: carry all child columns + increment level + forward each root value.
+    # SELECT * in both arms means WHERE/PRIOR columns are always available without explicit tracking.
+    inner_query = (
+        exp.select(
+            exp.Column(this=exp.Star(), table=exp.to_identifier("_child_row")),
+            exp.alias_(exp.column("level", "_parent_row") + 1, "level"),
+            *inner_root_cols,
+        )
+        .from_(source_table.as_("_child_row"))
+        .join(exp.to_table(cte_name).as_("_parent_row"), on=_qualify_connect_pred(connect_pred))
+    )
+
+    # Outer SELECT re-projects from the CTE. Synthetic level/root columns are excluded from any
+    # star expansion (level only when not referenced) but kept where explicitly projected.
+    if has_star:
+        except_cols = [] if has_level else [exp.column("level")]
+        except_cols.extend(exp.column(name) for name in root_col_names)
+        star = exp.Star(except_=except_cols) if except_cols else exp.Star()
+        outer_select_exprs: list[exp.Expr] = [
+            star,
+            *(e for e in base_select_exprs if not e.is_star),
+        ]
+    else:
+        outer_select_exprs = base_select_exprs
+    outer_query = exp.select(*outer_select_exprs).from_(cte_name)
+    if base_where:
+        outer_query = outer_query.where(base_where.this)
+
+    # Attach the CTE, marking the WITH clause recursive.
+    if base_with:
+        outer_query.set("with_", base_with)
+    outer_query = outer_query.with_(
+        cte_name, as_=anchor.union(inner_query, distinct=False), recursive=True, copy=False
+    )
+
+    for arg, val in expression.args.items():
+        if val and arg not in _CONNECT_BY_ARGS_TO_SKIP:
+            outer_query.set(arg, val)
+
+    # Strip stale source table qualifiers in one pass; CTEs are child scopes so
+    # find_all_in_scope stays within the outer query only.
+    for col in find_all_in_scope(outer_query, exp.Column):
+        col.set("table", None)
+
+    return outer_query
+
+
 def _seq_sql(self: DuckDBGenerator, expression: exp.Func, byte_width: int) -> str:
     """
     Transpile Snowflake SEQ1/SEQ2/SEQ4/SEQ8 to DuckDB.
@@ -1616,7 +1736,9 @@ class DuckDBGenerator(generator.Generator):
         exp.Lateral: _explode_to_unnest_sql,
         exp.LogicalOr: lambda self, e: self.func("BOOL_OR", _cast_to_boolean(e.this)),
         exp.LogicalAnd: lambda self, e: self.func("BOOL_AND", _cast_to_boolean(e.this)),
-        exp.Select: transforms.preprocess([_seq_to_range_in_generator]),
+        exp.Select: transforms.preprocess(
+            [connect_by_to_recursive_cte, _seq_to_range_in_generator]
+        ),
         exp.Seq1: lambda self, e: _seq_sql(self, e, 1),
         exp.Seq2: lambda self, e: _seq_sql(self, e, 2),
         exp.Seq4: lambda self, e: _seq_sql(self, e, 4),
@@ -2577,9 +2699,6 @@ class DuckDBGenerator(generator.Generator):
         )
         return self.function_fallback_sql(expression)
 
-    def fromiso8601timestamp_sql(self, expression: exp.FromISO8601Timestamp) -> str:
-        return self.sql(exp.cast(expression.this, exp.DType.TIMESTAMPTZ))
-
     def strposition_sql(self, expression: exp.StrPosition) -> str:
         this = expression.this
         substr = expression.args.get("substr")
@@ -2659,6 +2778,19 @@ class DuckDBGenerator(generator.Generator):
             )
         )
 
+    def parsedatetime_sql(self, expression: exp.ParseDatetime) -> str:
+        formatted_time = self.format_time(expression)
+
+        default_year = expression.args.get("default_year")
+        if default_year:
+            year_str = exp.Literal.string(f"{default_year.name} ")
+            fmt_prefix = exp.Literal.string("%Y ")
+            value = exp.DPipe(this=year_str, expression=expression.this)
+            fmt = exp.DPipe(this=fmt_prefix, expression=formatted_time)
+            return self.func("STRPTIME", value, fmt)
+
+        return self.func("STRPTIME", expression.this, formatted_time)
+
     def parsetime_sql(self, expression: exp.ParseTime) -> str:
         formatted_time = self.format_time(expression)
         return self.sql(
@@ -4370,6 +4502,23 @@ class DuckDBGenerator(generator.Generator):
                 )
                 .else_(exp.TryCast(this=src, to=to))
             )
+        elif (
+            isinstance(to_type, exp.Interval)
+            and (unit := to_type.unit)
+            and expression.args.get("requires_string")
+        ):
+            interval_type = exp.DataType.build("INTERVAL")
+            if isinstance(unit, exp.IntervalSpan):
+                self.unsupported(
+                    "TRY_CAST to INTERVAL with span (e.g. HOUR TO MINUTE) is not supported in DuckDB"
+                )
+                return self.sql(exp.TryCast(this=src, to=interval_type))
+            return self.sql(
+                exp.TryCast(
+                    this=exp.DPipe(this=src, expression=exp.Literal.string(f" {unit.name}")),
+                    to=interval_type,
+                )
+            )
 
         return super().trycast_sql(expression)
 

{sqlglotc-30.11.0 → sqlglotc-30.12.0}/sqlglot/generators/exasol.py

@@ -348,9 +348,7 @@ class ExasolGenerator(generator.Generator):
         exp.DateTrunc: _date_trunc_sql,
         exp.DayOfWeek: lambda self, e: f"CAST(TO_CHAR({self.sql(e, 'this')}, 'D') AS INTEGER)",
         exp.DatetimeTrunc: timestamptrunc_sql(),
-        exp.GroupConcat: lambda self, e: groupconcat_sql(
-            self, e, func_name="LISTAGG", within_group=True
-        ),
+        exp.GroupConcat: lambda self, e: groupconcat_sql(self, e, on_overflow=True),
         # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/edit_distance.htm#EDIT_DISTANCE
         exp.Levenshtein: unsupported_args("ins_cost", "del_cost", "sub_cost", "max_dist")(
             rename_func("EDIT_DISTANCE")

{sqlglotc-30.11.0 → sqlglotc-30.12.0}/sqlglot/generators/mysql.py

@@ -653,6 +653,10 @@ class MySQLGenerator(generator.Generator):
         self.unsupported("Array operations are not supported by MySQL")
         return self.function_fallback_sql(expression)
 
+    def arraycontainedby_sql(self, expression: exp.ArrayContainedBy) -> str:
+        self.unsupported("Array operations are not supported by MySQL")
+        return self.function_fallback_sql(expression)
+
     def dpipe_sql(self, expression: exp.DPipe) -> str:
         return self.func("CONCAT", *expression.flatten())