sqlglotc 30.16.0__tar.gz → 30.18.0__tar.gz

{sqlglotc-30.16.0/sqlglotc.egg-info → sqlglotc-30.18.0}/PKG-INFO

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: sqlglotc
-Version: 30.16.0
+Version: 30.18.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.16.0
+Requires-Dist: sqlglot==30.18.0
 Provides-Extra: dev
 Requires-Dist: setuptools>=61.0; extra == "dev"
 Requires-Dist: setuptools_scm; extra == "dev"
-Requires-Dist: sqlglot-mypy>=2.1.0.post9; extra == "dev"
+Requires-Dist: sqlglot-mypy>=2.3.0.post2; extra == "dev"
 Dynamic: requires-dist

{sqlglotc-30.16.0 → sqlglotc-30.18.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.post9"]
+dev = ["setuptools >= 61.0", "setuptools_scm", "sqlglot-mypy >= 2.3.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 >= 2.1.0.post9",
+    "sqlglot-mypy >= 2.3.0.post2",
     "types-python-dateutil",
     "sqlglot",
 ]

{sqlglotc-30.16.0 → sqlglotc-30.18.0}/sqlglot/executor/table.py

@@ -109,7 +109,7 @@ class RowReader:
             if columns is not None
             else {}
         )
-        self.row = None
+        self.row = ()
 
     def __getitem__(self, column):
         return self.row[self.columns[column]]

{sqlglotc-30.16.0 → sqlglotc-30.18.0}/sqlglot/expressions/builders.py

@@ -495,11 +495,16 @@ def cast(
         target_dialect = Dialect.get_or_raise(dialect)
         type_mapping = target_dialect.generator_class.TYPE_MAPPING
 
-        existing_cast_type: DType = expr.to.this
+        existing_cast_type = expr.to.this
         new_cast_type: DType = data_type.this
-        types_are_equivalent = type_mapping.get(
-            existing_cast_type, existing_cast_type.value
-        ) == type_mapping.get(new_cast_type, new_cast_type.value)
+        # `this` is only a plain type enum for simple types; complex ones such as
+        # INTERVAL nest another expression there, so the equivalence check is skipped.
+        types_are_equivalent = (
+            isinstance(existing_cast_type, DType)
+            and isinstance(new_cast_type, DType)
+            and type_mapping.get(existing_cast_type, existing_cast_type.value)
+            == type_mapping.get(new_cast_type, new_cast_type.value)
+        )
 
         if expr.is_type(data_type) or types_are_equivalent:
             return expr

{sqlglotc-30.16.0 → sqlglotc-30.18.0}/sqlglot/expressions/constraints.py

@@ -41,6 +41,10 @@ class ZeroFillColumnConstraint(ColumnConstraint):
     arg_types = {}
 
 
+class BinaryColumnConstraint(ColumnConstraint):
+    arg_types = {}
+
+
 class PeriodForSystemTimeConstraint(Expression, ColumnConstraintKind):
     arg_types = {"this": True, "expression": True}
 

{sqlglotc-30.16.0 → sqlglotc-30.18.0}/sqlglot/expressions/core.py

@@ -1699,7 +1699,16 @@ class AggFunc(Func):
 
 
 class Column(Expression, Condition):
-    arg_types = {"this": True, "table": False, "db": False, "catalog": False, "join_mark": False}
+    # "shadow" marks a column whose qualifier is shadowed by a projection alias, so it must be
+    # rendered unqualified in dialects where PROJECTION_ALIASES_SHADOW_SOURCE_NAMES is set
+    arg_types = {
+        "this": True,
+        "table": False,
+        "db": False,
+        "catalog": False,
+        "join_mark": False,
+        "shadow": False,
+    }
 
     @property
     def table(self) -> str:

{sqlglotc-30.16.0 → sqlglotc-30.18.0}/sqlglot/expressions/ddl.py

@@ -345,8 +345,8 @@ class MergeTreeTTL(Expression):
 
 class Drop(Expression):
     arg_types = {
-        "this": False,
         "kind": False,
+        "tables": False,
         "expressions": False,
         "exists": False,
         "temporary": False,

{sqlglotc-30.16.0 → sqlglotc-30.18.0}/sqlglot/expressions/json.py

@@ -54,6 +54,10 @@ class JSONBContainsAllTopKeys(Expression, Binary, Predicate, Func):
     pass
 
 
+class JSONBContainsTopKey(Expression, Binary, Predicate, Func):
+    pass
+
+
 class JSONBContainsAnyTopKeys(Expression, Binary, Predicate, Func):
     pass
 

{sqlglotc-30.16.0 → sqlglotc-30.18.0}/sqlglot/expressions/query.py

@@ -624,6 +624,7 @@ class Group(Expression):
     arg_types = {
         "expressions": False,
         "grouping_sets": False,
+        "grouping_sets_as_group_by_element": False,
         "cube": False,
         "rollup": False,
         "totals": False,
@@ -1050,6 +1051,11 @@ class SetOperation(Expression, Query):
     def named_selects(self) -> list[str]:
         expr: Expr = self
         while isinstance(expr, SetOperation):
+            if expr.args.get("by_name"):
+                left = t.cast(Selectable, expr.this.unnest()).named_selects
+                right = t.cast(Selectable, expr.expression.unnest()).named_selects
+                return list(dict.fromkeys(left + right))
+
             expr = expr.this.unnest()
         return _named_selects(expr)
 
@@ -1886,7 +1892,7 @@ class Where(Expression):
 class Analyze(Expression):
     arg_types = {
         "kind": False,
-        "this": False,
+        "tables": False,
         "options": False,
         "mode": False,
         "partition": False,
@@ -2124,7 +2130,23 @@ class CaseStatement(Expression):
 
 
 class WhileBlock(Expression):
-    arg_types = {"this": True, "body": True}
+    arg_types = {"this": True, "body": True, "label": False}
+
+
+class LoopBlock(Expression):
+    arg_types = {"body": True, "label": False}
+
+
+class RepeatBlock(Expression):
+    arg_types = {"body": True, "until": True, "label": False}
+
+
+class Leave(Expression):
+    pass
+
+
+class Iterate(Expression):
+    pass
 
 
 class EndStatement(Expression):

{sqlglotc-30.16.0 → sqlglotc-30.18.0}/sqlglot/expressions/string.py

@@ -478,7 +478,8 @@ class RegexpReplace(Expression, Func):
 
 
 class RegexpSplit(Expression, Func):
-    arg_types = {"this": True, "expression": True, "limit": False}
+    # "mode" is Dremio-specific, appended after "limit" for from_arg_list compat
+    arg_types = {"this": True, "expression": True, "limit": False, "mode": False}
 
 
 class RegexpSubstr(Expression, Func):

{sqlglotc-30.16.0 → sqlglotc-30.18.0}/sqlglot/generator.py

@@ -147,6 +147,7 @@ class Generator:
         exp.AssumeColumnConstraint: lambda self, e: f"ASSUME ({self.sql(e, 'this')})",
         exp.AutoRefreshProperty: lambda self, e: f"AUTO REFRESH {self.sql(e, 'this')}",
         exp.BackupProperty: lambda self, e: f"BACKUP {self.sql(e, 'this')}",
+        exp.BinaryColumnConstraint: lambda *_: "BINARY",
         exp.CaseSpecificColumnConstraint: lambda _, e: (
             f"{'NOT ' if e.args.get('not_') else ''}CASESPECIFIC"
         ),
@@ -206,6 +207,7 @@ class Generator:
         exp.Int64: lambda self, e: self.sql(exp.cast(e.this, exp.DType.BIGINT)),
         exp.JSONBContainsAnyTopKeys: lambda self, e: self.binary(e, "?|"),
         exp.JSONBContainsAllTopKeys: lambda self, e: self.binary(e, "?&"),
+        exp.JSONBContainsTopKey: 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),
@@ -351,6 +353,9 @@ class Generator:
     # The separator for grouping sets and rollups
     GROUPINGS_SEP = ","
 
+    # Whether GROUPING SETS can follow GROUP BY expressions without a comma
+    SUPPORTS_GROUPING_SETS_AS_SUFFIX = False
+
     # The string used for creating an index on a table
     INDEX_ON = "ON"
 
@@ -850,6 +855,16 @@ class Generator:
 
     RESPECT_IGNORE_NULLS_UNSUPPORTED_EXPRESSIONS: t.ClassVar[tuple[type[exp.Expr], ...]] = ()
 
+    MOD_OPERATOR = "%"
+
+    # Infix operators that bind at least as tightly as %, so a Mod on their right side needs parentheses
+    MOD_PAREN_PARENT_TYPES: t.ClassVar[tuple[type[exp.Expr], ...]] = (
+        exp.Mul,
+        exp.Div,
+        exp.IntDiv,
+        exp.Mod,
+    )
+
     SAFE_JSON_PATH_KEY_RE: t.ClassVar = exp.SAFE_IDENTIFIER_RE
 
     SENTINEL_LINE_BREAK = "__SQLGLOT__LB__"
@@ -1151,6 +1166,10 @@ class Generator:
         return f"{default}CHARACTER SET={self.sql(expression, 'this')}"
 
     def column_parts(self, expression: exp.Column) -> str:
+        if expression.args.get("shadow") and self.dialect.PROJECTION_ALIASES_SHADOW_SOURCE_NAMES:
+            # The qualifier would be captured by a colliding projection alias (see qualify_columns)
+            return self.sql(expression, "this")
+
         return ".".join(
             self.sql(part)
             for part in (
@@ -1822,7 +1841,7 @@ class Generator:
         return self.prepend_ctes(expression, f"DELETE{hint}{tables}{expression_sql}")
 
     def drop_sql(self, expression: exp.Drop) -> str:
-        this = self.sql(expression, "this")
+        tables = self.expressions(expression, key="tables", flat=True)
         expressions = self.expressions(expression, flat=True)
         expressions = f" ({expressions})" if expressions else ""
         kind = expression.args["kind"]
@@ -1844,7 +1863,7 @@ class Generator:
         purge = " PURGE" if expression.args.get("purge") else ""
         sync = " SYNC" if expression.args.get("sync") else ""
         force = " FORCE" if expression.args.get("force") else ""
-        return f"DROP{temporary}{materialized}{iceberg} {kind}{concurrently_sql}{exists_sql}{this}{on_cluster}{expressions}{cascade}{restrict}{constraints}{purge}{sync}{force}"
+        return f"DROP{temporary}{materialized}{iceberg} {kind}{concurrently_sql}{exists_sql}{tables}{on_cluster}{expressions}{cascade}{restrict}{constraints}{purge}{sync}{force}"
 
     def set_operation(self, expression: exp.SetOperation) -> str:
         op_type = type(expression)
@@ -2815,7 +2834,18 @@ class Generator:
             and groupings
             and groupings.strip() not in ("WITH CUBE", "WITH ROLLUP")
         ):
-            group_by = f"{group_by}{self.GROUPINGS_SEP}"
+            add_separator = True
+
+            if grouping_sets and not expression.args.get("grouping_sets_as_group_by_element"):
+                if self.SUPPORTS_GROUPING_SETS_AS_SUFFIX:
+                    add_separator = False
+                else:
+                    self.unsupported(
+                        "GROUPING SETS without a comma after GROUP BY expressions is not supported"
+                    )
+
+            if add_separator:
+                group_by = f"{group_by}{self.GROUPINGS_SEP}"
 
         return f"{group_by}{groupings}"
 
@@ -4583,7 +4613,15 @@ class Generator:
         return self.binary(expression, "<=")
 
     def mod_sql(self, expression: exp.Mod) -> str:
-        return self.binary(expression, "%")
+        this = self.sql(expression, "this")
+        expr = self.sql(expression, "expression")
+        sql = f"{this} {self.maybe_comment(self.MOD_OPERATOR, comments=expression.comments)} {expr}"
+
+        parent = expression.parent
+        if isinstance(parent, self.MOD_PAREN_PARENT_TYPES) and parent.expression is expression:
+            return f"({sql})"
+
+        return sql
 
     def mul_sql(self, expression: exp.Mul) -> str:
         return self.binary(expression, "*")
@@ -5031,6 +5069,12 @@ class Generator:
 
         return self.sql(case)
 
+    def nthvalue_sql(self, expression: exp.NthValue) -> str:
+        if expression.args.get("from_first") is False:
+            self.unsupported("NTH_VALUE FROM LAST is not supported")
+
+        return self.function_fallback_sql(expression)
+
     def comprehension_sql(self, expression: exp.Comprehension) -> str:
         this = self.sql(expression, "this")
         expr = self.sql(expression, "expression")
@@ -5391,9 +5435,11 @@ class Generator:
 
         if self.IGNORE_NULLS_IN_FUNC and not expression.meta_get("inline"):
             if self.IGNORE_NULLS_BEFORE_ORDER:
+                from sqlglot.optimizer.scope import find_all_in_scope
+
                 # The first modifier here will be the one closest to the AggFunc's arg
                 mods = sorted(
-                    expression.find_all(exp.HavingMax, exp.Order, exp.Limit),
+                    find_all_in_scope(expression, exp.HavingMax, exp.Order, exp.Limit),
                     key=lambda x: (
                         0
                         if isinstance(x, exp.HavingMax)
@@ -6033,8 +6079,8 @@ class Generator:
         options = f" {options}" if options else ""
         kind = self.sql(expression, "kind")
         kind = f" {kind}" if kind else ""
-        this = self.sql(expression, "this")
-        this = f" {this}" if this else ""
+        tables = self.expressions(expression, key="tables", flat=True)
+        tables = f" {tables}" if tables else ""
         mode = self.sql(expression, "mode")
         mode = f" {mode}" if mode else ""
         properties = self.sql(expression, "properties")
@@ -6043,7 +6089,7 @@ class Generator:
         partition = f" {partition}" if partition else ""
         inner_expression = self.sql(expression, "expression")
         inner_expression = f" {inner_expression}" if inner_expression else ""
-        return f"ANALYZE{options}{kind}{this}{partition}{mode}{inner_expression}{properties}"
+        return f"ANALYZE{options}{kind}{tables}{partition}{mode}{inner_expression}{properties}"
 
     def xmltable_sql(self, expression: exp.XMLTable) -> str:
         this = self.sql(expression, "this")
@@ -6319,6 +6365,22 @@ class Generator:
         self.unsupported("Unsupported While block syntax")
         return ""
 
+    def loopblock_sql(self, expression: exp.LoopBlock) -> str:
+        self.unsupported("Unsupported Loop block syntax")
+        return ""
+
+    def repeatblock_sql(self, expression: exp.RepeatBlock) -> str:
+        self.unsupported("Unsupported Repeat block syntax")
+        return ""
+
+    def leave_sql(self, expression: exp.Leave) -> str:
+        self.unsupported("Unsupported Leave syntax")
+        return ""
+
+    def iterate_sql(self, expression: exp.Iterate) -> str:
+        self.unsupported("Unsupported Iterate syntax")
+        return ""
+
     def execute_sql(self, expression: exp.Execute) -> str:
         self.unsupported("Unsupported Execute syntax")
         return ""

{sqlglotc-30.16.0 → sqlglotc-30.18.0}/sqlglot/generators/clickhouse.py

@@ -372,12 +372,8 @@ class ClickHouseGenerator(generator.Generator):
         exp.SchemaCommentProperty: lambda self, e: self.naked_property(e),
         exp.Stddev: rename_func("stddevSamp"),
         exp.Chr: rename_func("CHAR"),
-        exp.Lag: lambda self, e: self.func(
-            "lagInFrame", e.this, e.args.get("offset"), e.args.get("default")
-        ),
-        exp.Lead: lambda self, e: self.func(
-            "leadInFrame", e.this, e.args.get("offset"), e.args.get("default")
-        ),
+        exp.Lag: rename_func("lag"),
+        exp.Lead: rename_func("lead"),
         exp.Levenshtein: unsupported_args("ins_cost", "del_cost", "sub_cost", "max_dist")(
             rename_func("editDistance")
         ),

{sqlglotc-30.16.0 → sqlglotc-30.18.0}/sqlglot/generators/dremio.py

@@ -70,6 +70,9 @@ class DremioGenerator(generator.Generator):
         exp.DateAdd: _date_delta_sql("DATE_ADD"),
         exp.DateSub: _date_delta_sql("DATE_SUB"),
         exp.GenerateSeries: rename_func("ARRAY_GENERATE_RANGE"),
+        exp.RegexpSplit: lambda self, e: self.func(
+            "REGEXP_SPLIT", e.this, e.expression, e.args.get("mode"), e.args.get("limit")
+        ),
     }
 
     def version_sql(self, expression: exp.Version) -> str:

{sqlglotc-30.16.0 → sqlglotc-30.18.0}/sqlglot/generators/duckdb.py

@@ -10,10 +10,10 @@ from sqlglot.dialects.dialect import (
     DATETIME_DELTA,
     JSON_EXTRACT_TYPE,
     approx_count_distinct_sql,
+    arrow_json_extract_sql,
     array_append_sql,
     array_compact_sql,
     array_concat_sql,
-    arrow_json_extract_sql,
     count_if_to_sum,
     date_delta_to_binary_interval_op,
     datestrtodate_sql,
@@ -2469,13 +2469,6 @@ class DuckDBGenerator(generator.Generator):
 
         return self.sql(result)
 
-    def nthvalue_sql(self, expression: exp.NthValue) -> str:
-        from_first = expression.args.get("from_first", True)
-        if not from_first:
-            self.unsupported("DuckDB's NTH_VALUE doesn't support starting from the end ")
-
-        return self.function_fallback_sql(expression)
-
     def randstr_sql(self, expression: exp.Randstr) -> str:
         """
         Transpile Snowflake's RANDSTR to DuckDB equivalent using deterministic hash-based random.
@@ -4720,9 +4713,14 @@ class DuckDBGenerator(generator.Generator):
 
     def jsonextractscalar_sql(self, expression: exp.JSONExtractScalar) -> str:
         if expression.args.get("scalar_only"):
-            expression = exp.JSONExtractScalar(
+            json_value = exp.JSONExtractScalar(
                 this=rename_func("JSON_VALUE")(self, expression), expression="'$'"
             )
+
+            # `->>` binds looser than most operators, so the wrap logic needs the parent
+            json_value.parent = expression.parent
+            expression = json_value
+
         return _arrow_json_extract_sql(self, expression)
 
     def bitwisenot_sql(self, expression: exp.BitwiseNot) -> str:

{sqlglotc-30.16.0 → sqlglotc-30.18.0}/sqlglot/generators/hive.py

@@ -223,6 +223,7 @@ class HiveGenerator(generator.Generator):
     SELECT_KINDS: tuple[str, ...] = ()
     TRY_SUPPORTED = False
     SUPPORTS_UESCAPE = False
+    SUPPORTS_GROUPING_SETS_AS_SUFFIX = True
     SUPPORTS_DECODE_CASE = False
     LIMIT_FETCH = "LIMIT"
     TABLESAMPLE_WITH_METHOD = False

{sqlglotc-30.16.0 → sqlglotc-30.18.0}/sqlglot/generators/oracle.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
-
 from sqlglot import exp, generator, transforms
 from sqlglot.dialects.dialect import (
     groupconcat_sql,
     no_ilike_sql,
+    nth_value_from_sql,
     rename_func,
     strposition_sql,
     trim_sql,
@@ -77,6 +77,7 @@ class OracleGenerator(generator.Generator):
         exp.LogicalOr: rename_func("MAX"),
         exp.LogicalAnd: rename_func("MIN"),
         exp.Mod: rename_func("MOD"),
+        exp.NthValue: nth_value_from_sql,
         exp.Rand: rename_func("DBMS_RANDOM.VALUE"),
         exp.Select: transforms.preprocess(
             [

{sqlglotc-30.16.0 → sqlglotc-30.18.0}/sqlglot/generators/postgres.py

@@ -7,6 +7,7 @@ from sqlglot.dialects.dialect import (
     DATE_ADD_OR_SUB,
     JSON_EXTRACT_TYPE,
     any_value_to_max_sql,
+    arrow_json_extract_sql,
     array_append_sql,
     array_concat_sql,
     bool_xor_sql,
@@ -189,7 +190,11 @@ def _json_extract_sql(
         if not isinstance(path, (exp.JSONPath, exp.Variadic)) and not ensure_list(
             expression.args.get("expressions")
         ):
-            return self.binary(expression, op)
+            return arrow_json_extract_sql(self, expression, op=op)
+
+        # JSON_EXTRACT_PATH requires a key, so use an empty variadic array for the root path
+        if len(path.expressions) == 1 and isinstance(path.expressions[0], exp.JSONPathRoot):
+            expression.set("expression", exp.Variadic(this=exp.Literal.string("{}")))
 
         if expression.args.get("only_json_types"):
             return json_extract_segments(name, quoted_index=False, op=op)(self, expression)
@@ -347,9 +352,8 @@ class PostgresGenerator(generator.Generator):
         ),
         exp.JSONExtract: _json_extract_sql("JSON_EXTRACT_PATH", "->"),
         exp.JSONExtractScalar: _json_extract_sql("JSON_EXTRACT_PATH_TEXT", "->>"),
-        exp.JSONBExtract: lambda self, e: self.binary(e, "#>"),
-        exp.JSONBExtractScalar: lambda self, e: self.binary(e, "#>>"),
-        exp.JSONBContains: lambda self, e: self.binary(e, "?"),
+        exp.JSONBExtract: lambda self, e: arrow_json_extract_sql(self, e, op="#>"),
+        exp.JSONBExtractScalar: lambda self, e: arrow_json_extract_sql(self, e, op="#>>"),
         exp.ParseJSON: lambda self, e: self.sql(exp.cast(e.this, exp.DType.JSON)),
         exp.JSONPathKey: json_path_key_only_name,
         exp.JSONPathRoot: lambda *_: "",

{sqlglotc-30.16.0 → sqlglotc-30.18.0}/sqlglot/generators/presto.py

@@ -383,7 +383,7 @@ class PrestoGenerator(generator.Generator):
                 transforms.eliminate_window_clause,
                 transforms.eliminate_qualify,
                 transforms.eliminate_distinct_on,
-                transforms.explode_projection_to_unnest(1),
+                transforms.explode_projection_to_unnest(1, unnest_map=True),
                 transforms.eliminate_semi_and_anti_joins,
                 amend_exploded_column_table,
             ]

{sqlglotc-30.16.0 → sqlglotc-30.18.0}/sqlglot/generators/python.py

@@ -43,7 +43,7 @@ def _case_sql(self, expression):
         condition = f"{this} = ({condition})" if this else condition
         chain = f"{true} if {condition} else ({chain})"
 
-    return chain
+    return f"({chain})"
 
 
 def _lambda_sql(self, e: exp.Lambda) -> str:
@@ -58,6 +58,15 @@ def _lambda_sql(self, e: exp.Lambda) -> str:
     return f"lambda {self.expressions(e, flat=True)}: {self.sql(e, 'this')}"
 
 
+def _like_sql(self: generator.Generator, e: exp.Like | exp.ILike) -> str:
+    sql = self.func(e.key, e.this, e.expression)
+
+    if e.args.get("negate"):
+        sql = f"NOT({sql})"
+
+    return sql
+
+
 def _div_sql(self: generator.Generator, e: exp.Div) -> str:
     denominator = self.sql(e, "expression")
 
@@ -66,12 +75,21 @@ def _div_sql(self: generator.Generator, e: exp.Div) -> str:
 
     sql = f"DIV({self.sql(e, 'this')}, {denominator})"
 
-    if e.args.get("typed"):
-        sql = f"int({sql})"
+    if e.args.get("typed") and not (
+        e.this.is_type(*exp.DataType.REAL_TYPES) or e.expression.is_type(*exp.DataType.REAL_TYPES)
+    ):
+        sql = f"INT({sql})"
 
     return sql
 
 
+def _dpipe_sql(self: generator.Generator, e: exp.DPipe) -> str:
+    if e.this.is_type(exp.DataType.Type.ARRAY) or e.expression.is_type(exp.DataType.Type.ARRAY):
+        return self.func("ARRAYCONCAT", e.this, e.expression)
+
+    return self.func("SAFECONCAT" if e.args.get("safe") else "CONCAT", e.this, e.expression)
+
+
 class PythonGenerator(generator.Generator):
     TRANSFORMS = {
         **{klass: _rename for klass in subclasses(exp.__name__, exp.Binary)},
@@ -89,7 +107,9 @@ class PythonGenerator(generator.Generator):
         ),
         exp.Distinct: lambda self, e: f"set({self.sql(e, 'this')})",
         exp.Div: _div_sql,
+        exp.DPipe: _dpipe_sql,
         exp.Extract: lambda self, e: f"EXTRACT('{e.name.lower()}', {self.sql(e, 'expression')})",
+        exp.ILike: _like_sql,
         exp.In: lambda self, e: self.func("IN", e.this, *e.expressions),
         exp.Interval: lambda self, e: f"INTERVAL({self.sql(e.this)}, '{self.sql(e.unit)}')",
         exp.Is: lambda self, e: (
@@ -102,6 +122,7 @@ class PythonGenerator(generator.Generator):
         exp.JSONPathKey: lambda self, e: f"'{self.sql(e.this)}'",
         exp.JSONPathSubscript: lambda self, e: f"'{e.this}'",
         exp.Lambda: _lambda_sql,
+        exp.Like: _like_sql,
         exp.Not: lambda self, e: self.func("NOT", e.this),
         exp.Null: lambda *_: "None",
         exp.Or: lambda self, e: f"OR(lambda: {self.sql(e.left)}, lambda: {self.sql(e.right)})",

{sqlglotc-30.16.0 → sqlglotc-30.18.0}/sqlglot/generators/snowflake.py

@@ -17,6 +17,7 @@ from sqlglot.dialects.dialect import (
     min_or_least,
     no_make_interval_sql,
     no_timestamp_sql,
+    nth_value_from_sql,
     rename_func,
     strposition_sql,
     timestampdiff_sql,
@@ -96,25 +97,6 @@ def _unqualify_pivot_columns(expression: exp.Expr) -> exp.Expr:
     return expression
 
 
-def _flatten_structured_types_unless_iceberg(expression: exp.Expr) -> exp.Expr:
-    assert isinstance(expression, exp.Create)
-
-    def _flatten_structured_type(expression: exp.Expr) -> exp.Expr:
-        if isinstance(expression, exp.DataType) and expression.this in exp.DataType.NESTED_TYPES:
-            expression.set("expressions", None)
-        return expression
-
-    props = expression.args.get("properties")
-    if isinstance(expression.this, exp.Schema) and not (props and props.find(exp.IcebergProperty)):
-        for schema_expression in expression.this.expressions:
-            if isinstance(schema_expression, exp.ColumnDef):
-                column_type = schema_expression.kind
-                if isinstance(column_type, exp.DataType):
-                    column_type.transform(_flatten_structured_type, copy=False)
-
-    return expression
-
-
 def _unnest_generate_date_array(unnest: exp.Unnest) -> None:
     generate_date_array = unnest.expressions[0]
     start = generate_date_array.args.get("start")
@@ -437,7 +419,6 @@ class SnowflakeGenerator(generator.Generator):
         exp.BitwiseNot: rename_func("BITNOT"),
         exp.BitwiseLeftShift: rename_func("BITSHIFTLEFT"),
         exp.BitwiseRightShift: rename_func("BITSHIFTRIGHT"),
-        exp.Create: transforms.preprocess([_flatten_structured_types_unless_iceberg]),
         exp.CurrentTimestamp: lambda self, e: (
             self.func("SYSDATE") if e.args.get("sysdate") else self.function_fallback_sql(e)
         ),
@@ -518,6 +499,7 @@ class SnowflakeGenerator(generator.Generator):
         exp.MakeInterval: no_make_interval_sql,
         exp.Max: max_or_greatest,
         exp.Min: min_or_least,
+        exp.NthValue: nth_value_from_sql,
         exp.ParseJSON: lambda self, e: self.func(
             f"{'TRY_' if e.args.get('safe') else ''}PARSE_JSON", e.this
         ),
@@ -629,19 +611,6 @@ class SnowflakeGenerator(generator.Generator):
             nulls_first = None
         return self.func("ARRAY_SORT", expression.this, asc, nulls_first)
 
-    def nthvalue_sql(self, expression: exp.NthValue) -> str:
-        result = self.func("NTH_VALUE", expression.this, expression.args.get("offset"))
-
-        from_first = expression.args.get("from_first")
-
-        if from_first is not None:
-            if from_first:
-                result = result + " FROM FIRST"
-            else:
-                result = result + " FROM LAST"
-
-        return result
-
     SUPPORTED_JSON_PATH_PARTS = {
         exp.JSONPathKey,
         exp.JSONPathRoot,
@@ -1179,7 +1148,7 @@ class SnowflakeGenerator(generator.Generator):
         # Snowflake doesn't support FILTER (WHERE cond), so we rewrite it into an
         # equivalent conditional aggregation, i.e. wrap the input values in an IFF
         agg = expression.this
-        agg_arg = agg.this
+        agg_arg = seq_get(agg.expressions, 0) if isinstance(agg, exp.Anonymous) else agg.this
         cond = expression.expression.this
 
         if isinstance(agg, exp.WithinGroup):
@@ -1203,7 +1172,7 @@ class SnowflakeGenerator(generator.Generator):
         # `COUNT(*/t.*) FILTER (WHERE cond)` counts qualifying rows, but a star can't be an IFF
         # argument: `IFF(cond, *, NULL)` expands to multiple columns once the table has 2+ of
         # them, which Snowflake rejects. Use its native COUNT_IF instead.
-        if isinstance(agg, exp.Count) and agg_arg.is_star:
+        if isinstance(agg, exp.Count) and isinstance(agg_arg, exp.Expression) and agg_arg.is_star:
             return self.func("COUNT_IF", cond)
 
         # `DISTINCT` and `ORDER BY` are part of the aggregate's own argument list, so the