sqlglotc 30.18.0__tar.gz → 30.19.0__tar.gz

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

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

{sqlglotc-30.18.0 → sqlglotc-30.19.0}/sqlglot/expressions/aggregate.py

@@ -5,6 +5,12 @@ from __future__ import annotations
 from sqlglot.expressions.core import Expression, Func, AggFunc, Binary
 
 
+class Agg(Expression, AggFunc):
+    @property
+    def output_name(self) -> str:
+        return self.this.name
+
+
 class AIAgg(Expression, AggFunc):
     arg_types = {"this": True, "expression": True}
     _sql_names = ["AI_AGG"]

{sqlglotc-30.18.0 → sqlglotc-30.19.0}/sqlglot/expressions/array.py

@@ -240,10 +240,15 @@ class Explode(Expression, Func, UDTF):
     is_var_len_args = True
 
 
-class Inline(Expression, Func):
+class Inline(Expression, Func, UDTF):
     pass
 
 
+class Stack(Expression, Func, UDTF):
+    arg_types = {"this": True, "expressions": True}
+    is_var_len_args = True
+
+
 @trait
 class ExplodeOuter(Expr):
     pass

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

@@ -1828,6 +1828,10 @@ class Identifier(Expression):
 class DynamicIdentifier(Expression, Func):
     arg_types = {"this": True, "expressions": False}
 
+    @property
+    def name(self) -> str:
+        return self.this.name if self.this else ""
+
 
 class Opclass(Expression):
     arg_types = {"this": True, "expression": True}

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

@@ -240,6 +240,10 @@ class OpenJSON(Expression, Func):
     arg_types = {"this": True, "path": False, "expressions": False}
 
 
+class FromJson(Expression, Func):
+    arg_types = {"this": True, "expression": True, "options": False}
+
+
 class ParseJSON(Expression, Func):
     # BigQuery, Snowflake have PARSE_JSON, Presto has JSON_PARSE
     # Snowflake also has TRY_PARSE_JSON, which is represented using `safe`

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

@@ -12,6 +12,7 @@ from sqlglot.expressions.core import (
     Condition,
     Distinct,
     Dot,
+    DynamicIdentifier,
     Expr,
     Expression,
     Func,
@@ -624,7 +625,6 @@ class Group(Expression):
     arg_types = {
         "expressions": False,
         "grouping_sets": False,
-        "grouping_sets_as_group_by_element": False,
         "cube": False,
         "rollup": False,
         "totals": False,
@@ -967,9 +967,10 @@ class Table(Expression, Selectable):
 
     @property
     def name(self) -> str:
-        if not self.this or isinstance(self.this, Func):
+        this = self.this
+        if not this or (isinstance(this, Func) and not isinstance(this, DynamicIdentifier)):
             return ""
-        return self.this.name
+        return this.name
 
     @property
     def db(self) -> str:
@@ -1019,6 +1020,20 @@ class Table(Expression, Selectable):
         return col
 
 
+def _is_star(expression: Expr) -> bool:
+    stack = [expression]
+    while stack:
+        node = stack.pop()
+        if isinstance(node, SetOperation):
+            stack.append(node.this)
+            stack.append(node.expression)
+        elif isinstance(node, Subquery):
+            stack.append(node.this)
+        elif node.is_star:
+            return True
+    return False
+
+
 class SetOperation(Expression, Query):
     arg_types = {
         "with_": False,
@@ -1061,7 +1076,7 @@ class SetOperation(Expression, Query):
 
     @property
     def is_star(self) -> bool:
-        return self.this.is_star or self.expression.is_star
+        return _is_star(self)
 
     @property
     def selects(self) -> list[Expr]:
@@ -1719,7 +1734,7 @@ class Subquery(Expression, DerivedTable, Query):
 
     @property
     def is_star(self) -> bool:
-        return self.this.is_star
+        return _is_star(self)
 
     @property
     def output_name(self) -> str:

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

@@ -32,6 +32,7 @@ class Concat(Expression, Func):
 
 
 class ConcatWs(Concat):
+    arg_types = {**Concat.arg_types, "flatten": False}
     _sql_names = ["CONCAT_WS"]
 
 

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

@@ -535,6 +535,12 @@ class Generator:
     # True means limit 1 happens after the set op, False means it it happens on y.
     SET_OP_MODIFIERS = True
 
+    # Whether a SELECT operand can have a branch-local LIMIT/TOP without parentheses.
+    SET_OP_LIMITS = False
+
+    # Whether set operation operands can be parenthesized without a SELECT wrapper.
+    SET_OP_PARENTHESIZED_OPERANDS = True
+
     # Whether parameters from COPY statement are wrapped in parentheses
     COPY_PARAMS_ARE_WRAPPED = True
 
@@ -1902,16 +1908,16 @@ class Generator:
         if not self.SET_OP_MODIFIERS:
             limit = expression.args.get("limit")
             order = expression.args.get("order")
+            offset = expression.args.get("offset")
 
-            if limit or order:
+            if limit or order or offset:
                 select = self._move_ctes_to_top_level(
                     exp.subquery(expression, "_l_0", copy=False).select("*", copy=False)
                 )
 
-                if limit:
-                    select = select.limit(limit.pop(), copy=False)
-                if order:
-                    select = select.order_by(order.pop(), copy=False)
+                for arg in ("limit", "order", "offset"):
+                    if value := expression.args.get(arg):
+                        select.set(arg, value.pop())
                 return self.sql(select)
 
         sqls: list[str] = []
@@ -1929,6 +1935,14 @@ class Generator:
                 )
                 stack.append(node.this)
             else:
+                if (
+                    not self.SET_OP_LIMITS
+                    and isinstance(node, exp.Select)
+                    and node.args.get("limit")
+                ):
+                    node = node.subquery(copy=False)
+                    if not self.SET_OP_PARENTHESIZED_OPERANDS:
+                        node = exp.select("*").from_(node, copy=False)
                 sqls.append(self.sql(node))
 
         this = self.sep().join(sqls)
@@ -2836,7 +2850,7 @@ class Generator:
         ):
             add_separator = True
 
-            if grouping_sets and not expression.args.get("grouping_sets_as_group_by_element"):
+            if grouping_sets:
                 if self.SUPPORTS_GROUPING_SETS_AS_SUFFIX:
                     add_separator = False
                 else:
@@ -3324,8 +3338,8 @@ class Generator:
             self.sql(expression, "order"),
             *self.offset_limit_modifiers(expression, isinstance(limit, exp.Fetch), limit),
             *self.after_limit_modifiers(expression),
-            self.options_modifier(expression),
             self.sql(expression, "for_"),
+            self.options_modifier(expression),
             sep="",
         )
 
@@ -3822,6 +3836,7 @@ class Generator:
         path = self.expressions(expression, sep="", flat=True).lstrip(".")
 
         if self.QUOTE_JSON_PATH:
+            path = self.escape_str(path)
             path = f"{self.dialect.QUOTE_START}{path}{self.dialect.QUOTE_END}"
 
         return path
@@ -3840,7 +3855,7 @@ class Generator:
 
         if self._quote_json_path_key_using_brackets and self.JSON_PATH_SINGLE_QUOTE_ESCAPE:
             escaped = expression.replace("'", "\\'")
-            escaped = f"\\'{expression}\\'"
+            escaped = f"'{escaped}'"
         else:
             escaped = expression.replace('"', '\\"')
             escaped = f'"{escaped}"'
@@ -5401,12 +5416,6 @@ class Generator:
 
         this = self.json_path_part(this)
 
-        if quoted and self.QUOTE_JSON_PATH:
-            # The whole path is rendered as a single quoted string literal, so the bracketed key
-            # (which may itself contain backslash-escaped quotes, e.g. ["x \"y\"z"]) must be
-            # escaped again for the outer string literal (-> ["x \\"y\\"z"]).
-            this = self.escape_str(this)
-
         return (
             f"[{this}]"
             if self._quote_json_path_key_using_brackets and self.JSON_PATH_BRACKETED_KEY_SUPPORTED

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

@@ -186,6 +186,7 @@ class ClickHouseGenerator(generator.Generator):
     TABLE_HINTS = False
     GROUPINGS_SEP = ""
     SET_OP_MODIFIERS = False
+    SET_OP_LIMITS = True
     ARRAY_SIZE_NAME = "LENGTH"
     WRAP_DERIVED_VALUES = False
     AUTO_REFRESH_BARE_INTERVALS = True
@@ -445,6 +446,15 @@ class ClickHouseGenerator(generator.Generator):
 
         return self.func("groupConcat", this)
 
+    def select_sql(self, expression: exp.Select) -> str:
+        limit = expression.args.get("limit")
+        if isinstance(limit, exp.Fetch) and not expression.args.get("order"):
+            count = limit.args.get("count")
+            expression.set(
+                "limit", exp.Limit(expression=count if count is not None else exp.Literal.number(1))
+            )
+        return super().select_sql(expression)
+
     def offset_sql(self, expression: exp.Offset) -> str:
         offset = super().offset_sql(expression)
 

{sqlglotc-30.18.0 → sqlglotc-30.19.0}/sqlglot/generators/databricks.py

@@ -97,10 +97,10 @@ class DatabricksGenerator(SparkGenerator):
         return f"{self.sql(expression, 'this')} TIMESERIES"
 
     def jsonpath_sql(self, expression: exp.JSONPath) -> str:
-        expression.set("escape", None)
         path = super().jsonpath_sql(expression)
 
         if isinstance(expression.parent, exp.JSONExtractScalar):
+            path = self.escape_str(path)
             return f"{self.dialect.QUOTE_START}{path}{self.dialect.QUOTE_END}"
 
         return path

{sqlglotc-30.18.0 → sqlglotc-30.19.0}/sqlglot/generators/doris.py

@@ -104,6 +104,7 @@ class DorisGenerator(MySQLGenerator):
         "alter",
         "analyze",
         "analyzed",
+        "analyzer",
         "and",
         "anti",
         "append",
@@ -111,6 +112,7 @@ class DorisGenerator(MySQLGenerator):
         "array_range",
         "as",
         "asc",
+        "asof",
         "at",
         "authors",
         "auto",
@@ -132,6 +134,7 @@ class DorisGenerator(MySQLGenerator):
         "bitxor",
         "blob",
         "boolean",
+        "both",
         "brief",
         "broker",
         "buckets",
@@ -148,6 +151,7 @@ class DorisGenerator(MySQLGenerator):
         "catalogs",
         "chain",
         "char",
+        "char_filter",
         "character",
         "charset",
         "check",
@@ -227,6 +231,7 @@ class DorisGenerator(MySQLGenerator):
         "drop",
         "dropp",
         "dual",
+        "dump",
         "duplicate",
         "dynamic",
         "else",
@@ -329,8 +334,10 @@ class DorisGenerator(MySQLGenerator):
         "largeint",
         "last",
         "lateral",
+        "layout",
         "ldap",
         "ldap_admin_password",
+        "leading",
         "left",
         "less",
         "level",
@@ -352,6 +359,7 @@ class DorisGenerator(MySQLGenerator):
         "match",
         "match_all",
         "match_any",
+        "match_condition",
         "match_phrase",
         "match_phrase_edge",
         "match_phrase_prefix",
@@ -377,6 +385,7 @@ class DorisGenerator(MySQLGenerator):
         "next",
         "ngram_bf",
         "no",
+        "no_use_mv",
         "non_nullable",
         "not",
         "null",
@@ -410,6 +419,7 @@ class DorisGenerator(MySQLGenerator):
         "permissive",
         "physical",
         "plan",
+        "play",
         "process",
         "plugin",
         "plugins",
@@ -520,6 +530,9 @@ class DorisGenerator(MySQLGenerator):
         "timestampdiff",
         "tinyint",
         "to",
+        "token_filter",
+        "tokenizer",
+        "trailing",
         "transaction",
         "trash",
         "tree",
@@ -527,6 +540,7 @@ class DorisGenerator(MySQLGenerator):
         "trim",
         "true",
         "truncate",
+        "try_cast",
         "type",
         "type_cast",
         "types",
@@ -539,6 +553,7 @@ class DorisGenerator(MySQLGenerator):
         "unsigned",
         "update",
         "use",
+        "use_mv",
         "user",
         "using",
         "value",

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

@@ -651,17 +651,6 @@ def _struct_sql(self: DuckDBGenerator, expression: exp.Struct) -> str:
     return f"ROW({csv_args})" if is_bq_inline_struct else f"{{{csv_args}}}"
 
 
-def _datatype_sql(self: DuckDBGenerator, expression: exp.DataType) -> str:
-    if expression.is_type("array"):
-        return f"{self.expressions(expression, flat=True)}[{self.expressions(expression, key='values', flat=True)}]"
-
-    # Modifiers are not supported for TIME, [TIME | TIMESTAMP] WITH TIME ZONE
-    if expression.is_type(exp.DType.TIME, exp.DType.TIMETZ, exp.DType.TIMESTAMPTZ):
-        return expression.this.value
-
-    return self.datatype_sql(expression)
-
-
 def _json_format_sql(self: DuckDBGenerator, expression: exp.JSONFormat) -> str:
     sql = self.func("TO_JSON", expression.this, expression.args.get("options"))
     return f"CAST({sql} AS TEXT)"
@@ -1665,7 +1654,6 @@ class DuckDBGenerator(generator.Generator):
             if e.args.get("abbreviated")
             else self.func("MONTHNAME", e.this)
         ),
-        exp.DataType: _datatype_sql,
         exp.Date: _date_sql,
         exp.DateAdd: _date_delta_to_binary_interval_op(),
         exp.DateFromParts: _date_from_parts_sql,
@@ -2308,6 +2296,18 @@ class DuckDBGenerator(generator.Generator):
     _TRYCAST_DATE_SLASH_FMT = "%m/%d/%Y"
     _TRYCAST_DATE_MON_FMT = "%d-%b-%Y"
 
+    def datatype_sql(self, expression: exp.DataType) -> str:
+        if expression.is_type(exp.DType.ARRAY):
+            return f"{self.expressions(expression, flat=True)}[{self.expressions(expression, key='values', flat=True)}]"
+
+        # Modifiers are not supported for TIME, [TIME | TIMESTAMP] WITH TIME ZONE
+        if expression.is_type(
+            exp.DType.TIME, exp.DType.TIMETZ, exp.DType.TIMESTAMPTZ, exp.DType.TIMESTAMPLTZ
+        ):
+            expression.set("expressions", None)
+
+        return super().datatype_sql(expression)
+
     def _array_bag_sql(self, condition: exp.Expr, arr1: exp.Expr, arr2: exp.Expr) -> str:
         cond = exp.Paren(this=exp.replace_placeholders(condition, arr1=arr1, arr2=arr2))
         return self.sql(

{sqlglotc-30.18.0 → sqlglotc-30.19.0}/sqlglot/generators/fabric.py

@@ -53,22 +53,22 @@ class FabricGenerator(TSQLGenerator):
         **TSQLGenerator.TYPE_MAPPING,
         exp.DType.DATETIME: "DATETIME2",
         exp.DType.DECIMAL: "DECIMAL",
-        exp.DType.IMAGE: "VARBINARY",
+        exp.DType.IMAGE: "VARBINARY(MAX)",
         exp.DType.INT: "INT",
-        exp.DType.JSON: "VARCHAR",
-        exp.DType.MONEY: "DECIMAL",
+        exp.DType.JSON: "VARCHAR(MAX)",
+        exp.DType.MONEY: "DECIMAL(19, 4)",
         exp.DType.NCHAR: "CHAR",
         exp.DType.NVARCHAR: "VARCHAR",
         exp.DType.ROWVERSION: "ROWVERSION",
         exp.DType.SMALLDATETIME: "DATETIME2",
-        exp.DType.SMALLMONEY: "DECIMAL",
+        exp.DType.SMALLMONEY: "DECIMAL(10, 4)",
         exp.DType.TIMESTAMP: "DATETIME2",
         exp.DType.TIMESTAMPNTZ: "DATETIME2",
         exp.DType.TIMESTAMPTZ: "DATETIME2",
         exp.DType.TINYINT: "SMALLINT",
         exp.DType.UTINYINT: "SMALLINT",
         exp.DType.UUID: "UNIQUEIDENTIFIER",
-        exp.DType.XML: "VARCHAR",
+        exp.DType.XML: "VARCHAR(MAX)",
     }
 
     TRANSFORMS = {

{sqlglotc-30.18.0 → sqlglotc-30.19.0}/sqlglot/generators/mysql.py

@@ -17,6 +17,7 @@ from sqlglot.dialects.dialect import (
     no_pivot_sql,
     no_tablesample_sql,
     no_trycast_sql,
+    if_sql,
     remove_ts_or_ds_to_date,
     rename_func,
     strposition_sql,
@@ -165,6 +166,8 @@ class MySQLGenerator(generator.Generator):
             f"""GROUP_CONCAT({self.sql(e, "this")} SEPARATOR {self.sql(e, "separator") or "','"})"""
         ),
         exp.ILike: no_ilike_sql,
+        # https://dev.mysql.com/doc/refman/9.7/en/flow-control-functions.html#function_if
+        exp.If: if_sql(false_value="NULL"),
         exp.JSONExtractScalar: arrow_json_extract_sql,
         exp.Length: length_or_char_length_sql,
         exp.LogicalOr: rename_func("MAX"),
@@ -692,6 +695,15 @@ class MySQLGenerator(generator.Generator):
         global_ = " GLOBAL" if expression.args.get("global_") else ""
 
         target = self.sql(expression, "target")
+
+        # SHOW CREATE ... takes a possibly qualified name, it has no FROM clause
+        # https://dev.mysql.com/doc/refman/8.4/en/show-create-table.html
+        if expression.name.startswith("CREATE") and (db_id := self.sql(expression, "db")):
+            target = f"{db_id}.{target}"
+            db = ""
+        else:
+            db = self._prefixed_sql("FROM", expression, "db")
+
         target = f" {target}" if target else ""
         if expression.name in ("COLUMNS", "INDEX"):
             target = f" FROM{target}"
@@ -702,8 +714,6 @@ class MySQLGenerator(generator.Generator):
         elif expression.name == "PROJECTIONS":
             target = f" ON TABLE{target}" if target else ""
 
-        db = self._prefixed_sql("FROM", expression, "db")
-
         like = self._prefixed_sql("LIKE", expression, "like")
         where = self.sql(expression, "where")
 

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

@@ -90,6 +90,15 @@ def _dpipe_sql(self: generator.Generator, e: exp.DPipe) -> str:
     return self.func("SAFECONCAT" if e.args.get("safe") else "CONCAT", e.this, e.expression)
 
 
+def _distinct_sql(self, e: exp.Distinct) -> str:
+    this = self.expressions(e, flat=True)
+
+    if len(e.expressions) == 1:
+        return f"set({this})"
+
+    return f"set(ZIPNOTNULL({this}))"
+
+
 class PythonGenerator(generator.Generator):
     TRANSFORMS = {
         **{klass: _rename for klass in subclasses(exp.__name__, exp.Binary)},
@@ -105,7 +114,7 @@ class PythonGenerator(generator.Generator):
         exp.Concat: lambda self, e: self.func(
             "SAFECONCAT" if e.args.get("safe") else "CONCAT", *e.expressions
         ),
-        exp.Distinct: lambda self, e: f"set({self.sql(e, 'this')})",
+        exp.Distinct: _distinct_sql,
         exp.Div: _div_sql,
         exp.DPipe: _dpipe_sql,
         exp.Extract: lambda self, e: f"EXTRACT('{e.name.lower()}', {self.sql(e, 'expression')})",

{sqlglotc-30.18.0 → sqlglotc-30.19.0}/sqlglot/generators/singlestore.py

@@ -1454,6 +1454,17 @@ class SingleStoreGenerator(MySQLGenerator):
 
         return self.sql(res)
 
+    def withingroup_sql(self, expression: exp.WithinGroup) -> str:
+        # SingleStore includes trailing NULLs in percentile calculations, so we sort them first
+        if isinstance(expression.this, (exp.PercentileCont, exp.PercentileDisc)) and isinstance(
+            expression.expression, exp.Order
+        ):
+            expression = expression.copy()
+            for ordered in expression.expression.expressions:
+                ordered.set("nulls_first", True)
+
+        return super().withingroup_sql(expression)
+
     def all_sql(self, expression: exp.All) -> str:
         self.unsupported("ALL subquery predicate is not supported in SingleStore")
         return super().all_sql(expression)

{sqlglotc-30.18.0 → sqlglotc-30.19.0}/sqlglot/generators/spark.py

@@ -128,6 +128,9 @@ class SparkGenerator(Spark2Generator):
             exp.SafeMultiply: rename_func("TRY_MULTIPLY"),
             exp.SafeSubtract: rename_func("TRY_SUBTRACT"),
             exp.StartsWith: rename_func("STARTSWITH"),
+            exp.StabilityProperty: lambda self, e: (
+                "DETERMINISTIC" if e.name == "IMMUTABLE" else "NOT DETERMINISTIC"
+            ),
             exp.TimeAdd: date_delta_to_binary_interval_op(cast=False),
             exp.TimeSub: date_delta_to_binary_interval_op(cast=False),
             exp.TsOrDsAdd: _dateadd_sql,