sqlglotc 30.23.0__tar.gz → 30.24.0__tar.gz

{sqlglotc-30.23.0/sqlglotc.egg-info → sqlglotc-30.24.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: sqlglotc
-Version: 30.23.0
+Version: 30.24.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.23.0
+Requires-Dist: sqlglot==30.24.0
 Provides-Extra: dev
 Requires-Dist: setuptools>=61.0; extra == "dev"
 Requires-Dist: setuptools_scm; extra == "dev"

{sqlglotc-30.23.0 → sqlglotc-30.24.0}/setup.py

@@ -90,6 +90,16 @@ def _source_paths():
 
 
 class build_ext(_build_ext):
+    def _remove_obsolete_extensions(self, directory, expected):
+        if self.dry_run:
+            return
+        expected = {os.path.abspath(path) for path in expected}
+        for root, _, files in os.walk(directory):
+            for filename in files:
+                path = os.path.join(root, filename)
+                if filename.endswith((".so", ".pyd")) and os.path.abspath(path) not in expected:
+                    self.execute(os.remove, (path,), f"removing obsolete extension {path}")
+
     def finalize_options(self):
         super().finalize_options()
         # Compile in parallel by default; builds driven by pip (wheel/sdist installs)
@@ -97,8 +107,13 @@ class build_ext(_build_ext):
         if self.parallel is None:
             self.parallel = os.cpu_count() or 1
 
+    def build_extensions(self):
+        self._remove_obsolete_extensions(self.build_lib, self.get_outputs())
+        super().build_extensions()
+
     def copy_extensions_to_source(self):
         """For editable installs, put sqlglot.* .so files in the sqlglot source dir."""
+        expected = []
         for ext in self.extensions:
             fullname = self.get_ext_fullname(ext.name)
             filename = self.get_ext_filename(fullname)
@@ -112,7 +127,9 @@ class build_ext(_build_ext):
                 # Place the mypyc runtime helper (e.g., HASH__mypyc) inside sqlglot/.
                 # sqlglot/__init__.py bootstraps it into sys.modules for editable installs.
                 dst = os.path.join(SQLGLOT_SRC, os.path.basename(filename))
+            expected.append(dst)
             self.copy_file(src, dst, level=self.verbose)
+        self._remove_obsolete_extensions(SQLGLOT_SRC, expected)
 
 
 class sdist(_sdist):

{sqlglotc-30.23.0 → sqlglotc-30.24.0}/sqlglot/expressions/array.py

@@ -98,17 +98,13 @@ class ArraySlice(Expression, Func):
 
 
 class ArraySort(Expression, Func):
-    arg_types = {"this": True, "expression": False}
+    arg_types = {"this": True, "expression": False, "asc": False, "nulls_first": False}
 
 
 class Shuffle(Expression, Func):
     pass
 
 
-class SortArray(Expression, Func):
-    arg_types = {"this": True, "asc": False, "nulls_first": False}
-
-
 # Array predicates / search
 
 

{sqlglotc-30.23.0 → sqlglotc-30.24.0}/sqlglot/expressions/query.py

@@ -1938,6 +1938,10 @@ class WindowSpec(Expression):
     }
 
 
+class PartitionByExcluding(Expression):
+    arg_types = {"expressions": True}
+
+
 class PreWhere(Expression):
     pass
 
@@ -2020,6 +2024,10 @@ class DropPartition(Expression):
     arg_types = {"expressions": True, "exists": False}
 
 
+class ReplaceColumns(Expression):
+    arg_types = {"expressions": True}
+
+
 class ReplacePartition(Expression):
     arg_types = {"expression": True, "source": True}
 

{sqlglotc-30.23.0 → sqlglotc-30.24.0}/sqlglot/generator.py

@@ -2178,6 +2178,7 @@ class Generator:
         property_name = exp.Properties.PROPERTY_TO_NAME.get(property_cls)
         if not property_name:
             self.unsupported(f"Unsupported property {expression.key}")
+            return ""
 
         return f"{property_name}={self.sql(expression, 'this')}"
 
@@ -2319,6 +2320,10 @@ class Generator:
         override = " OVERRIDE" if expression.args.get("override") else ""
         return f"LOCKING {kind}{this}{for_or_in} {lock_type}{override}"
 
+    def lockingstatement_sql(self, expression: exp.LockingStatement) -> str:
+        self.unsupported("LOCKING request modifier is not supported")
+        return self.sql(expression, "expression")
+
     def withdataproperty_sql(self, expression: exp.WithDataProperty) -> str:
         data_sql = f"WITH {'NO ' if expression.args.get('no') else ''}DATA"
         statistics = expression.args.get("statistics")
@@ -2561,6 +2566,10 @@ class Generator:
         expression: exp.TableSample,
         tablesample_keyword: str | None = None,
     ) -> str:
+        if expression.expressions:
+            self.unsupported("Multiple sample sets are not supported")
+            return ""
+
         method = self.sql(expression, "method")
         method = f"{method} " if method and self.TABLESAMPLE_WITH_METHOD else ""
         numerator = self.sql(expression, "bucket_numerator")
@@ -3638,6 +3647,9 @@ class Generator:
         partition = self.expressions(expression, key="partition_by", flat=True)
         return f"PARTITION BY {partition}" if partition else ""
 
+    def partitionbyexcluding_sql(self, expression: exp.PartitionByExcluding) -> str:
+        return f"EXCLUDING {self.expressions(expression, flat=True)}"
+
     def windowspec_sql(self, expression: exp.WindowSpec) -> str:
         kind = self.sql(expression, "kind")
         start = csv(self.sql(expression, "start"), self.sql(expression, "start_side"), sep=" ")
@@ -4517,6 +4529,9 @@ class Generator:
     def addconstraint_sql(self, expression: exp.AddConstraint) -> str:
         return f"ADD {self.expressions(expression, indent=False)}"
 
+    def replacecolumns_sql(self, expression: exp.ReplaceColumns) -> str:
+        return f"REPLACE COLUMNS ({self.expressions(expression, flat=True)})"
+
     def addpartition_sql(self, expression: exp.AddPartition) -> str:
         exists = "IF NOT EXISTS " if expression.args.get("exists") else ""
         location = self.sql(expression, "location")
@@ -4771,14 +4786,22 @@ class Generator:
         sqls: list[str] = []
         stack: list[None | str | exp.Expr] = [expression]
         binary_type = type(expression)
+        is_is = binary_type is exp.Is and op in ("IS", "IS NOT")
+        negate = expression.args.get("negate")
 
         while stack:
             node = stack.pop()
 
-            if type(node) is binary_type:
+            if type(node) is binary_type and (
+                node is expression
+                or (is_is and not isinstance(node.expression, exp.Boolean))
+                or node.args.get("negate") == negate
+            ):
                 op_func = node.args.get("operator")
                 if op_func:
                     op = f"OPERATOR({self.sql(op_func)})"
+                elif is_is:
+                    op = "IS NOT" if node.args.get("negate") else "IS"
 
                 stack.append(node.args.get("expression"))
                 stack.append(f" {self.maybe_comment(op, comments=node.comments)} ")
@@ -6053,6 +6076,13 @@ class Generator:
             exp.TimestampDiff(this=expression.this, expression=start_ts, unit=exp.var("SECONDS"))
         )
 
+    def arraysort_sql(self, expression: exp.ArraySort) -> str:
+        asc = expression.args.get("asc")
+        nulls_first = expression.args.get("nulls_first")
+        if (asc and asc != exp.true()) or (nulls_first and nulls_first != exp.false()):
+            self.unsupported("ARRAY_SORT only sorts ascending with NULLs last")
+        return self.func("ARRAY_SORT", expression.this, expression.expression)
+
     def arraysize_sql(self, expression: exp.ArraySize) -> str:
         dim = expression.expression
 

{sqlglotc-30.23.0 → sqlglotc-30.24.0}/sqlglot/generators/bigquery.py

@@ -3,10 +3,13 @@ from __future__ import annotations
 import logging
 import re
 import typing as t
+from decimal import Decimal
+from fractions import Fraction
 
 from sqlglot import exp, generator, transforms
 from sqlglot.dialects.dialect import (
     arg_max_or_min_no_count,
+    array_sort_order,
     date_add_interval_sql,
     datestrtodate_sql,
     filter_array_using_unnest,
@@ -176,6 +179,90 @@ def _array_contains_sql(self: BigQueryGenerator, expression: exp.ArrayContains)
     )
 
 
+def _widen_decimal(expression: exp.Expr) -> exp.Expr:
+    # NUMERIC holds at most 29 integer and 9 fractional digits, e.g. DECIMAL(38, 0) needs BIGNUMERIC
+    for node in expression.find_all(exp.DataType):
+        if node.is_type(exp.DType.DECIMAL) and node.expressions:
+            precision, *rest = (param.this for param in node.expressions)
+            scale = rest[0] if rest else exp.Literal.number(0)
+            if precision.is_int and scale.is_int:
+                scale_digits = int(scale.name)
+                if int(precision.name) - scale_digits > 29 or scale_digits > 9:
+                    node.set("this", exp.DType.BIGDECIMAL)
+    return expression
+
+
+def _extract_part(part: str) -> t.Callable[[BigQueryGenerator, exp.Func], str]:
+    return lambda self, e: self.sql(exp.func("EXTRACT", exp.var(part), e.this, copy=False))
+
+
+def _day_of_week_iso_sql(self: BigQueryGenerator, expression: exp.DayOfWeekIso) -> str:
+    # DAYOFWEEK is Sunday=1..Saturday=7, ISO is Monday=1..Sunday=7
+    template: exp.Expr = exp.maybe_parse("(MOD(EXTRACT(DAYOFWEEK FROM :this) + 5, 7) + 1)")
+    return self.sql(exp.replace_placeholders(template, this=expression.this))
+
+
+def _array_agg_fold_sql(
+    self: BigQueryGenerator, expression: exp.ArrayDistinct | exp.ArraySort
+) -> str:
+    distinct = False
+    ignore_nulls = False
+    sort: exp.ArraySort | None = None
+    agg: exp.Expr = expression
+    while isinstance(agg, (exp.ArrayDistinct, exp.ArraySort)) and not agg.expression:
+        if isinstance(agg, exp.ArrayDistinct):
+            distinct = True
+            ignore_nulls |= agg.args.get("check_null") is False
+        elif sort is None:
+            sort = agg
+        agg = agg.this
+
+    order = array_sort_order(sort) if sort else None
+
+    # An ARRAY_AGG with its own ORDER BY or LIMIT can't take another
+    if (
+        not isinstance(agg, exp.ArrayAgg)
+        or isinstance(agg.this, (exp.Order, exp.Limit))
+        or (sort is not None and order is None)
+    ):
+        self.unsupported(
+            f"{expression.sql_name()} is only supported on an ARRAY_AGG without ORDER BY or LIMIT and with a literal order"
+        )
+        return self.func(expression.sql_name(), expression.this, expression.expression)
+
+    value = agg.this
+    if isinstance(value, exp.Distinct):
+        distinct, value = True, value.expressions[0]
+
+    folded: exp.Expr = exp.Distinct(expressions=[value]) if distinct else value
+    if order is not None:
+        asc, nulls_first = order
+        keys = [exp.Ordered(this=value.copy(), desc=not asc or None, nulls_first=asc)]
+
+        # Aggregate ORDER BY only puts NULLs first when ascending, so other placements need a key
+        if not ignore_nulls and nulls_first is not None and nulls_first != asc:
+            if distinct:
+                self.unsupported("ARRAY_AGG(DISTINCT) only puts NULLs first when ascending")
+            else:
+                is_null = value.copy().is_(exp.null())
+                keys.insert(
+                    0,
+                    exp.Ordered(
+                        this=is_null, desc=nulls_first or None, nulls_first=not nulls_first
+                    ),
+                )
+        folded = exp.Order(this=folded, expressions=keys)
+    agg.set("this", folded)
+    if ignore_nulls:
+        # All-NULL input yields [], but an empty input still yields NULL.
+        agg = exp.If(
+            this=exp.Count(this=exp.Star()).eq(0),
+            true=exp.null(),
+            false=exp.func("COALESCE", exp.IgnoreNulls(this=agg), exp.array()),
+        )
+    return self.sql(agg)
+
+
 def _ts_or_ds_add_sql(self: BigQueryGenerator, expression: exp.TsOrDsAdd) -> str:
     return date_add_interval_sql("DATE", "ADD")(self, ts_or_ds_add_cast(expression))
 
@@ -311,6 +398,8 @@ class BigQueryGenerator(generator.Generator):
         exp.ArgMin: arg_max_or_min_no_count("MIN_BY"),
         exp.Array: inline_array_unless_query,
         exp.ArrayContains: _array_contains_sql,
+        exp.ArrayDistinct: _array_agg_fold_sql,
+        exp.ArraySort: _array_agg_fold_sql,
         exp.ArrayFilter: filter_array_using_unnest,
         exp.ArrayRemove: filter_array_using_unnest,
         exp.BitwiseAndAgg: rename_func("BIT_AND"),
@@ -318,7 +407,9 @@ class BigQueryGenerator(generator.Generator):
         exp.BitwiseXorAgg: rename_func("BIT_XOR"),
         exp.BitwiseCount: rename_func("BIT_COUNT"),
         exp.ByteLength: rename_func("BYTE_LENGTH"),
-        exp.Cast: transforms.preprocess([transforms.remove_precision_parameterized_types]),
+        exp.Cast: transforms.preprocess(
+            [_widen_decimal, transforms.remove_precision_parameterized_types]
+        ),
         exp.CollateProperty: lambda self, e: (
             f"DEFAULT COLLATE {self.sql(e, 'this')}"
             if e.args.get("default")
@@ -336,6 +427,10 @@ class BigQueryGenerator(generator.Generator):
         exp.DatetimeAdd: date_add_interval_sql("DATETIME", "ADD"),
         exp.DatetimeSub: date_add_interval_sql("DATETIME", "SUB"),
         exp.DateFromUnixDate: rename_func("DATE_FROM_UNIX_DATE"),
+        exp.Day: _extract_part("DAY"),
+        exp.DayOfMonth: _extract_part("DAY"),
+        exp.DayOfWeekIso: _day_of_week_iso_sql,
+        exp.DayOfYear: _extract_part("DAYOFYEAR"),
         exp.Filter: no_filter_sql,
         exp.FromTimeZone: lambda self, e: self.func(
             "DATETIME", self.func("TIMESTAMP", e.this, e.args.get("zone")), "'UTC'"
@@ -346,6 +441,7 @@ class BigQueryGenerator(generator.Generator):
         ),
         exp.Hex: lambda self, e: self.func("UPPER", self.func("TO_HEX", self.sql(e, "this"))),
         exp.HexString: lambda self, e: self.hexstring_sql(e, binary_function_repr="FROM_HEX"),
+        exp.Hour: _extract_part("HOUR"),
         exp.If: if_sql(false_value="NULL"),
         exp.ILike: no_ilike_sql,
         exp.IntDiv: rename_func("DIV"),
@@ -366,12 +462,14 @@ class BigQueryGenerator(generator.Generator):
         exp.MD5: lambda self, e: self.func("TO_HEX", self.func("MD5", e.this)),
         exp.MD5Digest: rename_func("MD5"),
         exp.Min: min_or_least,
+        exp.Month: _extract_part("MONTH"),
         exp.Normalize: lambda self, e: self.func(
             "NORMALIZE_AND_CASEFOLD" if e.args.get("is_casefold") else "NORMALIZE",
             e.this,
             e.args.get("form"),
         ),
         exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
+        exp.Quarter: _extract_part("QUARTER"),
         exp.RegexpExtract: lambda self, e: self.func(
             "REGEXP_EXTRACT",
             e.this,
@@ -431,6 +529,8 @@ class BigQueryGenerator(generator.Generator):
         exp.Uuid: lambda *_: "GENERATE_UUID()",
         exp.Values: _derived_table_values_to_unnest,
         exp.VariancePop: rename_func("VAR_POP"),
+        exp.WeekOfYear: _extract_part("ISOWEEK"),
+        exp.Year: _extract_part("YEAR"),
         exp.SafeDivide: rename_func("SAFE_DIVIDE"),
     }
 
@@ -582,6 +682,47 @@ class BigQueryGenerator(generator.Generator):
         "within",
     }
 
+    def frombase_sql(self, expression: exp.FromBase) -> str:
+        # Hex is the only base BigQuery can cast from, and the sign goes before the prefix, e.g. -0xff
+        if expression.expression.name != "16":
+            self.unsupported("FROM_BASE is only supported for base 16")
+            return self.function_fallback_sql(expression)
+
+        prefixed = exp.func(
+            "REGEXP_REPLACE",
+            expression.this,
+            exp.Literal.string("^([+-]?)"),
+            exp.Literal.string("\\10x"),
+            copy=False,
+        )
+        return self.sql(exp.cast(prefixed, exp.DType.BIGINT, copy=False))
+
+    def approxquantile_sql(self, expression: exp.ApproxQuantile) -> str:
+        node: exp.Expr = expression
+        while node.parent and not isinstance(node.parent, (exp.Window, exp.AggFunc, exp.Select)):
+            node = node.parent
+        if isinstance(node.parent, exp.Window) and node.arg_key == "this":
+            self.unsupported("APPROX_QUANTILES does not support window functions")
+            return self.function_fallback_sql(expression)
+
+        # The k/n quantile is APPROX_QUANTILES(x, n)[k], e.g. 0.95 -> n = 20, k = 19. n is at most
+        # 100,000, so the quantile has at most 5 decimal places, and Decimal comparisons are exact
+        quantile = expression.args["quantile"]
+        weight = expression.args.get("weight")
+        value = Decimal(quantile.to_py()) if quantile.is_number else None
+        if (
+            value is None
+            or not 0 <= value <= 1
+            or round(value, 5) != value
+            or (weight and (not weight.is_number or weight.to_py() != 1))
+        ):
+            self.unsupported("APPROX_QUANTILE needs a literal quantile and no weight")
+            return self.function_fallback_sql(expression)
+
+        fraction = Fraction(value)
+        quantiles = exp.func("APPROX_QUANTILES", expression.this, fraction.denominator, copy=False)
+        return self.sql(quantiles[fraction.numerator])
+
     def weekstart_sql(self, expression: exp.WeekStart) -> str:
         if expression.this.name.upper() == "SUNDAY":
             # BigQuery specific optimization since WEEK(SUNDAY) == WEEK

{sqlglotc-30.23.0 → sqlglotc-30.24.0}/sqlglot/generators/clickhouse.py

@@ -688,7 +688,8 @@ class ClickHouseGenerator(generator.Generator):
             comment_prop = expression.find(exp.SchemaCommentProperty)
             if comment_prop:
                 comment_prop.pop()
-                query.replace(exp.paren(query))
+                if not isinstance(query, exp.Subquery):
+                    query.replace(exp.paren(query))
         else:
             comment_prop = None
 

{sqlglotc-30.23.0 → sqlglotc-30.24.0}/sqlglot/generators/duckdb.py

@@ -7,6 +7,7 @@ import typing as t
 
 from sqlglot import exp, generator, transforms
 from sqlglot.dialects.dialect import (
+    array_sort_order,
     DATETIME_DELTA,
     JSON_EXTRACT_TYPE,
     approx_count_distinct_sql,
@@ -548,9 +549,22 @@ def _array_remove_at_sql(self: DuckDBGenerator, expression: exp.ArrayRemoveAt) -
     )
 
 
-@unsupported_args(("expression", "DuckDB's ARRAY_SORT does not support a comparator."))
+@unsupported_args(("expression", "DuckDB's LIST_SORT does not support a comparator."))
 def _array_sort_sql(self: DuckDBGenerator, expression: exp.ArraySort) -> str:
-    return self.func("ARRAY_SORT", expression.this)
+    order = array_sort_order(expression)
+    if order is None:
+        self.unsupported("LIST_SORT only takes literal orders")
+        return self.func("LIST_SORT", expression.this)
+
+    asc, nulls_first = order
+    if not nulls_first:
+        return self.func("LIST_SORT" if asc else "ARRAY_REVERSE_SORT", expression.this)
+    return self.func(
+        "LIST_SORT",
+        expression.this,
+        exp.Literal.string("ASC" if asc else "DESC"),
+        exp.Literal.string("NULLS FIRST"),
+    )
 
 
 def _array_contains_sql(self: DuckDBGenerator, expression: exp.ArrayContains) -> str:
@@ -1858,16 +1872,16 @@ class DuckDBGenerator(generator.Generator):
         "union",
         "all",
         "when",
-        "in_p",
+        "in",
         "default",
-        "create_p",
+        "create",
         "window",
         "asymmetric",
         "to",
         "else",
         "localtime",
         "from",
-        "end_p",
+        "end",
         "select",
         "current_date",
         "foreign",
@@ -1879,7 +1893,7 @@ class DuckDBGenerator(generator.Generator):
         "references",
         "fetch",
         "limit",
-        "group_p",
+        "group",
         "leading",
         "into",
         "collate",
@@ -1887,13 +1901,13 @@ class DuckDBGenerator(generator.Generator):
         "do",
         "then",
         "localtimestamp",
-        "check_p",
-        "lateral_p",
+        "check",
+        "lateral",
         "current_role",
         "where",
-        "asc_p",
+        "asc",
         "placing",
-        "desc_p",
+        "desc",
         "user",
         "unique",
         "initially",
@@ -1904,9 +1918,9 @@ class DuckDBGenerator(generator.Generator):
         "any",
         "only",
         "deferrable",
-        "null_p",
+        "null",
         "current_time",
-        "true_p",
+        "true",
         "table",
         "case",
         "trailing",
@@ -1914,7 +1928,7 @@ class DuckDBGenerator(generator.Generator):
         "for",
         "on",
         "distinct",
-        "false_p",
+        "false",
         "not",
         "constraint",
         "current_timestamp",
@@ -1930,6 +1944,15 @@ class DuckDBGenerator(generator.Generator):
         "using",
         "order",
         "current_catalog",
+        "describe",
+        "lambda",
+        "pivot",
+        "pivot_longer",
+        "pivot_wider",
+        "qualify",
+        "show",
+        "summarize",
+        "unpivot",
     }
 
     UNWRAPPED_INTERVAL_VALUES = (exp.Literal, exp.Paren)
@@ -2674,33 +2697,6 @@ class DuckDBGenerator(generator.Generator):
         self.unsupported("SOUNDEX is not supported in DuckDB")
         return self.func("SOUNDEX", expression.this)
 
-    def sortarray_sql(self, expression: exp.SortArray) -> str:
-        arr = expression.this
-        asc = expression.args.get("asc")
-        nulls_first = expression.args.get("nulls_first")
-
-        if not isinstance(asc, exp.Boolean) and not isinstance(nulls_first, exp.Boolean):
-            return self.func("LIST_SORT", arr, asc, nulls_first)
-
-        nulls_are_first = nulls_first == exp.true()
-        nulls_first_sql = exp.Literal.string("NULLS FIRST") if nulls_are_first else None
-
-        if not isinstance(asc, exp.Boolean):
-            return self.func("LIST_SORT", arr, asc, nulls_first_sql)
-
-        descending = asc == exp.false()
-
-        if not descending and not nulls_are_first:
-            return self.func("LIST_SORT", arr)
-        if not nulls_are_first:
-            return self.func("ARRAY_REVERSE_SORT", arr)
-        return self.func(
-            "LIST_SORT",
-            arr,
-            exp.Literal.string("DESC" if descending else "ASC"),
-            exp.Literal.string("NULLS FIRST"),
-        )
-
     def install_sql(self, expression: exp.Install) -> str:
         force = "FORCE " if expression.args.get("force") else ""
         this = self.sql(expression, "this")

{sqlglotc-30.23.0 → sqlglotc-30.24.0}/sqlglot/generators/fabric.py

@@ -121,6 +121,11 @@ class FabricGenerator(TSQLGenerator):
             # Generate the AT TIME ZONE expression (which will handle the inner cast conversion)
             at_time_zone_sql = super().attimezone_sql(expression)
 
+            # Don't wrap again if it's already cast to DATETIME2, e.g. when re-parsing our own output
+            parent = expression.parent
+            if isinstance(parent, exp.Cast) and parent.to.is_type(exp.DType.DATETIME2):
+                return at_time_zone_sql
+
             # Wrap it in an outer cast to DATETIME2
             return f"CAST({at_time_zone_sql} AS DATETIME2({precision}))"
 

{sqlglotc-30.23.0 → sqlglotc-30.24.0}/sqlglot/generators/hive.py

@@ -6,6 +6,7 @@ from functools import partial
 
 from sqlglot import exp, generator, transforms
 from sqlglot.dialects.dialect import (
+    array_sort_order,
     DATE_ADD_OR_SUB,
     approx_count_distinct_sql,
     arg_max_or_min_no_count,
@@ -162,6 +163,9 @@ def _date_diff_sql(self: HiveGenerator, expression: exp.DateDiff | exp.TsOrDsDif
 
 @generator.unsupported_args(("expression", "Hive's SORT_ARRAY does not support a comparator."))
 def _array_sort_sql(self: HiveGenerator, expression: exp.ArraySort) -> str:
+    asc, nulls_first = array_sort_order(expression) or (False, False)
+    if not asc or nulls_first is False:
+        self.unsupported("Hive's SORT_ARRAY only sorts ascending with NULLs first")
     return self.func("SORT_ARRAY", expression.this)
 
 

{sqlglotc-30.23.0 → sqlglotc-30.24.0}/sqlglot/generators/mysql.py

@@ -195,6 +195,7 @@ class MySQLGenerator(generator.Generator):
                 transforms.unnest_generate_date_array_using_recursive_cte,
             ]
         ),
+        exp.Stddev: rename_func("STDDEV_SAMP"),
         exp.StrPosition: lambda self, e: strposition_sql(
             self, e, func_name="LOCATE", supports_position=True
         ),
@@ -228,6 +229,8 @@ class MySQLGenerator(generator.Generator):
         exp.TsOrDsToDate: _ts_or_ds_to_date_sql,
         exp.Unicode: lambda self, e: f"ORD(CONVERT({self.sql(e.this)} USING utf32))",
         exp.UnixToTime: _unix_to_time_sql,
+        exp.Variance: rename_func("VAR_SAMP"),
+        exp.VariancePop: rename_func("VAR_POP"),
         exp.Week: remove_ts_or_ds_to_date(),
         exp.WeekOfYear: remove_ts_or_ds_to_date(rename_func("WEEKOFYEAR")),
         exp.Year: remove_ts_or_ds_to_date(),

{sqlglotc-30.23.0 → sqlglotc-30.24.0}/sqlglot/generators/postgres.py

@@ -40,7 +40,7 @@ from sqlglot.dialects.dialect import (
     ts_or_ds_add_cast,
 )
 from sqlglot.generator import unsupported_args
-from sqlglot.helper import ensure_list, seq_get
+from sqlglot.helper import ensure_list, seq_get, to_int
 
 
 DATE_DIFF_FACTOR = {
@@ -579,8 +579,13 @@ class PostgresGenerator(generator.Generator):
 
         this = expression.this
         if unit.startswith("quarter") and isinstance(this, exp.Literal):
-            this.replace(exp.Literal.string(int(this.to_py()) * 3))
-            expression.args["unit"].replace(exp.var("MONTH"))
+            # Postgres has no QUARTER unit and no exponents in interval strings
+            quarters = to_int(this.to_py())
+            if quarters is None:
+                self.unsupported("Postgres intervals need a whole number of quarters")
+            else:
+                this.replace(exp.Literal.string(quarters * 3))
+                expression.args["unit"].replace(exp.var("MONTH"))
 
         return super().interval_sql(expression)