sqlglotc 30.17.0__tar.gz → 30.19.0__tar.gz

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

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: sqlglotc
-Version: 30.17.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.17.0
+Requires-Dist: sqlglot==30.19.0
 Provides-Extra: dev
 Requires-Dist: setuptools>=61.0; extra == "dev"
 Requires-Dist: setuptools_scm; extra == "dev"
-Requires-Dist: sqlglot-mypy>=2.3.0.post1; extra == "dev"
+Requires-Dist: sqlglot-mypy>=2.3.0.post2; extra == "dev"
 Dynamic: requires-dist

{sqlglotc-30.17.0 → sqlglotc-30.19.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.3.0.post1"]
+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.3.0.post1",
+    "sqlglot-mypy >= 2.3.0.post2",
     "types-python-dateutil",
     "sqlglot",
 ]

{sqlglotc-30.17.0 → sqlglotc-30.19.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.17.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.17.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.17.0 → sqlglotc-30.19.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.17.0 → sqlglotc-30.19.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.17.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.17.0 → sqlglotc-30.19.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.17.0 → sqlglotc-30.19.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
 
@@ -236,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.17.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,
@@ -966,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:
@@ -1018,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,
@@ -1060,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]:
@@ -1718,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:
@@ -1891,7 +1907,7 @@ class Where(Expression):
 class Analyze(Expression):
     arg_types = {
         "kind": False,
-        "this": False,
+        "tables": False,
         "options": False,
         "mode": False,
         "partition": False,

{sqlglotc-30.17.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"]
 
 
@@ -478,7 +479,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.17.0 → sqlglotc-30.19.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"
 
@@ -530,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
 
@@ -850,6 +861,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__"
@@ -1826,7 +1847,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"]
@@ -1848,7 +1869,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)
@@ -1887,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] = []
@@ -1914,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)
@@ -2819,7 +2848,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:
+                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}"
 
@@ -3298,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="",
         )
 
@@ -3796,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
@@ -3814,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}"'
@@ -4587,7 +4628,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, "*")
@@ -5035,6 +5084,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")
@@ -5361,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
@@ -5395,9 +5444,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)
@@ -6037,8 +6088,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")
@@ -6047,7 +6098,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")

{sqlglotc-30.17.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
@@ -372,12 +373,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")
         ),
@@ -449,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.17.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.17.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.17.0 → sqlglotc-30.19.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: