sqlglotc 30.12.0__tar.gz → 30.14.0__tar.gz

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

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: sqlglotc
-Version: 30.12.0
+Version: 30.14.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.12.0
+Requires-Dist: sqlglot==30.14.0
 Provides-Extra: dev
 Requires-Dist: setuptools>=61.0; extra == "dev"
 Requires-Dist: setuptools_scm; extra == "dev"
-Requires-Dist: sqlglot-mypy>=2.1.0.post3; extra == "dev"
+Requires-Dist: sqlglot-mypy>=2.1.0.post9; extra == "dev"
 Dynamic: requires-dist

{sqlglotc-30.12.0 → sqlglotc-30.14.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.post3"]
+dev = ["setuptools >= 61.0", "setuptools_scm", "sqlglot-mypy >= 2.1.0.post9"]
 
 [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.post3",
+    "sqlglot-mypy >= 2.1.0.post9",
     "types-python-dateutil",
     "sqlglot",
 ]

{sqlglotc-30.12.0 → sqlglotc-30.14.0}/setup.py

@@ -90,6 +90,13 @@ def _source_paths():
 
 
 class build_ext(_build_ext):
+    def finalize_options(self):
+        super().finalize_options()
+        # Compile in parallel by default; builds driven by pip (wheel/sdist installs)
+        # have no way to pass -j. An explicit -j on the command line still wins.
+        if self.parallel is None:
+            self.parallel = os.cpu_count() or 1
+
     def copy_extensions_to_source(self):
         """For editable installs, put sqlglot.* .so files in the sqlglot source dir."""
         for ext in self.extensions:

{sqlglotc-30.12.0 → sqlglotc-30.14.0}/sqlglot/expressions/aggregate.py

@@ -102,6 +102,7 @@ class Count(Expression, AggFunc):
 
 class CountIf(Expression, AggFunc):
     _sql_names = ["COUNT_IF", "COUNTIF"]
+    arg_types = {"this": True, "zero_on_all_null": False}
 
 
 class CovarPop(Expression, AggFunc):
@@ -255,19 +256,19 @@ class RegrAvgy(Expression, AggFunc):
 
 
 class RegrCount(Expression, AggFunc):
-    arg_types = {"this": True, "expression": True}
+    arg_types = {"this": True, "expression": False}
 
 
 class RegrIntercept(Expression, AggFunc):
-    arg_types = {"this": True, "expression": True}
+    arg_types = {"this": True, "expression": False}
 
 
 class RegrR2(Expression, AggFunc):
-    arg_types = {"this": True, "expression": True}
+    arg_types = {"this": True, "expression": False}
 
 
 class RegrSlope(Expression, AggFunc):
-    arg_types = {"this": True, "expression": True}
+    arg_types = {"this": True, "expression": False}
 
 
 class RegrSxx(Expression, AggFunc):

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

@@ -90,6 +90,10 @@ class ArraySort(Expression, Func):
     arg_types = {"this": True, "expression": False}
 
 
+class Shuffle(Expression, Func):
+    pass
+
+
 class SortArray(Expression, Func):
     arg_types = {"this": True, "asc": False, "nulls_first": False}
 

{sqlglotc-30.12.0 → sqlglotc-30.14.0}/sqlglot/expressions/constraints.py

@@ -220,6 +220,11 @@ class PrimaryKey(Expression):
     arg_types = {"this": False, "expressions": True, "options": False, "include": False}
 
 
+# https://docs.databricks.com/aws/en/sql/language-manual/sql-ref-syntax-ddl-create-table-constraint
+class TimeseriesKey(Expression):
+    pass
+
+
 class IndexParameters(Expression):
     arg_types = {
         "using": False,

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

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

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

@@ -432,7 +432,7 @@ class NextValueFor(Expression, Func):
 
 
 class Execute(Expression):
-    arg_types = {"this": True, "expressions": False}
+    arg_types = {"this": True, "expressions": False, "return_status": False}
 
     @property
     def name(self) -> str:

{sqlglotc-30.12.0 → sqlglotc-30.14.0}/sqlglot/expressions/math.py

@@ -164,10 +164,18 @@ class Log(Expression, Func):
     arg_types = {"this": True, "expression": False}
 
 
+class Nanvl(Expression, Func):
+    arg_types = {"this": True, "expression": True}
+
+
 class Pi(Expression, Func):
     arg_types = {}
 
 
+class Rint(Expression, Func):
+    pass
+
+
 class Round(Expression, Func):
     arg_types = {
         "this": True,

{sqlglotc-30.12.0 → sqlglotc-30.14.0}/sqlglot/expressions/string.py

@@ -477,6 +477,17 @@ class RegexpSplit(Expression, Func):
     arg_types = {"this": True, "expression": True, "limit": False}
 
 
+class RegexpSubstr(Expression, Func):
+    arg_types = {
+        "this": True,
+        "expression": True,
+        "position": False,
+        "occurrence": False,
+        "parameters": False,
+        "group": False,
+    }
+
+
 # Hashing / cryptographic
 
 

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

@@ -106,7 +106,7 @@ class DatetimeAdd(Expression, Func, IntervalOp):
 
 
 class DatetimeDiff(Expression, Func, TimeUnit):
-    arg_types = {"this": True, "expression": True, "unit": False}
+    arg_types = {"this": True, "expression": True, "unit": False, "date_part_boundary": False}
 
 
 class DatetimeSub(Expression, Func, IntervalOp):
@@ -441,6 +441,10 @@ class FromISO8601Date(Expression, Func):
     _sql_names = ["FROM_ISO8601_DATE"]
 
 
+class FromISO8601TimestampNanos(Expression, Func):
+    _sql_names = ["FROM_ISO8601_TIMESTAMP_NANOS"]
+
+
 class ParseDatetime(Expression, Func):
     arg_types = {"this": True, "format": False, "zone": False, "default_year": False}
 
@@ -450,11 +454,18 @@ class ParseTime(Expression, Func):
 
 
 class StrToDate(Expression, Func):
-    arg_types = {"this": True, "format": False, "safe": False}
+    arg_types = {"this": True, "format": False, "safe": False, "default_year": False}
 
 
 class StrToTime(Expression, Func):
-    arg_types = {"this": True, "format": True, "zone": False, "safe": False, "target_type": False}
+    arg_types = {
+        "this": True,
+        "format": True,
+        "zone": False,
+        "safe": False,
+        "target_type": False,
+        "default_year": False,
+    }
 
 
 class StrToUnix(Expression, Func):

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

@@ -402,9 +402,6 @@ class Generator:
     # UNNEST WITH ORDINALITY (presto) instead of UNNEST WITH OFFSET (bigquery)
     UNNEST_WITH_ORDINALITY = True
 
-    # Whether FILTER (WHERE cond) can be used for conditional aggregation
-    AGGREGATE_FILTER_SUPPORTED = True
-
     # Whether JOIN sides (LEFT, RIGHT) are supported in conjunction with SEMI/ANTI join kinds
     SEMI_ANTI_JOIN_WITH_SIDE = True
 
@@ -429,6 +426,9 @@ class Generator:
     # The keyword to use when specifying the seed of a sample clause
     TABLESAMPLE_SEED_KEYWORD = "SEED"
 
+    # Whether the historical data clause (AT ... / BEFORE ...) is generated after the table alias
+    HISTORICAL_DATA_POST_ALIAS = False
+
     # Whether COLLATE is a function instead of a binary operator
     COLLATE_IS_FUNC = False
 
@@ -1905,16 +1905,9 @@ class Generator:
         return f"{percent}{rows}{with_ties}"
 
     def filter_sql(self, expression: exp.Filter) -> str:
-        if self.AGGREGATE_FILTER_SUPPORTED:
-            this = self.sql(expression, "this")
-            where = self.sql(expression, "expression").strip()
-            return f"{this} FILTER({where})"
-
-        agg = expression.this
-        agg_arg = agg.this
-        cond = expression.expression.this
-        agg_arg.replace(exp.If(this=cond.copy(), true=agg_arg.copy()))
-        return self.sql(agg)
+        this = self.sql(expression, "this")
+        where = self.sql(expression, "expression").strip()
+        return f"{this} FILTER({where})"
 
     def hint_sql(self, expression: exp.Hint) -> str:
         if not self.QUERY_HINTS:
@@ -2433,7 +2426,10 @@ class Generator:
 
         when = self.sql(expression, "when")
         if when:
-            table = f"{table} {when}"
+            if self.HISTORICAL_DATA_POST_ALIAS:
+                alias = f"{alias} {when}"
+            else:
+                table = f"{table} {when}"
 
         changes = self.sql(expression, "changes")
         changes = f" {changes}" if changes else ""
@@ -3243,7 +3239,12 @@ class Generator:
         limit = expression.args.get("limit")
 
         if self.LIMIT_FETCH == "LIMIT" and isinstance(limit, exp.Fetch):
-            limit = exp.Limit(expression=exp.maybe_copy(limit.args.get("count")))
+            count = limit.args.get("count")
+            # "FETCH FIRST ROWS ONLY" without a count means one row per the SQL
+            # standard; emitting a bare "LIMIT" here would produce invalid SQL.
+            limit = exp.Limit(
+                expression=exp.maybe_copy(count) if count is not None else exp.Literal.number(1)
+            )
         elif self.LIMIT_FETCH == "FETCH" and isinstance(limit, exp.Limit):
             limit = exp.Fetch(direction="FIRST", count=exp.maybe_copy(limit.expression))
 
@@ -3723,6 +3724,10 @@ class Generator:
         options = f" {options}" if options else ""
         return f"PRIMARY KEY{this} ({expressions}){include}{options}"
 
+    def timeserieskey_sql(self, expression: exp.TimeseriesKey) -> str:
+        self.unsupported("TIMESERIES primary key columns are not supported")
+        return self.sql(expression, "this")
+
     def if_sql(self, expression: exp.If) -> str:
         return self.case_sql(exp.Case(ifs=[expression], default=expression.args.get("false")))
 
@@ -4008,6 +4013,9 @@ class Generator:
     def fromiso8601timestamp_sql(self, expression: exp.FromISO8601Timestamp) -> str:
         return self.sql(exp.cast(expression.this, exp.DType.TIMESTAMPTZ))
 
+    def fromiso8601timestampnanos_sql(self, expression: exp.FromISO8601TimestampNanos) -> str:
+        return self.sql(exp.cast(expression.this, exp.DType.TIMESTAMPTZ))
+
     def add_sql(self, expression: exp.Add) -> str:
         return self.binary(expression, "+")
 
@@ -4087,6 +4095,10 @@ class Generator:
     def strtotime_sql(self, expression: exp.StrToTime) -> str:
         return self.func("STR_TO_TIME", expression.this, expression.args.get("format"))
 
+    # Base implementation that excludes the safe and default_year metadata args
+    def strtodate_sql(self, expression: exp.StrToDate) -> str:
+        return self.func("STR_TO_DATE", expression.this, expression.args.get("format"))
+
     def parsedatetime_sql(self, expression: exp.ParseDatetime) -> str:
         return self.func(
             "PARSE_DATETIME",
@@ -4428,11 +4440,11 @@ class Generator:
         return self.binary(expression, ">=")
 
     def is_sql(self, expression: exp.Is) -> str:
+        negate = expression.args.get("negate")
         if not self.IS_BOOL_ALLOWED and isinstance(expression.expression, exp.Boolean):
-            return self.sql(
-                expression.this if expression.expression.this else exp.not_(expression.this)
-            )
-        return self.binary(expression, "IS")
+            positive = bool(expression.expression.this) != bool(negate)
+            return self.sql(expression.this if positive else exp.not_(expression.this))
+        return self.binary(expression, "IS NOT" if negate else "IS")
 
     def _like_sql(
         self,
@@ -5662,7 +5674,11 @@ class Generator:
 
     def arrayagg_sql(self, expression: exp.ArrayAgg) -> str:
         array_agg = self.function_fallback_sql(expression)
-        return self._add_arrayagg_null_filter(array_agg, expression, expression.this)
+        column_expr = expression.this
+        if isinstance(column_expr, exp.Order):
+            column_expr = column_expr.this
+
+        return self._add_arrayagg_null_filter(array_agg, expression, column_expr)
 
     def slice_sql(self, expression: exp.Slice) -> str:
         step = self.sql(expression, "step")

{sqlglotc-30.12.0 → sqlglotc-30.14.0}/sqlglot/generators/bigquery.py

@@ -137,6 +137,34 @@ def _pushdown_cte_column_names(expression: exp.Expr) -> exp.Expr:
     return expression
 
 
+def _unnest_explode_generate_series(expression: exp.Expr) -> exp.Expr:
+    """
+    Rewrites exploding GENERATE_SERIES projections into table references, e.g.
+
+        SELECT GENERATE_SERIES(1, 2) AS x           -> SELECT x FROM GENERATE_SERIES(1, 2) AS x
+        SELECT y, GENERATE_SERIES(1, 2) AS x FROM t -> SELECT y, x FROM t CROSS JOIN GENERATE_SERIES(1, 2) AS x
+
+    since BigQuery can't explode in the projection and must unnest it in the FROM clause instead.
+    The resulting table reference is unnested downstream by `transforms.unnest_generate_series`.
+    """
+    if isinstance(expression, exp.Select):
+        for projection in expression.selects:
+            if isinstance(series := projection.unalias(), exp.ExplodingGenerateSeries):
+                column_name = projection.output_name or "_gen_series_value"
+
+                projection.replace(exp.column(column_name))
+                table = exp.Table(
+                    this=series, alias=exp.TableAlias(this=exp.to_identifier(column_name))
+                )
+
+                if expression.args.get("from_"):
+                    expression.join(table, copy=False, join_type="CROSS")
+                else:
+                    expression.set("from_", exp.From(this=table))
+
+    return expression
+
+
 def _array_contains_sql(self: BigQueryGenerator, expression: exp.ArrayContains) -> str:
     return self.sql(
         exp.Exists(
@@ -358,6 +386,7 @@ class BigQueryGenerator(generator.Generator):
         exp.ParseDatetime: lambda self, e: self.func("PARSE_DATETIME", self.format_time(e), e.this),
         exp.Select: transforms.preprocess(
             [
+                _unnest_explode_generate_series,
                 transforms.explode_projection_to_unnest(),
                 transforms.unqualify_unnest,
                 transforms.eliminate_distinct_on,
@@ -379,6 +408,7 @@ class BigQueryGenerator(generator.Generator):
         exp.StrToDate: _str_to_datetime_sql,
         exp.StrToTime: _str_to_datetime_sql,
         exp.SessionUser: lambda *_: "SESSION_USER()",
+        exp.Table: transforms.preprocess([transforms.unnest_generate_series]),
         exp.TimeAdd: date_add_interval_sql("TIME", "ADD"),
         exp.TimeFromParts: rename_func("TIME"),
         exp.TimestampFromParts: rename_func("DATETIME"),

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

@@ -57,6 +57,9 @@ class DatabricksGenerator(SparkGenerator):
             exp.CurrentCatalog: lambda *_: "CURRENT_CATALOG()",
             exp.RegexpLike: None,
             exp.TryCast: None,
+            exp.RegrAvgx: lambda self, e: self._regr_sql(e),
+            exp.RegrSxx: lambda self, e: self._regr_sql(e),
+            exp.RegrSyy: lambda self, e: self._regr_sql(e),
         }.items()
         if v is not None
     }
@@ -90,6 +93,9 @@ class DatabricksGenerator(SparkGenerator):
 
         return super().columndef_sql(expression, sep)
 
+    def timeserieskey_sql(self, expression: exp.TimeseriesKey) -> str:
+        return f"{self.sql(expression, 'this')} TIMESERIES"
+
     def jsonpath_sql(self, expression: exp.JSONPath) -> str:
         expression.set("escape", None)
         path = super().jsonpath_sql(expression)
@@ -109,6 +115,13 @@ class DatabricksGenerator(SparkGenerator):
 
         return self.func("UNIFORM", expression.this, expression.expression, seed)
 
+    def _regr_sql(self, expression: exp.RegrAvgx | exp.RegrSxx | exp.RegrSyy) -> str:
+        name = expression.sql_name()
+        x = expression.expression
+        if isinstance(x, exp.Distinct):
+            return self.func(name, exp.Distinct(expressions=[expression.this]), *x.expressions)
+        return self.func(name, expression.this, x)
+
     def clusterproperty_sql(self, expression):
         this = self.sql(expression, "this") or f"({self.expressions(expression, flat=True)})"
         return f"CLUSTER BY {this}"

sqlglotc-30.14.0/sqlglot/generators/dax.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from sqlglot import generator
+
+
+class DAXGenerator(generator.Generator):
+    AFTER_HAVING_MODIFIER_TRANSFORMS = generator.AFTER_HAVING_MODIFIER_TRANSFORMS

{sqlglotc-30.12.0 → sqlglotc-30.14.0}/sqlglot/generators/dremio.py

@@ -72,6 +72,14 @@ class DremioGenerator(generator.Generator):
         exp.GenerateSeries: rename_func("ARRAY_GENERATE_RANGE"),
     }
 
+    def version_sql(self, expression: exp.Version) -> str:
+        if expression.text("kind") == "AS OF":
+            this = "SNAPSHOT" if expression.name == "VERSION" else expression.name
+            return f"AT {this} {self.sql(expression, 'expression')}"
+
+        self.unsupported("Range time travel is not supported in Dremio")
+        return super().version_sql(expression)
+
     def datatype_sql(self, expression: exp.DataType) -> str:
         """
         Reject time-zone-aware TIMESTAMPs, which Dremio does not accept

{sqlglotc-30.12.0 → sqlglotc-30.14.0}/sqlglot/generators/drill.py

@@ -29,6 +29,7 @@ class DrillGenerator(generator.Generator):
     TRY_SUPPORTED = False
     SUPPORTS_UESCAPE = False
     SUPPORTS_DECODE_CASE = False
+    SUPPORTS_LIKE_QUANTIFIERS = False
 
     AFTER_HAVING_MODIFIER_TRANSFORMS = generator.AFTER_HAVING_MODIFIER_TRANSFORMS
 
@@ -76,7 +77,6 @@ class DrillGenerator(generator.Generator):
         exp.If: lambda self, e: (
             f"`IF`({self.format_args(e.this, e.args.get('true'), e.args.get('false'))})"
         ),
-        exp.ILike: lambda self, e: self.binary(e, "`ILIKE`"),
         exp.Levenshtein: unsupported_args("ins_cost", "del_cost", "sub_cost", "max_dist")(
             rename_func("LEVENSHTEIN_DISTANCE")
         ),
@@ -104,6 +104,22 @@ class DrillGenerator(generator.Generator):
         ),
     }
 
+    def ilike_sql(self, expression: exp.ILike) -> str:
+        if isinstance(expression.expression, (exp.All, exp.Any)):
+            return super().ilike_sql(expression)
+        return self._ilike_func_sql(expression)
+
+    def escape_sql(self, expression: exp.Escape) -> str:
+        # Drill takes the escape character as ILIKE's third argument instead of an ESCAPE clause
+        this = expression.this
+        if isinstance(this, exp.ILike) and not isinstance(this.expression, (exp.All, exp.Any)):
+            return self._ilike_func_sql(this, expression.expression)
+        return super().escape_sql(expression)
+
+    def _ilike_func_sql(self, expression: exp.ILike, escape: exp.Expr | None = None) -> str:
+        ilike = self.func("ILIKE", expression.this, expression.expression, escape)
+        return f"NOT {ilike}" if expression.args.get("negate") else ilike
+
 
 def _drill_dateint_format() -> str:
     from sqlglot.dialects.drill import Drill