sqlglotc 30.7.0__tar.gz → 30.8.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlglotc
-Version: 30.7.0
+Version: 30.8.0
 Summary: mypyc-compiled extensions for sqlglot
 Author-email: Toby Mao <toby.mao@gmail.com>
 License-Expression: MIT

{sqlglotc-30.7.0 → sqlglotc-30.8.0}/sqlglot/expressions/array.py

@@ -365,5 +365,5 @@ class StDistance(Expression, Func):
 
 
 class StPoint(Expression, Func):
-    arg_types = {"this": True, "expression": True, "null": False}
+    arg_types = {"this": True, "expression": True, "z": False, "m": False}
     _sql_names = ["ST_POINT", "ST_MAKEPOINT"]

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

@@ -2135,7 +2135,7 @@ class GTE(Expression, Binary, Predicate):
 
 
 class ILike(Expression, Binary, Predicate):
-    pass
+    arg_types = {"this": True, "expression": True, "negate": False}
 
 
 class IntDiv(Expression, Binary):
@@ -2147,7 +2147,7 @@ class Is(Expression, Binary, Predicate):
 
 
 class Like(Expression, Binary, Predicate):
-    pass
+    arg_types = {"this": True, "expression": True, "negate": False}
 
 
 class Match(Expression, Binary, Predicate):

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

@@ -178,6 +178,7 @@ class DataType(Expression):
         "values": False,
         "kind": False,
         "nullable": False,
+        "collate": False,
     }
 
     Type: t.ClassVar[Type[DType]] = DType

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

@@ -246,7 +246,7 @@ class AlterColumn(Expression):
 
 
 class ModifyColumn(Expression):
-    pass
+    arg_types = {"this": True, "rename_from": False}
 
 
 class AlterIndex(Expression):

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

@@ -148,6 +148,10 @@ class Nullif(Expression, Func):
     arg_types = {"this": True, "expression": True}
 
 
+class ObjectTransform(Expression, Func):
+    arg_types = {"this": True, "keep": False, "set_": False}
+
+
 class Nvl2(Expression, Func):
     arg_types = {"this": True, "true": True, "false": False}
 
@@ -301,6 +305,10 @@ class CurrentUser(Expression, Func):
     arg_types = {"this": False}
 
 
+class CurrentUserId(Expression, Func):
+    arg_types = {}
+
+
 class CurrentVersion(Expression, Func):
     arg_types = {}
 

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

@@ -1763,14 +1763,15 @@ class Pivot(Expression):
     def fields(self) -> list[Expr]:
         return self.args.get("fields", [])
 
-    def output_columns(self, pre_pivot_columns: t.Iterable[str]) -> list[str]:
+    def output_columns(self, pre_pivot_columns: t.Iterable[str]) -> dict[str, str]:
         """
-        Returns the columns produced by this (UN)PIVOT, in order.
+        Returns an ordered map of post-rename output column name -> pre-rename
+        source-side name, in the order the (UN)PIVOT produces them.
 
-        Example:
+        For callers that just want the names, iterate the dict (or call .keys()):
             >>> from sqlglot import parse_one, exp
             >>> piv = parse_one("SELECT * FROM t UNPIVOT(val FOR name IN (a, b))").find(exp.Pivot)
-            >>> piv.output_columns(["a", "b", "c"])
+            >>> list(piv.output_columns(["a", "b", "c"]))
             ['c', 'name', 'val']
 
         AST shape:
@@ -1813,9 +1814,23 @@ class Pivot(Expression):
                 outputs = [c.alias_or_name for c in self.expressions]
 
         if not excluded or not outputs:
-            return []
+            return {}
+
+        pre_rename = [c for c in pre_pivot_columns if c not in excluded] + outputs
+
+        alias = self.args.get("alias")
+        renames = alias.args.get("columns") if alias else None
+
+        # `PIVOT(...) AS alias(c1, c2, ...)` renames the operator's output columns
+        # positionally from the front (DuckDB, Snowflake): the user's names cover
+        # the leading N output columns, remaining columns keep their auto names.
+        if renames:
+            rename_names = [r.name for r in renames]
+            post_rename = rename_names + pre_rename[len(rename_names) :]
+        else:
+            post_rename = pre_rename
 
-        return [c for c in pre_pivot_columns if c not in excluded] + outputs
+        return dict(zip(post_rename, pre_rename))
 
 
 class UnpivotColumns(Expression):

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

@@ -303,17 +303,13 @@ class FromBase64(Expression, Func):
 
 
 class Hex(Expression, Func):
-    pass
+    arg_types = {"this": True, "case": False}
 
 
 class HexDecodeString(Expression, Func):
     pass
 
 
-class HexEncode(Expression, Func):
-    arg_types = {"this": True, "case": False}
-
-
 class LowerHex(Hex):
     pass
 

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

@@ -446,6 +446,9 @@ class Generator:
     # Whether named columns are allowed in table aliases
     SUPPORTS_TABLE_ALIAS_COLUMNS = True
 
+    # Whether named columns are allowed in CTE definitions
+    SUPPORTS_NAMED_CTE_COLUMNS = True
+
     # Whether UNPIVOT aliases are Identifiers (False means they're Literals)
     UNPIVOT_ALIASES_ARE_IDENTIFIERS = True
 
@@ -467,6 +470,9 @@ class Generator:
     # Whether ALTER TABLE ... MODIFY COLUMN column-redefinition syntax is supported
     SUPPORTS_MODIFY_COLUMN = False
 
+    # Whether ALTER TABLE ... CHANGE COLUMN column-rename-and-redefine syntax is supported
+    SUPPORTS_CHANGE_COLUMN = False
+
     # Whether the LikeProperty needs to be specified inside of the schema clause
     LIKE_PROPERTY_INSIDE_SCHEMA = False
 
@@ -620,6 +626,11 @@ class Generator:
 
     UNSUPPORTED_TYPES: t.ClassVar[set[exp.DType]] = set()
 
+    # mapping of DType to its default parameters, bounds
+    TYPE_PARAM_SETTINGS: t.ClassVar[
+        dict[exp.DType, tuple[tuple[int, ...], tuple[int | None, ...]]]
+    ] = {}
+
     TIME_PART_SINGULARS: t.ClassVar = {
         "MICROSECONDS": "MICROSECOND",
         "SECONDS": "SECOND",
@@ -1526,7 +1537,11 @@ class Generator:
         columns = self.expressions(expression, key="columns", flat=True)
         columns = f"({columns})" if columns else ""
 
-        if columns and not self.SUPPORTS_TABLE_ALIAS_COLUMNS:
+        if (
+            columns
+            and not self.SUPPORTS_TABLE_ALIAS_COLUMNS
+            and not (self.SUPPORTS_NAMED_CTE_COLUMNS and isinstance(expression.parent, exp.CTE))
+        ):
             columns = ""
             self.unsupported("Named columns are not supported in table alias.")
 
@@ -1629,11 +1644,59 @@ class Generator:
         specifier = f" {specifier}" if specifier and self.DATA_TYPE_SPECIFIERS_ALLOWED else ""
         return f"{this}{specifier}"
 
+    def datatype_param_bound_limiter(
+        self,
+        expression: exp.DataType,
+        type_value: exp.DType,
+        defaults: tuple[int, ...],
+        bounds: tuple[int | None, ...],
+    ) -> exp.DataType:
+        params = expression.expressions
+
+        if not params:
+            if defaults:
+                expression.set(
+                    "expressions",
+                    [exp.DataTypeParam(this=exp.Literal.number(d)) for d in defaults],
+                )
+            return expression
+
+        if not bounds:
+            return expression
+
+        for i, param in enumerate(params):
+            bound = bounds[i] if i < len(bounds) else None
+            if bound is None:
+                continue
+
+            param_value = param.this if isinstance(param, exp.DataTypeParam) else param
+            if (
+                isinstance(param_value, exp.Literal)
+                and param_value.is_number
+                and int(param_value.to_py()) > bound
+            ):
+                self.unsupported(
+                    f"{type_value.value} parameter {param_value.name} exceeds "
+                    f"{self.dialect.__class__.__name__}'s maximum of {bound}; capping"
+                )
+                params[i] = exp.DataTypeParam(this=exp.Literal.number(bound))
+
+        return expression
+
     def datatype_sql(self, expression: exp.DataType) -> str:
         nested = ""
         values = ""
 
         expr_nested = expression.args.get("nested")
+        type_value = expression.this
+
+        if (
+            not expr_nested
+            and isinstance(type_value, exp.DType)
+            and (settings := self.TYPE_PARAM_SETTINGS.get(type_value))
+        ):
+            expression = self.datatype_param_bound_limiter(expression, type_value, *settings)
+
         interior = (
             self.expressions(
                 expression, dynamic=True, new_line=True, skip_first=True, skip_last=True
@@ -1642,7 +1705,6 @@ class Generator:
             else self.expressions(expression, flat=True)
         )
 
-        type_value = expression.this
         if type_value in self.UNSUPPORTED_TYPES:
             self.unsupported(
                 f"Data type {type_value.value} is not supported when targeting {self.dialect.__class__.__name__}"
@@ -1679,6 +1741,10 @@ class Generator:
         ):
             type_sql = f"{type_sql} WITH TIME ZONE"
 
+        collate = self.sql(expression, "collate")
+        if collate:
+            type_sql = f"{type_sql} COLLATE {collate}"
+
         return type_sql
 
     def directory_sql(self, expression: exp.Directory) -> str:
@@ -3944,9 +4010,15 @@ class Generator:
         return f"ALTER COLUMN {this} DROP DEFAULT"
 
     def modifycolumn_sql(self, expression: exp.ModifyColumn) -> str:
+        this = self.sql(expression, "this")
+        rename_from = self.sql(expression, "rename_from")
+        if rename_from:
+            if not self.SUPPORTS_CHANGE_COLUMN:
+                self.unsupported("CHANGE COLUMN is not supported in this dialect")
+            return f"CHANGE COLUMN {rename_from} {this}"
         if not self.SUPPORTS_MODIFY_COLUMN:
             self.unsupported("MODIFY COLUMN is not supported in this dialect")
-        return f"MODIFY COLUMN {self.sql(expression, 'this')}"
+        return f"MODIFY COLUMN {this}"
 
     def alterindex_sql(self, expression: exp.AlterIndex) -> str:
         this = self.sql(expression, "this")
@@ -4193,6 +4265,9 @@ class Generator:
             exp_class = exp.ILike
             op = "ILIKE"
 
+        if expression.args.get("negate"):
+            op = f"NOT {op}"
+
         if isinstance(rhs, (exp.All, exp.Any)) and not self.SUPPORTS_LIKE_QUANTIFIERS:
             exprs = rhs.this.unnest()
 
@@ -4204,7 +4279,9 @@ class Generator:
             connective = exp.or_ if isinstance(rhs, exp.Any) else exp.and_
 
             def _make_like(expr: exp.Expression) -> exp.Expression:
-                like: exp.Expression = exp_class(this=this, expression=expr)
+                like: exp.Expression = exp_class(
+                    this=this, expression=expr, negate=expression.args.get("negate")
+                )
                 if escape:
                     like = exp.Escape(this=like, expression=escape.expression.copy())
                 return like

{sqlglotc-30.7.0 → sqlglotc-30.8.0}/sqlglot/generators/bigquery.py

@@ -232,6 +232,7 @@ class BigQueryGenerator(generator.Generator):
     COLLATE_IS_FUNC = True
     LIMIT_ONLY_LITERALS = True
     SUPPORTS_TABLE_ALIAS_COLUMNS = False
+    SUPPORTS_NAMED_CTE_COLUMNS = False
     UNPIVOT_ALIASES_ARE_IDENTIFIERS = False
     JSON_KEY_VALUE_PAIR_SEP = ","
     NULL_ORDERING_SUPPORTED: bool | None = False

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

@@ -1581,6 +1581,7 @@ class DuckDBGenerator(generator.Generator):
             f"CAST(STRFTIME({self.sql(e, 'this')}, {self.dialect.DATEINT_FORMAT}) AS INT)"
         ),
         exp.Decode: lambda self, e: encode_decode_sql(self, e, "DECODE", replace=False),
+        exp.HexDecodeString: lambda self, e: self.sql(exp.Decode(this=exp.Unhex(this=e.this))),
         exp.DiToDate: lambda self, e: (
             f"CAST(STRPTIME(CAST({self.sql(e, 'this')} AS TEXT), {self.dialect.DATEINT_FORMAT}) AS DATE)"
         ),
@@ -1727,7 +1728,7 @@ class DuckDBGenerator(generator.Generator):
         exp.DType.BPCHAR: "TEXT",
         exp.DType.CHAR: "TEXT",
         exp.DType.DATETIME: "TIMESTAMP",
-        exp.DType.DECFLOAT: "DECIMAL(38, 5)",
+        exp.DType.DECFLOAT: "DECIMAL",
         exp.DType.FLOAT: "REAL",
         exp.DType.JSONB: "JSON",
         exp.DType.NCHAR: "TEXT",
@@ -1741,7 +1742,13 @@ class DuckDBGenerator(generator.Generator):
         exp.DType.TIMESTAMP_S: "TIMESTAMP_S",
         exp.DType.TIMESTAMP_MS: "TIMESTAMP_MS",
         exp.DType.TIMESTAMP_NS: "TIMESTAMP_NS",
-        exp.DType.BIGDECIMAL: "DECIMAL(38, 5)",
+        exp.DType.BIGDECIMAL: "DECIMAL",
+    }
+
+    TYPE_PARAM_SETTINGS = {
+        **generator.Generator.TYPE_PARAM_SETTINGS,
+        exp.DType.BIGDECIMAL: ((38, 5), (38, 38)),
+        exp.DType.DECFLOAT: ((38, 5), (38, 38)),
     }
 
     # https://github.com/duckdb/duckdb/blob/ff7f24fd8e3128d94371827523dae85ebaf58713/third_party/libpg_query/grammar/keywords/reserved_keywords.list#L1-L77
@@ -3607,15 +3614,13 @@ class DuckDBGenerator(generator.Generator):
 
         return self.sql(result)
 
-    def hexencode_sql(self, expression: exp.HexEncode) -> str:
-        arg = expression.this
+    def hex_sql(self, expression: exp.Hex) -> str:
         case = expression.args.get("case")
-        hex_expr = exp.Hex(this=arg)
 
         if not case:
-            return self.sql(hex_expr)
+            return self.func("HEX", expression.this)
 
-        # Emit runtime CASE WHEN to handle NULL propagation and case=0 (lowercase) vs case=1 (uppercase)
+        hex_expr = exp.Hex(this=expression.this)
         return self.sql(
             exp.case()
             .when(case.is_(exp.null()), exp.null())

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

@@ -2,9 +2,10 @@ from __future__ import annotations
 
 import typing as t
 
-from sqlglot import exp, generator, transforms
+from sqlglot import exp, generator
 from sqlglot.dialects.dialect import (
     DATE_ADD_OR_SUB,
+    Dialect,
     groupconcat_sql,
     no_last_day_sql,
     rename_func,
@@ -35,10 +36,13 @@ def _date_diff_sql(self: ExasolGenerator, expression: exp.DateDiff | exp.TsOrDsD
 
 
 # https://docs.exasol.com/db/latest/sql/select.htm#:~:text=If%20you%20have,local.x%3E10
-def _add_local_prefix_for_aliases(expression: exp.Expr) -> exp.Expr:
+def _add_local_prefix_for_aliases(expression: exp.Expr, dialect: Dialect) -> exp.Expr:
+    def _key(ident: exp.Identifier) -> str:
+        return dialect.normalize_identifier(ident.copy()).this
+
     if isinstance(expression, exp.Select):
-        aliases: dict[str, bool] = {
-            alias.name: bool(alias.args.get("quoted"))
+        aliases: dict[str, exp.Identifier] = {
+            _key(alias): alias
             for sel in expression.selects
             if isinstance(sel, exp.Alias) and (alias := sel.args.get("alias"))
         }
@@ -53,11 +57,12 @@ def _add_local_prefix_for_aliases(expression: exp.Expr) -> exp.Expr:
         ):
             table_ident.replace(exp.to_identifier(table_ident.name.upper(), quoted=True))
 
-        def prefix_local(node: exp.Expr, visible_aliases: dict[str, bool]) -> exp.Expr:
+        def prefix_local(node: exp.Expr, visible_aliases: dict[str, exp.Identifier]) -> exp.Expr:
             if isinstance(node, exp.Column) and not node.table:
-                if node.name in visible_aliases:
+                alias = visible_aliases.get(_key(node.this))
+                if alias is not None:
                     return exp.Column(
-                        this=exp.to_identifier(node.name, quoted=visible_aliases[node.name]),
+                        this=alias,
                         table=exp.to_identifier("LOCAL", quoted=False),
                     )
             return node
@@ -66,16 +71,15 @@ def _add_local_prefix_for_aliases(expression: exp.Expr) -> exp.Expr:
             if arg := expression.args.get(key):
                 expression.set(key, arg.transform(lambda node: prefix_local(node, aliases)))
 
-        seen_aliases: dict[str, bool] = {}
+        seen_aliases: dict[str, exp.Identifier] = {}
         new_selects: list[exp.Expr] = []
         for sel in expression.selects:
             if isinstance(sel, exp.Alias):
                 inner = sel.this.transform(lambda node: prefix_local(node, seen_aliases))
                 sel.set("this", inner)
 
-                alias_node = sel.args.get("alias")
-
-                seen_aliases[sel.alias] = bool(alias_node and getattr(alias_node, "quoted", False))
+                if alias_node := sel.args.get("alias"):
+                    seen_aliases[_key(alias_node)] = alias_node
                 new_selects.append(sel)
             else:
                 new_selects.append(sel.transform(lambda node: prefix_local(node, seen_aliases)))
@@ -303,6 +307,12 @@ class ExasolGenerator(generator.Generator):
         exp.DType.TIMESTAMPNTZ: "TIMESTAMP",
     }
 
+    def select_sql(self, expression: exp.Select) -> str:
+        processed = _qualify_unscoped_star(expression)
+        processed = _add_local_prefix_for_aliases(processed, self.dialect)
+        processed = _group_by_all(processed)
+        return super().select_sql(t.cast(exp.Select, processed))
+
     def datatype_sql(self, expression: exp.DataType) -> str:
         # Exasol supports a fixed default precision of 3 for TIMESTAMP WITH LOCAL TIME ZONE
         # and does not allow specifying a different custom precision
@@ -390,13 +400,6 @@ class ExasolGenerator(generator.Generator):
         exp.MD5Digest: rename_func("HASHTYPE_MD5"),
         # https://docs.exasol.com/db/latest/sql/create_view.htm
         exp.CommentColumnConstraint: lambda self, e: f"COMMENT IS {self.sql(e, 'this')}",
-        exp.Select: transforms.preprocess(
-            [
-                _qualify_unscoped_star,
-                _add_local_prefix_for_aliases,
-                _group_by_all,
-            ]
-        ),
         exp.SubstringIndex: _substring_index_sql,
         exp.WeekOfYear: rename_func("WEEK"),
         # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/to_date.htm

{sqlglotc-30.7.0 → sqlglotc-30.8.0}/sqlglot/generators/hive.py

@@ -433,17 +433,18 @@ class HiveGenerator(generator.Generator):
         if expression.this in self.PARAMETERIZABLE_TEXT_TYPES and (
             not expression.expressions or expression.expressions[0].name == "MAX"
         ):
-            expression = exp.DType.TEXT.into_expr()
+            expression.set("this", exp.DType.TEXT)
+            expression.set("expressions", None)
         elif expression.is_type(exp.DType.TEXT) and expression.expressions:
             expression.set("this", exp.DType.VARCHAR)
         elif expression.this in exp.DataType.TEMPORAL_TYPES:
-            expression = exp.DataType.build(expression.this)
+            expression.set("expressions", None)
         elif expression.is_type("float"):
             size_expression = expression.find(exp.DataTypeParam)
             if size_expression:
                 size = int(size_expression.name)
-                builder = exp.DType.FLOAT if size <= 32 else exp.DType.DOUBLE
-                expression = builder.into_expr()
+                expression.set("this", exp.DType.FLOAT if size <= 32 else exp.DType.DOUBLE)
+                expression.set("expressions", None)
         return super().datatype_sql(expression)
 
     def version_sql(self, expression: exp.Version) -> str:

{sqlglotc-30.7.0 → sqlglotc-30.8.0}/sqlglot/generators/mysql.py

@@ -112,6 +112,7 @@ class MySQLGenerator(generator.Generator):
     SUPPORTS_UESCAPE = False
     SUPPORTS_DECODE_CASE = False
     SUPPORTS_MODIFY_COLUMN = True
+    SUPPORTS_CHANGE_COLUMN = True
 
     AFTER_HAVING_MODIFIER_TRANSFORMS = generator.AFTER_HAVING_MODIFIER_TRANSFORMS
 

{sqlglotc-30.7.0 → sqlglotc-30.8.0}/sqlglot/generators/postgres.py

@@ -481,6 +481,9 @@ class PostgresGenerator(generator.Generator):
                 return f"{self.expressions(expression, flat=True)}[{values}]"
             return "ARRAY"
 
+        if expression.is_type(exp.DType.ENUM):
+            return f"ENUM ({self.expressions(expression, flat=True)})"
+
         if expression.is_type(exp.DType.DOUBLE, exp.DType.FLOAT) and expression.expressions:
             # Postgres doesn't support precision for REAL and DOUBLE PRECISION types
             return f"FLOAT({self.expressions(expression, flat=True)})"

{sqlglotc-30.7.0 → sqlglotc-30.8.0}/sqlglot/generators/redshift.py

@@ -67,6 +67,7 @@ class RedshiftGenerator(PostgresGenerator):
                 exp.SHA2,
                 exp.Getbit,
                 exp.Round,
+                exp.TryCast,
             }
         },
         exp.ArrayConcat: array_concat_sql("ARRAY_CONCAT"),
@@ -74,6 +75,7 @@ class RedshiftGenerator(PostgresGenerator):
         exp.ConcatWs: concat_ws_to_dpipe_sql,
         exp.ApproxDistinct: lambda self, e: f"APPROXIMATE COUNT(DISTINCT {self.sql(e, 'this')})",
         exp.CurrentTimestamp: lambda self, e: "SYSDATE" if e.args.get("sysdate") else "GETDATE()",
+        exp.CurrentUserId: lambda *_: "CURRENT_USER_ID",
         exp.DateAdd: date_delta_sql("DATEADD"),
         exp.DateDiff: date_delta_sql("DATEDIFF"),
         exp.DistKeyProperty: lambda self, e: self.func("DISTKEY", e.this),
@@ -270,6 +272,34 @@ class RedshiftGenerator(PostgresGenerator):
         "without",
     }
 
+    def stpoint_sql(self, expression: exp.StPoint) -> str:
+        # ST_POINT only accepts 2 args in Redshift; use ST_MAKEPOINT for 3 or 4 args
+        if expression.args.get("z") or expression.args.get("m"):
+            return self.func(
+                "ST_MAKEPOINT",
+                expression.this,
+                expression.expression,
+                expression.args.get("z"),
+                expression.args.get("m"),
+            )
+        return self.func("ST_POINT", expression.this, expression.expression)
+
+    def arraycontains_sql(self, expression: exp.ArrayContains) -> str:
+        return self.func(
+            "ARRAY_CONTAINS",
+            expression.this,
+            expression.expression,
+            expression.args.get("check_null"),
+        )
+
+    def objecttransform_sql(self, expression: exp.ObjectTransform) -> str:
+        this = self.sql(expression, "this")
+        keep = self.expressions(expression, key="keep", flat=True)
+        set_ = self.expressions(expression, key="set_", flat=True)
+        keep_sql = " KEEP " + keep if keep else ""
+        set_sql = " SET " + set_ if set_ else ""
+        return f"OBJECT_TRANSFORM({this}{keep_sql}{set_sql})"
+
     def approxquantile_sql(self, expression: exp.ApproxQuantile) -> str:
         return "APPROXIMATE " + self.sql(
             exp.WithinGroup(

{sqlglotc-30.7.0 → sqlglotc-30.8.0}/sqlglot/generators/singlestore.py

@@ -361,7 +361,12 @@ class SingleStoreGenerator(MySQLGenerator):
         exp.DType.JSONB: "BSON",
         exp.DType.TIMESTAMP: "TIMESTAMP",
         exp.DType.TIMESTAMP_S: "TIMESTAMP",
-        exp.DType.TIMESTAMP_MS: "TIMESTAMP(6)",
+        exp.DType.TIMESTAMP_MS: "TIMESTAMP",
+    }
+
+    TYPE_PARAM_SETTINGS = {
+        **MySQLGenerator.TYPE_PARAM_SETTINGS,
+        exp.DType.TIMESTAMP_MS: ((6,), ()),
     }
 
     # https://docs.singlestore.com/cloud/reference/sql-reference/restricted-keywords/list-of-restricted-keywords/

{sqlglotc-30.7.0 → sqlglotc-30.8.0}/sqlglot/generators/snowflake.py

@@ -559,6 +559,7 @@ class SnowflakeGenerator(generator.Generator):
         exp.MD5Digest: rename_func("MD5_BINARY"),
         exp.MD5NumberLower64: rename_func("MD5_NUMBER_LOWER64"),
         exp.MD5NumberUpper64: rename_func("MD5_NUMBER_UPPER64"),
+        exp.Hex: rename_func("HEX_ENCODE"),
         exp.LowerHex: rename_func("TO_CHAR"),
         exp.Skewness: rename_func("SKEW"),
         exp.StarMap: rename_func("OBJECT_CONSTRUCT"),

{sqlglotc-30.7.0 → sqlglotc-30.8.0}/sqlglot/generators/spark.py

@@ -76,13 +76,19 @@ class SparkGenerator(Spark2Generator):
 
     TYPE_MAPPING = {
         **Spark2Generator.TYPE_MAPPING,
-        exp.DType.MONEY: "DECIMAL(15, 4)",
-        exp.DType.SMALLMONEY: "DECIMAL(6, 4)",
+        exp.DType.MONEY: "DECIMAL",
+        exp.DType.SMALLMONEY: "DECIMAL",
         exp.DType.UUID: "STRING",
         exp.DType.TIMESTAMPLTZ: "TIMESTAMP_LTZ",
         exp.DType.TIMESTAMPNTZ: "TIMESTAMP_NTZ",
     }
 
+    TYPE_PARAM_SETTINGS = {
+        **Spark2Generator.TYPE_PARAM_SETTINGS,
+        exp.DType.MONEY: ((15, 4), ()),
+        exp.DType.SMALLMONEY: ((6, 4), ()),
+    }
+
     TRANSFORMS = {
         k: v
         for k, v in {

{sqlglotc-30.7.0 → sqlglotc-30.8.0}/sqlglot/generators/tsql.py

@@ -234,6 +234,7 @@ class TSQLGenerator(generator.Generator):
         exp.TemporaryProperty: lambda self, e: "",
         exp.TimeStrToTime: _timestrtotime_sql,
         exp.TimeToStr: _format_sql,
+        exp.TimestampAdd: date_delta_sql("DATEADD"),
         exp.Trim: trim_sql,
         exp.TsOrDsAdd: date_delta_sql("DATEADD", cast=True),
         exp.TsOrDsDiff: date_delta_sql("DATEDIFF"),