sqlglotc 30.8.0__tar.gz → 30.9.0__tar.gz

{sqlglotc-30.8.0/sqlglotc.egg-info → sqlglotc-30.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlglotc
-Version: 30.8.0
+Version: 30.9.0
 Summary: mypyc-compiled extensions for sqlglot
 Author-email: Toby Mao <toby.mao@gmail.com>
 License-Expression: MIT
@@ -10,4 +10,4 @@ Requires-Python: >=3.10
 Provides-Extra: dev
 Requires-Dist: setuptools>=61.0; extra == "dev"
 Requires-Dist: setuptools_scm; extra == "dev"
-Requires-Dist: sqlglot-mypy>=1.20.0.post6; extra == "dev"
+Requires-Dist: sqlglot-mypy>=2.1.0.post2; extra == "dev"

{sqlglotc-30.8.0 → sqlglotc-30.9.0}/pyproject.toml

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

{sqlglotc-30.8.0 → sqlglotc-30.9.0}/sqlglot/expressions/aggregate.py

@@ -208,7 +208,7 @@ class NthValue(Expression, AggFunc):
 
 
 class ObjectAgg(Expression, AggFunc):
-    arg_types = {"this": True, "expression": True}
+    arg_types = {"this": True, "expression": False}
 
 
 class PercentileCont(Expression, AggFunc):

{sqlglotc-30.8.0 → sqlglotc-30.9.0}/sqlglot/expressions/core.py

@@ -88,6 +88,7 @@ class Expr:
     _hash_raw_args: t.ClassVar[bool] = False
     is_subquery: t.ClassVar[bool] = False
     is_cast: t.ClassVar[bool] = False
+    is_data_type: t.ClassVar[bool] = False
 
     args: dict[str, t.Any]
     parent: Expr | None
@@ -837,26 +838,35 @@ class Expression(Expr):
     def __hash__(self) -> int:
         if self._hash is None:
             nodes: list[Expr] = []
-            queue: deque[Expr] = deque()
-            queue.append(self)
+            stack: list[Expr] = [self]
 
-            while queue:
-                node = queue.popleft()
+            # Collect nodes, finding child expressions inline instead of via the
+            # iter_expressions generator (whose per-node generator object dominates the
+            # hash's cost). reversed(nodes) is a valid post-order regardless of DFS/BFS.
+            while stack:
+                node = stack.pop()
                 nodes.append(node)
 
-                for child in node.iter_expressions():
-                    if child._hash is None:
-                        queue.append(child)
+                for v in node.args.values():
+                    if isinstance(v, Expr):
+                        if v._hash is None:
+                            stack.append(v)
+                    elif type(v) is list:
+                        for x in v:
+                            if isinstance(x, Expr) and x._hash is None:
+                                stack.append(x)
 
             for node in reversed(nodes):
                 hash_ = hash(node.key)
 
                 if node._hash_raw_args:
-                    for k, v in sorted(node.args.items()):
+                    for k in sorted(node.args):
+                        v = node.args[k]
                         if v:
                             hash_ = hash((hash_, k, v))
                 else:
-                    for k, v in sorted(node.args.items()):
+                    for k in sorted(node.args):
+                        v = node.args[k]
                         vt = type(v)
 
                         if vt is list:
@@ -953,6 +963,8 @@ class Expression(Expr):
 
     @property
     def type(self) -> DataType | None:
+        if self.is_data_type:
+            return self  # type: ignore[return-value]
         if self.is_cast:
             return self._type or self.to  # type: ignore[attr-defined]
         return self._type
@@ -1039,6 +1051,11 @@ class Expression(Expr):
         return comments
 
     def append(self, arg_key: str, value: t.Any) -> None:
+        node: Expr | None = self
+        while node and node._hash is not None:
+            node._hash = None
+            node = node.parent
+
         if type(self.args.get(arg_key)) is not list:
             self.args[arg_key] = []
         self._set_parent(arg_key, value)
@@ -2118,6 +2135,10 @@ class Distance(Expression, Binary):
     pass
 
 
+class DistanceNd(Expression, Binary):
+    pass
+
+
 class Escape(Expression, Binary):
     pass
 
@@ -2269,8 +2290,7 @@ class Or(Expression, Connector, Func):
 
 
 class Xor(Expression, Connector, Func):
-    arg_types = {"this": False, "expression": False, "expressions": False, "round_input": False}
-    is_var_len_args = True
+    arg_types = {"this": True, "expression": True, "round_input": False}
 
 
 class Pow(Expression, Binary, Func):
@@ -2428,6 +2448,7 @@ QUERY_MODIFIERS = {
     "settings": False,
     "format": False,
     "options": False,
+    "for_": False,
 }
 
 
@@ -2534,7 +2555,7 @@ def _to_s(node: t.Any, verbose: bool = False, level: int = 0, repr_str: bool = F
     if isinstance(node, Expr):
         args = {k: v for k, v in node.args.items() if (v is not None and v != []) or verbose}
 
-        if (node.type or verbose) and type(node).__name__ != "DataType":
+        if (node.type or verbose) and not node.is_data_type:
             args["_type"] = node.type
         if node.comments or verbose:
             args["_comments"] = node.comments

{sqlglotc-30.8.0 → sqlglotc-30.9.0}/sqlglot/expressions/datatypes.py

@@ -8,6 +8,7 @@ from enum import auto
 from sqlglot.helper import AutoName
 from sqlglot.errors import ErrorLevel, ParseError
 from sqlglot.expressions.core import (
+    Expr,
     Expression,
     _TimeUnit,
     Identifier,
@@ -17,13 +18,18 @@ from sqlglot.expressions.core import (
 from builtins import type as Type
 
 if t.TYPE_CHECKING:
+    from sqlglot._typing import DataTypeArgs
     from sqlglot.dialects.dialect import DialectType
-    from typing_extensions import Self
+    from typing_extensions import Self, Unpack
 
 
 class DataTypeParam(Expression):
     arg_types = {"this": True, "expression": False}
 
+    @property
+    def this(self) -> Expr:
+        return self.args["this"]
+
     @property
     def name(self) -> str:
         return self.this.name
@@ -181,6 +187,8 @@ class DataType(Expression):
         "collate": False,
     }
 
+    is_data_type: t.ClassVar[bool] = True
+
     Type: t.ClassVar[Type[DType]] = DType
 
     STRUCT_TYPES: t.ClassVar[set[DType]] = {
@@ -331,7 +339,7 @@ class DataType(Expression):
         dialect: DialectType = None,
         udt: bool = False,
         copy: bool = True,
-        **kwargs: object,
+        **kwargs: Unpack[DataTypeArgs],
     ) -> Self:
         """
         Constructs a DataType object.
@@ -364,7 +372,11 @@ class DataType(Expression):
 
     @classmethod
     def from_str(
-        cls, dtype: str, dialect: DialectType = None, udt: bool = False, **kwargs: object
+        cls,
+        dtype: str,
+        dialect: DialectType = None,
+        udt: bool = False,
+        **kwargs: Unpack[DataTypeArgs],
     ) -> Self:
         """
         Constructs a `DataType` object from a `str` representation.
@@ -405,10 +417,10 @@ class DataType(Expression):
         Returns:
             True, if and only if there is a type in `dtypes` which is equal to this DataType.
         """
-        self_is_nullable = self.args.get("nullable")
+        self_is_nullable: bool | None = self.args.get("nullable")
         for dtype in dtypes:
             other_type = DataType.build(dtype, copy=False, udt=True)
-            other_is_nullable = other_type.args.get("nullable")
+            other_is_nullable: bool | None = other_type.args.get("nullable")
             if (
                 other_type.expressions
                 or (check_nullable and (self_is_nullable or other_is_nullable))

{sqlglotc-30.8.0 → sqlglotc-30.9.0}/sqlglot/expressions/ddl.py

@@ -226,6 +226,14 @@ class UserDefinedFunction(Expression):
     arg_types = {"this": True, "expressions": False, "wrapped": False}
 
 
+class MacroOverloads(Expression):
+    arg_types = {"expressions": True}
+
+
+class MacroOverload(Expression):
+    arg_types = {"this": True, "expressions": False, "is_table": False}
+
+
 class CharacterSet(Expression):
     arg_types = {"this": True, "default": False}
 

{sqlglotc-30.8.0 → sqlglotc-30.9.0}/sqlglot/expressions/dml.py

@@ -283,6 +283,7 @@ class LoadData(Expression):
         "this": True,
         "local": False,
         "overwrite": False,
+        "temp": False,
         "inpath": False,
         "files": False,
         "partition": False,

{sqlglotc-30.8.0 → sqlglotc-30.9.0}/sqlglot/expressions/functions.py

@@ -70,7 +70,7 @@ class Cast(Expression, Func):
 
 
 class TryCast(Cast):
-    arg_types = {**Cast.arg_types, "requires_string": False}
+    arg_types = {**Cast.arg_types, "requires_string": False, "null_on_text_overflow": False}
 
 
 class JSONCast(Cast):
@@ -436,6 +436,10 @@ class XMLElement(Expression, Func):
     arg_types = {"this": True, "expressions": False, "evalname": False}
 
 
+class GetIgnoreCase(Expression, Func):
+    arg_types = {"this": True, "expression": True}
+
+
 class XMLGet(Expression, Func):
     _sql_names = ["XMLGET"]
     arg_types = {"this": True, "expression": True, "instance": False}

{sqlglotc-30.8.0 → sqlglotc-30.9.0}/sqlglot/expressions/query.py

@@ -915,6 +915,11 @@ class QueryOption(Expression):
     arg_types = {"this": True, "expression": False}
 
 
+# FOR { XML | JSON } query modifier; `kind` is the discriminant ("XML" or "JSON").
+class ForClause(Expression):
+    arg_types = {"kind": True, "expressions": False}
+
+
 class WithTableHint(Expression):
     arg_types = {"expressions": True}
 
@@ -1753,6 +1758,9 @@ class Pivot(Expression):
         "default_on_null": False,
         "into": False,
         "with_": False,
+        "identify_pivot_strings": False,
+        "prefixed_pivot_columns": False,
+        "pivot_column_naming": False,
     }
 
     @property

{sqlglotc-30.8.0 → sqlglotc-30.9.0}/sqlglot/expressions/string.py

@@ -375,6 +375,7 @@ class ToNumber(Expression, Func):
         "scale": False,
         "safe": False,
         "safe_name": False,
+        "default": False,
     }
 
 

{sqlglotc-30.8.0 → sqlglotc-30.9.0}/sqlglot/generator.py

@@ -1328,7 +1328,9 @@ class Generator:
         if expression_sql:
             expression_sql = f"{begin}{self.sep()}{expression_sql}"
 
-            if self.CREATE_FUNCTION_RETURN_AS or not isinstance(expression.expression, exp.Return):
+            if not isinstance(expression.expression, exp.MacroOverloads) and (
+                self.CREATE_FUNCTION_RETURN_AS or not isinstance(expression.expression, exp.Return)
+            ):
                 postalias_props_sql = ""
                 if properties_locs.get(exp.Properties.Location.POST_ALIAS):
                     postalias_props_sql = self.properties(
@@ -1605,7 +1607,12 @@ class Generator:
                 )
 
             return delimited_byte_string
-        return this
+
+        if "\\" in self.dialect.tokenizer_class.STRING_ESCAPES:
+            return self.sql(exp.Literal.string(this))
+
+        self.unsupported(f"Byte strings are not supported for {self.dialect.__class__.__name__}")
+        return ""
 
     def unicodestring_sql(self, expression: exp.UnicodeString) -> str:
         this = self.sql(expression, "this")
@@ -2454,6 +2461,81 @@ class Generator:
 
         return f" {tablesample_keyword or self.TABLESAMPLE_KEYWORDS} {method}{expr}{seed}"
 
+    def _pivot_in_value_aliases(self, expression: exp.Pivot) -> list[exp.Expression] | None:
+        # Returns the rewritten field.expressions list with PivotAlias wrappers injected where
+        # the stored column name differs from the target dialect's natural output.
+        columns = expression.args.get("columns")
+        if not columns or len(expression.fields) != 1:
+            return None
+
+        args = expression.args
+        parser_cls = self.dialect.parser_class
+
+        tgt_identify_pivot_strings = parser_cls.IDENTIFY_PIVOT_STRINGS
+        tgt_prefixed_pivot_columns = parser_cls.PREFIXED_PIVOT_COLUMNS
+        tgt_pivot_column_naming = parser_cls.PIVOT_COLUMN_NAMING
+
+        src_identify_pivot_strings = args.get("identify_pivot_strings", tgt_identify_pivot_strings)
+        src_prefixed_pivot_columns = args.get("prefixed_pivot_columns", tgt_prefixed_pivot_columns)
+        src_pivot_column_naming = args.get("pivot_column_naming", tgt_pivot_column_naming)
+
+        if (
+            src_identify_pivot_strings == tgt_identify_pivot_strings
+            and src_prefixed_pivot_columns == tgt_prefixed_pivot_columns
+            and src_pivot_column_naming == tgt_pivot_column_naming
+        ):
+            return None
+
+        in_exprs = expression.fields[0].expressions
+        step = len(columns) // len(in_exprs)
+
+        # Derive the per-value suffix from the first stored column vs the first IN-list value.
+        # This correctly handles dialects (e.g. Spark single-agg) that ignore agg aliases.
+        first_base = in_exprs[0].sql() if src_identify_pivot_strings else in_exprs[0].alias_or_name
+        first_stored = columns[0].name
+
+        # exit if only suffix matches, not prefix. (e.g. BigQuery, which cannot be fixed)
+        if not first_stored.startswith(first_base):
+            return None
+
+        suffix = first_stored[len(first_base) :]
+
+        # Whether the target dialect would append an agg-name suffix for this pivot.
+        # Spark single-agg uniquely drops the agg alias entirely.
+        target_has_suffix = (
+            len(expression.expressions) > 1 or tgt_pivot_column_naming != "agg_name_if_multiple"
+        ) and any(a.alias for a in expression.expressions)
+        source_has_suffix = suffix != ""
+
+        new_exprs: list[exp.Expression] = []
+        modified = False
+        for val_idx, e in enumerate(in_exprs):
+            if isinstance(e, exp.PivotAlias):
+                new_exprs.append(e)
+                continue
+
+            i = val_idx * step
+            stored_full = columns[i].name
+            stored_value = stored_full[: -len(suffix)] if suffix else stored_full
+            target_value = e.sql() if tgt_identify_pivot_strings else e.alias_or_name
+
+            # Source had a suffix, but target won't apply one
+            if source_has_suffix and not target_has_suffix:
+                new_exprs.append(
+                    exp.PivotAlias(this=e, alias=exp.to_identifier(stored_full, quoted=True))
+                )
+                modified = True
+            # Value-part mismatch (e.g. Snowflake's literal-style values vs others).
+            elif stored_value != target_value:
+                new_exprs.append(
+                    exp.PivotAlias(this=e, alias=exp.to_identifier(stored_value, quoted=True))
+                )
+                modified = True
+            else:
+                new_exprs.append(e)
+
+        return new_exprs if modified else None
+
     def pivot_sql(self, expression: exp.Pivot) -> str:
         expressions = self.expressions(expression, flat=True)
         direction = "UNPIVOT" if expression.unpivot else "PIVOT"
@@ -2473,6 +2555,12 @@ class Generator:
                 sql = f"{direction} {this}{on}{into}{using}{group}"
             return self.prepend_ctes(expression, sql)
 
+        if not expression.unpivot:
+            # Wrap IN-list values with explicit aliases where the target dialect would differ
+            new_field_exprs = self._pivot_in_value_aliases(expression)
+            if new_field_exprs is not None:
+                expression.fields[0].set("expressions", new_field_exprs)
+
         alias = self.sql(expression, "alias")
         alias = f" AS {alias}" if alias else ""
 
@@ -2896,7 +2984,12 @@ class Generator:
         if files:
             files_sql = self.expressions(files, flat=True)
             files_sql = f"FILES{self.wrap(files_sql)}"
-            this = f" {this}" if is_overwrite else f" INTO TABLE {this}"
+            if is_overwrite:
+                this = f" {this}"
+            elif expression.args.get("temp"):
+                this = f" INTO TEMP TABLE {this}"
+            else:
+                this = f" INTO TABLE {this}"
             return f"LOAD DATA{overwrite}{this} FROM {files_sql}"
 
         local = " LOCAL" if expression.args.get("local") else ""
@@ -2955,6 +3048,40 @@ class Generator:
     def sort_sql(self, expression: exp.Sort) -> str:
         return self.op_expressions("SORT BY", expression)
 
+    def _resolve_ordered_for_null_ordering_simulation(
+        self, expression: exp.Ordered
+    ) -> exp.Expr | None:
+        """Resolve a bare ORDER BY name against the enclosing SELECT projection.
+
+        Returns the underlying expression of the uniquely-matching projection
+        (Alias-stripped) for substitution into the NULLS FIRST/LAST CASE
+        simulation, since the CASE is evaluated in FROM-clause scope rather
+        than alias scope (MySQL error 1052). Returns None if no safe
+        substitution applies, leaving the original behaviour unchanged.
+        """
+        this = expression.this
+        if not (isinstance(this, exp.Column) and not this.table):
+            return None
+
+        ancestor = expression.find_ancestor(exp.Select, exp.Window)
+        if not isinstance(ancestor, exp.Select):
+            return None
+
+        column_name = this.name
+        matched: list[exp.Expr] = [
+            p.this if isinstance(p, exp.Alias) else p
+            for p in ancestor.selects
+            if p.output_name == column_name
+        ]
+        match = matched[0] if len(matched) == 1 else None
+
+        # Skip the substitution when it would be identical to the existing
+        # reference (e.g. ``SELECT col FROM t ORDER BY col``).
+        if isinstance(match, exp.Column) and not match.table and match.name == column_name:
+            return None
+
+        return match
+
     def ordered_sql(self, expression: exp.Ordered) -> str:
         desc = expression.args.get("desc")
         asc = not desc
@@ -3025,10 +3152,10 @@ class Generator:
                             f"'{nulls_sort_change.strip()}' translation not supported with positional ordering"
                         )
                     elif not isinstance(expression.this, exp.Rand):
+                        resolved = self._resolve_ordered_for_null_ordering_simulation(expression)
+                        target = self.sql(resolved) if resolved is not None else this
                         null_sort_order = " DESC" if nulls_sort_change == " NULLS FIRST" else ""
-                        this = (
-                            f"CASE WHEN {this} IS NULL THEN 1 ELSE 0 END{null_sort_order}, {this}"
-                        )
+                        this = f"CASE WHEN {target} IS NULL THEN 1 ELSE 0 END{null_sort_order}, {target}"
                     nulls_sort_change = ""
 
         with_fill = self.sql(expression, "with_fill")
@@ -3099,7 +3226,7 @@ class Generator:
             *self.offset_limit_modifiers(expression, isinstance(limit, exp.Fetch), limit),
             *self.after_limit_modifiers(expression),
             self.options_modifier(expression),
-            self.for_modifiers(expression),
+            self.sql(expression, "for_"),
             sep="",
         )
 
@@ -3107,9 +3234,16 @@ class Generator:
         options = self.expressions(expression, key="options")
         return f" {options}" if options else ""
 
-    def for_modifiers(self, expression: exp.Expr) -> str:
-        for_modifiers = self.expressions(expression, key="for_")
-        return f"{self.sep()}FOR XML{self.seg(for_modifiers)}" if for_modifiers else ""
+    def forclause_sql(self, expression: exp.ForClause) -> str:
+        kind = expression.args["kind"]
+        if kind == "BROWSE":
+            return f"{self.sep()}FOR BROWSE"
+        # FOR XML/JSON always carry at least AUTO/PATH. An empty rendering means
+        # the target dialect doesn't support QueryOption, so we drop the clause.
+        options = self.expressions(expression, key="expressions")
+        if not options:
+            return ""
+        return f"{self.sep()}FOR {kind}{self.seg(options)}"
 
     def queryoption_sql(self, expression: exp.QueryOption) -> str:
         self.unsupported("Unsupported query option.")
@@ -3857,9 +3991,7 @@ class Generator:
             else:
                 stack.append(expression.right)
                 if expression.comments and self.comments:
-                    for comment in expression.comments:
-                        if comment:
-                            op += f" /*{self.sanitize_comment(comment)}*/"
+                    op = self.maybe_comment(op, comments=expression.comments)
                 stack.extend((op, expression.left))
             return op
 
@@ -4215,6 +4347,9 @@ class Generator:
     def distance_sql(self, expression: exp.Distance) -> str:
         return self.binary(expression, "<->")
 
+    def distancend_sql(self, expression: exp.DistanceNd) -> str:
+        return self.binary(expression, "<<->>")
+
     def dot_sql(self, expression: exp.Dot) -> str:
         return f"{self.sql(expression, 'this')}.{self.sql(expression, 'expression')}"
 
@@ -4536,6 +4671,15 @@ class Generator:
         )
         return f"{this}{expressions}" if expressions.strip() != "" else this
 
+    def macrooverloads_sql(self, expression: exp.MacroOverloads) -> str:
+        return self.expressions(expression, flat=True)
+
+    def macrooverload_sql(self, expression: exp.MacroOverload) -> str:
+        params = self.no_identify(self.expressions, expression, flat=True)
+        body = self.sql(expression, "this")
+        prefix = "TABLE " if expression.args.get("is_table") else ""
+        return f"({params}) AS {prefix}{body}"
+
     def joinhint_sql(self, expression: exp.JoinHint) -> str:
         this = self.sql(expression, "this")
         expressions = self.expressions(expression, flat=True)
@@ -4612,6 +4756,7 @@ class Generator:
     def tochar_sql(self, expression: exp.ToChar) -> str:
         return self.sql(exp.cast(expression.this, exp.DType.TEXT))
 
+    @unsupported_args("default")
     def tonumber_sql(self, expression: exp.ToNumber) -> str:
         if not self.SUPPORTS_TO_NUMBER:
             self.unsupported("Unsupported TO_NUMBER function")

{sqlglotc-30.8.0 → sqlglotc-30.9.0}/sqlglot/generators/clickhouse.py

@@ -349,7 +349,7 @@ class ClickHouseGenerator(generator.Generator):
         exp.TimestampSub: _datetime_delta_sql("TIMESTAMP_SUB"),
         exp.Typeof: rename_func("toTypeName"),
         exp.VarMap: _map_sql,
-        exp.Xor: lambda self, e: self.func("xor", e.this, e.expression, *e.expressions),
+        exp.Xor: lambda self, e: self.func("xor", e.this, e.expression),
         exp.MD5Digest: rename_func("MD5"),
         exp.MD5: lambda self, e: self.func("LOWER", self.func("HEX", self.func("MD5", e.this))),
         exp.SHA: rename_func("SHA1"),

{sqlglotc-30.8.0 → sqlglotc-30.9.0}/sqlglot/generators/duckdb.py

@@ -2285,6 +2285,10 @@ class DuckDBGenerator(generator.Generator):
             f"({self.sql(exp.replace_placeholders(self.BITMAP_CONSTRUCT_AGG_TEMPLATE, arg=arg))})"
         )
 
+    def getignorecase_sql(self, expression: exp.GetIgnoreCase) -> str:
+        self.unsupported("DuckDB does not support the GET_IGNORE_CASE() function")
+        return self.function_fallback_sql(expression)
+
     def compress_sql(self, expression: exp.Compress) -> str:
         self.unsupported("DuckDB does not support the COMPRESS() function")
         return self.function_fallback_sql(expression)
@@ -2647,6 +2651,15 @@ class DuckDBGenerator(generator.Generator):
             )
         )
 
+    def parsetime_sql(self, expression: exp.ParseTime) -> str:
+        formatted_time = self.format_time(expression)
+        return self.sql(
+            exp.cast(
+                self.func("STRPTIME", expression.this, formatted_time),
+                exp.DataType(this=exp.DType.TIME),
+            )
+        )
+
     def tsordstotime_sql(self, expression: exp.TsOrDsToTime) -> str:
         this = expression.this
         time_format = self.format_time(expression)
@@ -4313,6 +4326,27 @@ class DuckDBGenerator(generator.Generator):
 
         return self.func(func, this, decimals, truncate)
 
+    def trycast_sql(self, expression: exp.TryCast) -> str:
+        to = expression.to
+        to_type = to.this
+
+        if (
+            expression.args.get("null_on_text_overflow")
+            and to_type in exp.DataType.TEXT_TYPES
+            and to.expressions
+        ):
+            src = expression.this
+            return self.sql(
+                exp.case()
+                .when(
+                    exp.LTE(this=exp.func("LENGTH", src), expression=to.expressions[0].this),
+                    exp.cast(src, "TEXT"),
+                )
+                .else_(exp.Null())
+            )
+
+        return super().trycast_sql(expression)
+
     def strtok_sql(self, expression: exp.Strtok) -> str:
         string_arg = expression.this
         delimiter_arg = expression.args.get("delimiter")

{sqlglotc-30.8.0 → sqlglotc-30.9.0}/sqlglot/generators/exasol.py

@@ -916,6 +916,12 @@ class ExasolGenerator(generator.Generator):
             )
             return self.sql(select)
 
+        if expression.name == "DATABASES":
+            select = exp.select(exp.column("SCHEMA_NAME")).from_(
+                exp.table_("EXA_SCHEMAS", db="SYS")
+            )
+            return self.sql(select)
+
         return super().show_sql(expression)
 
     def collate_sql(self, expression: exp.Collate) -> str: