sqlglotc 30.20.0__tar.gz → 30.22.0__tar.gz

{sqlglotc-30.20.0/sqlglotc.egg-info → sqlglotc-30.22.0}/PKG-INFO

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

{sqlglotc-30.20.0 → sqlglotc-30.22.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.post2"]
+dev = ["setuptools >= 61.0", "setuptools_scm", "mypy >= 2.4.0"]
 
 [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.post2",
+    "mypy >= 2.4.0",
     "types-python-dateutil",
     "sqlglot",
 ]

{sqlglotc-30.20.0 → sqlglotc-30.22.0}/setup.py

@@ -49,7 +49,6 @@ def _source_files(src_dir):
         "helper.py",
         "lineage.py",
         "parser.py",
-        "schema.py",
         "serde.py",
         "time.py",
         "tokenizer_core.py",

{sqlglotc-30.20.0 → sqlglotc-30.22.0}/sqlglot/expressions/array.py

@@ -23,6 +23,7 @@ class Array(Expression, Func):
         "expressions": False,
         "bracket_notation": False,
         "struct_name_inheritance": False,
+        "value_constructor": False,
     }
     is_var_len_args = True
 
@@ -84,7 +85,16 @@ class ArrayReverse(Expression, Func):
 
 
 class ArraySlice(Expression, Func):
-    arg_types = {"this": True, "start": True, "end": False, "step": False, "zero_based": False}
+    """Slice by end index, or by length when is_length is set."""
+
+    arg_types = {
+        "this": True,
+        "start": True,
+        "end": False,
+        "step": False,
+        "zero_based": False,
+        "is_length": False,
+    }
 
 
 class ArraySort(Expression, Func):
@@ -244,6 +254,10 @@ class Inline(Expression, Func, UDTF):
     pass
 
 
+class SplitToTable(Expression, Func, UDTF):
+    arg_types = {"this": True, "expression": True}
+
+
 class Stack(Expression, Func, UDTF):
     arg_types = {"this": True, "expressions": True}
     is_var_len_args = True

{sqlglotc-30.20.0 → sqlglotc-30.22.0}/sqlglot/expressions/builders.py

@@ -516,7 +516,7 @@ def cast(
 
 
 def table_(
-    table: Identifier | str,
+    table: Identifier | str | None,
     db: Identifier | str | None = None,
     catalog: Identifier | str | None = None,
     quoted: bool | None = None,

{sqlglotc-30.20.0 → sqlglotc-30.22.0}/sqlglot/expressions/ddl.py

@@ -400,7 +400,7 @@ class Alter(Expression):
     arg_types = {
         "this": False,
         "kind": True,
-        "actions": True,
+        "actions": False,
         "exists": False,
         "only": False,
         "options": False,

{sqlglotc-30.20.0 → sqlglotc-30.22.0}/sqlglot/expressions/properties.py

@@ -624,7 +624,9 @@ class Properties(Expression):
         "INCLUDE": IncludeProperty,
     }
 
-    PROPERTY_TO_NAME: t.ClassVar[dict[type[Property], str]] = {}
+    PROPERTY_TO_NAME: t.ClassVar[dict[type[Property], str]] = {
+        v: k for k, v in NAME_TO_PROPERTY.items()
+    }
 
     # CREATE property locations
     # Form: schema specified
@@ -652,7 +654,3 @@ class Properties(Expression):
                 expressions.append(Property(this=Literal.string(key), value=convert(value)))
 
         return cls(expressions=expressions)
-
-
-# TODO (mypyc)
-Properties.PROPERTY_TO_NAME = {v: k for k, v in Properties.NAME_TO_PROPERTY.items()}

{sqlglotc-30.20.0 → sqlglotc-30.22.0}/sqlglot/expressions/query.py

@@ -19,6 +19,7 @@ from sqlglot.expressions.core import (
     Hint,
     Identifier,
     In,
+    Var,
     _apply_builder,
     _apply_child_list_builder,
     _apply_list_builder,
@@ -441,11 +442,24 @@ class QueryBand(Expression):
 
 
 class RecursiveWithSearch(Expression):
-    arg_types = {"kind": True, "this": True, "expression": True, "using": False}
+    arg_types = {
+        "kind": True,
+        "this": True,
+        "expression": True,
+        "to": False,
+        "default": False,
+        "using": False,
+    }
 
 
 class With(Expression):
-    arg_types = {"expressions": False, "recursive": False, "search": False, "udfs": False}
+    arg_types = {
+        "expressions": False,
+        "recursive": False,
+        "search": False,
+        "cycle": False,
+        "udfs": False,
+    }
 
     @property
     def recursive(self) -> bool:
@@ -572,7 +586,7 @@ class ConditionalInsert(Expression):
 
 
 class MultitableInserts(Expression):
-    arg_types = {"expressions": True, "kind": True, "source": True}
+    arg_types = {"with_": False, "expressions": True, "kind": False, "source": True}
 
 
 class OnCondition(Expression):
@@ -657,6 +671,11 @@ class Limit(Expression):
         "expressions": False,
     }
 
+    @property
+    def is_limit_all(self) -> bool:
+        limit_expression = self.args.get("expression")
+        return isinstance(limit_expression, Var) and limit_expression.name.upper() == "ALL"
+
 
 class LimitOptions(Expression):
     arg_types = {
@@ -804,6 +823,19 @@ class Lateral(Expression, UDTF):
         "ordinality": False,
     }
 
+    @property
+    def selects(self) -> list[Expr]:
+        from sqlglot.expressions.array import Unnest
+
+        columns = super().selects
+
+        # UNNEST ... WITH ORDINALITY stores the ordinality column's name in Unnest.offset
+        offset = self.this.args.get("offset") if isinstance(self.this, Unnest) else None
+        if isinstance(offset, Identifier):
+            columns = columns + [offset]
+
+        return columns
+
 
 class TableFromRows(Expression, UDTF):
     arg_types = {
@@ -941,6 +973,12 @@ class Get(Expression):
     arg_types = {"this": True, "target": True, "properties": False}
 
 
+class ListStage(Expression):
+    """Lists files in a Snowflake stage or Git repository clone."""
+
+    arg_types = {"this": True, "pattern": False}
+
+
 class Table(Expression, Selectable):
     arg_types = {
         "this": False,

{sqlglotc-30.20.0 → sqlglotc-30.22.0}/sqlglot/expressions/string.py

@@ -260,6 +260,10 @@ class Upper(Expression, Func):
     _sql_names = ["UPPER", "UCASE"]
 
 
+class WeightString(Expression, Func):
+    arg_types = {"this": True, "to": False}
+
+
 # Encoding / base conversion
 
 

{sqlglotc-30.20.0 → sqlglotc-30.22.0}/sqlglot/generator.py

@@ -25,6 +25,8 @@ if t.TYPE_CHECKING:
 
 logger = logging.getLogger("sqlglot")
 
+_HIGH_BYTE_RE = re.compile(r"[\x80-\xff]")
+
 ESCAPED_UNICODE_RE = re.compile(r"\\(\d+)")
 UNSUPPORTED_TEMPLATE = "Argument '{}' is not supported for expression '{}' when targeting {}."
 
@@ -380,6 +382,12 @@ class Generator:
     # Whether comparing against booleans (e.g. x IS TRUE) is supported
     IS_BOOL_ALLOWED = True
 
+    # Whether casting a fractional number to an integer rounds it instead of truncating it
+    CAST_TO_INT_ROUNDS = False
+
+    # Whether the native integer division operator returns NULL for a zero divisor instead of raising
+    SAFE_INT_DIVISION = False
+
     # Whether to include the "SET" keyword in the "INSERT ... ON DUPLICATE KEY UPDATE" statement
     DUPLICATE_KEY_UPDATE_WITH_SET = True
 
@@ -565,6 +573,9 @@ class Generator:
     # The HEX function name
     HEX_FUNC = "HEX"
 
+    # Function that constructs a binary value from a hex-encoded byte string.
+    BYTE_STRING_FUNCTION = ""
+
     # The keywords to use when prefixing & separating WITH based properties
     WITH_PROPERTIES_PREFIX = "WITH"
 
@@ -871,6 +882,10 @@ class Generator:
         exp.Mod,
     )
 
+    # ALTER options that follow the others without a comma, e.g. MySQL's
+    # ENGINE=InnoDB PARTITION BY LIST (...) or StarRocks' PARTITION BY ... DISTRIBUTED BY ...
+    ALTER_PARTITION_OPTIONS: t.ClassVar[tuple[type[exp.Expr], ...]] = ()
+
     SAFE_JSON_PATH_KEY_RE: t.ClassVar = exp.SAFE_IDENTIFIER_RE
 
     SENTINEL_LINE_BREAK = "__SQLGLOT__LB__"
@@ -892,6 +907,7 @@ class Generator:
         "_escaped_quote_end",
         "_escaped_byte_quote_end",
         "_escaped_identifier_end",
+        "_identifier_escaped_sequences",
         "_next_name",
         "_identifier_start",
         "_identifier_end",
@@ -944,6 +960,7 @@ class Generator:
             else ""
         )
         self._escaped_identifier_end = self.dialect.IDENTIFIER_END * 2
+        self._identifier_escaped_sequences = self.dialect.IDENTIFIER_ESCAPED_SEQUENCES
 
         self._next_name = name_sequence("_t")
 
@@ -1569,8 +1586,10 @@ class Generator:
         )
         search = self.sql(expression, "search")
         search = f" {search}" if search else ""
+        cycle = self.sql(expression, "cycle")
+        cycle = f" {cycle}" if cycle else ""
 
-        sql = f"WITH {recursive}{sql}{search}" if sql else ""
+        sql = f"WITH {recursive}{sql}{search}{cycle}" if sql else ""
         return f"{udfs} {sql}" if udfs and sql else f"{udfs}{sql}"
 
     def cte_sql(self, expression: exp.CTE) -> str:
@@ -1642,15 +1661,23 @@ class Generator:
 
     def bytestring_sql(self, expression: exp.ByteString) -> str:
         this = self.sql(expression, "this")
+        is_bytes = bool(expression.args.get("is_bytes"))
+        if is_bytes and self.BYTE_STRING_FUNCTION:
+            # Hex digits can be quoted directly without escaping.
+            return self.func(self.BYTE_STRING_FUNCTION, f"'{this.encode('latin-1').hex()}'")
+
         if self.dialect.BYTE_START:
             escaped_byte_string = self.escape_str(
                 this,
-                escape_backslash=False,
+                escape_backslash=bool(
+                    self.dialect.tokenizer_class.NUMERIC_ESCAPES
+                    or self.dialect.tokenizer_class.DROP_UNKNOWN_ESCAPES
+                ),
                 delimiter=self.dialect.BYTE_END,
                 escaped_delimiter=self._escaped_byte_quote_end,
                 is_byte_string=True,
+                is_bytes=is_bytes,
             )
-            is_bytes = expression.args.get("is_bytes", False)
             delimited_byte_string = (
                 f"{self.dialect.BYTE_START}{escaped_byte_string}{self.dialect.BYTE_END}"
             )
@@ -1787,7 +1814,8 @@ class Generator:
         if type_value == exp.DType.USERDEFINED and expression.args.get("kind"):
             type_sql = self.sql(expression, "kind")
         elif type_value == exp.DType.CHARACTER_SET:
-            return f"CHAR CHARACTER SET {self.sql(expression, 'kind')}"
+            char = f"CHAR({interior})" if interior else "CHAR"
+            return f"{char} CHARACTER SET {self.sql(expression, 'kind')}"
         else:
             type_sql = (
                 self.TYPE_MAPPING.get(type_value, type_value.value)
@@ -2031,6 +2059,9 @@ class Generator:
         lower = text.lower()
         quoted = expression.quoted
         text = lower if self.normalize and not quoted else text
+        if self._identifier_escaped_sequences:
+            for char, escaped in self._identifier_escaped_sequences.items():
+                text = text.replace(char, escaped)
         text = text.replace(self._identifier_end, self._escaped_identifier_end)
         if (
             quoted
@@ -2959,7 +2990,20 @@ class Generator:
             op_sql = self.seg(f"LATERAL VIEW{' OUTER' if expression.args.get('outer') else ''}")
             return f"{op_sql}{self.sep()}{this}{table}{columns}"
 
-        alias = self.sql(expression, "alias")
+        table_alias = expression.args.get("alias")
+        offset = expression.this.args.get("offset")
+
+        if (
+            self.UNNEST_WITH_ORDINALITY
+            and table_alias
+            and isinstance(expression.this, exp.Unnest)
+            and isinstance(offset, exp.Identifier)
+        ):
+            # UNNEST ... WITH ORDINALITY stores the ordinality column's name in Unnest.offset
+            table_alias = table_alias.copy()
+            table_alias.append("columns", offset.copy())
+
+        alias = self.sql(table_alias)
         alias = f" AS {alias}" if alias else ""
 
         ordinality = expression.args.get("ordinality") or ""
@@ -2972,6 +3016,9 @@ class Generator:
     def limit_sql(self, expression: exp.Limit, top: bool = False) -> str:
         this = self.sql(expression, "this")
 
+        if expression.is_limit_all and not self.dialect.SUPPORTS_LIMIT_ALL:
+            return this
+
         args = [
             self._simplify_unless_literal(e) if self.LIMIT_ONLY_LITERALS else e
             for e in (expression.args.get(k) for k in ("offset", "expression"))
@@ -3059,6 +3106,7 @@ class Generator:
         delimiter: str | None = None,
         escaped_delimiter: str | None = None,
         is_byte_string: bool = False,
+        is_bytes: bool = False,
     ) -> str:
         if is_byte_string:
             supports_escape_sequences = self.dialect.BYTE_STRINGS_SUPPORT_ESCAPED_SEQUENCES
@@ -3071,6 +3119,10 @@ class Generator:
                 for ch in text
             )
 
+            if is_bytes and "x" in self.dialect.tokenizer_class.NUMERIC_ESCAPES:
+                # Escape high bytes so they aren't re-encoded as UTF-8 characters.
+                text = _HIGH_BYTE_RE.sub(lambda m: f"\\x{ord(m.group()):02x}", text)
+
         delimiter = delimiter or self.dialect.QUOTE_END
         escaped_delimiter = escaped_delimiter or self._escaped_quote_end
 
@@ -3171,7 +3223,9 @@ class Generator:
         if not (isinstance(this, exp.Column) and not this.table):
             return None
 
-        ancestor = expression.find_ancestor(exp.Select, exp.Window)
+        # Only a query's own ORDER BY can reference its projection aliases
+        order = expression.parent
+        ancestor = order.parent if isinstance(order, exp.Order) else None
         if not isinstance(ancestor, exp.Select):
             return None
 
@@ -3321,7 +3375,9 @@ class Generator:
             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):
+        elif (
+            self.LIMIT_FETCH == "FETCH" and isinstance(limit, exp.Limit) and not limit.is_limit_all
+        ):
             limit = exp.Fetch(direction="FIRST", count=exp.maybe_copy(limit.expression))
 
         return csv(
@@ -4371,10 +4427,12 @@ class Generator:
         return f"SET {exprs}"
 
     def alter_sql(self, expression: exp.Alter) -> str:
-        actions = expression.args["actions"]
+        actions = expression.actions
 
-        if not self.dialect.ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN and isinstance(
-            actions[0], exp.ColumnDef
+        if (
+            not self.dialect.ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN
+            and actions
+            and isinstance(actions[0], exp.ColumnDef)
         ):
             actions_sql = self.expressions(expression, key="actions", flat=True)
             actions_sql = f"ADD {actions_sql}"
@@ -4401,8 +4459,18 @@ class Generator:
         on_cluster = self.sql(expression, "cluster")
         on_cluster = f" {on_cluster}" if on_cluster else ""
         only = " ONLY" if expression.args.get("only") else ""
-        options = self.expressions(expression, key="options")
-        options = f", {options}" if options else ""
+        options = expression.args.get("options") or []
+        options_sql = self.expressions(
+            sqls=[o for o in options if not isinstance(o, self.ALTER_PARTITION_OPTIONS)]
+        )
+        options_sql = f", {options_sql}" if options_sql and actions_sql else options_sql
+        partitions_sql = self.expressions(
+            sqls=[o for o in options if isinstance(o, self.ALTER_PARTITION_OPTIONS)],
+            sep=" ",
+            flat=True,
+        )
+        if partitions_sql and (actions_sql or options_sql):
+            partitions_sql = f" {partitions_sql}"
         kind = self.sql(expression, "kind")
         not_valid = " NOT VALID" if expression.args.get("not_valid") else ""
         check = " WITH CHECK" if expression.args.get("check") else ""
@@ -4414,7 +4482,7 @@ class Generator:
         this = self.sql(expression, "this")
         this = f" {this}" if this else ""
 
-        return f"ALTER {iceberg}{kind}{exists}{only}{this}{on_cluster}{check}{self.sep()}{actions_sql}{not_valid}{options}{cascade}"
+        return f"ALTER {iceberg}{kind}{exists}{only}{this}{on_cluster}{check}{self.sep()}{actions_sql}{not_valid}{options_sql}{partitions_sql}{cascade}"
 
     def altersession_sql(self, expression: exp.AlterSession) -> str:
         items_sql = self.expressions(expression, flat=True)
@@ -4477,12 +4545,14 @@ class Generator:
         return f"{this_sql} HAVING {kind} {expression_sql}"
 
     def intdiv_sql(self, expression: exp.IntDiv) -> str:
-        return self.sql(
-            exp.Cast(
-                this=exp.Div(this=expression.this, expression=expression.expression),
-                to=exp.DataType(this=exp.DType.INT),
-            )
-        )
+        return self._truncated_div_sql(expression.this, expression.expression)
+
+    def _truncated_div_sql(self, this: exp.Expr, divisor: exp.Expr) -> str:
+        div: exp.Expr = exp.Div(this=this, expression=divisor)
+        if self.CAST_TO_INT_ROUNDS:
+            div = exp.Trunc(this=div)
+
+        return self.sql(exp.Cast(this=div, to=exp.DataType(this=exp.DType.BIGINT)))
 
     def dpipe_sql(self, expression: exp.DPipe) -> str:
         if self.dialect.STRICT_STRING_CONCAT and expression.args.get("safe"):
@@ -4501,12 +4571,14 @@ class Generator:
 
         elif not self.dialect.TYPED_DIVISION and expression.args.get("typed"):
             if l.is_type(*exp.DataType.INTEGER_TYPES) and r.is_type(*exp.DataType.INTEGER_TYPES):
-                return self.sql(
-                    exp.cast(
-                        l / r,
-                        to=exp.DType.BIGINT,
-                    )
-                )
+                # Native integer division depends on the target's operand types, which may differ
+                # from the source's (e.g. FLOOR(int) is DOUBLE in DuckDB), unless the operands are
+                # integer literals or casts
+                if all(e.is_int or isinstance(e, exp.Cast) for e in (l, r)) and (
+                    expression.args.get("safe") or not self.SAFE_INT_DIVISION
+                ):
+                    return self.sql(exp.IntDiv(this=l, expression=r))
+                return self._truncated_div_sql(l, r)
 
         return self.binary(expression, "/")
 
@@ -4727,12 +4799,11 @@ class Generator:
             elif arg_value is not None:
                 args.append(arg_value)
 
-        if self.dialect.PRESERVE_ORIGINAL_NAMES:
-            name = expression.meta_get("name") or expression.sql_name()
-        else:
-            name = expression.sql_name()
+        return self.func(self.function_name(expression), *args)
 
-        return self.func(name, *args)
+    def function_name(self, expression: exp.Func) -> str:
+        name_key = self.dialect.ORIGINAL_NAME_META_KEY
+        return (expression.meta_get(name_key) if name_key else None) or expression.sql_name()
 
     def func(
         self,
@@ -5309,6 +5380,28 @@ class Generator:
             sqlglot.dialects.dialect.unit_to_str(expression),
         )
 
+    def arrayinsert_sql(self, expression: exp.ArrayInsert, index_offset: int = 0) -> str:
+        this = expression.this
+        position = expression.args["position"]
+        offset = index_offset - (expression.args.get("offset") or 0)
+
+        if offset:
+            if position.is_int:
+                value = position.to_py()
+                if value >= 0:
+                    position = exp.Literal.number(value + offset)
+                elif offset < 0 and value == -1:
+                    # 1-based -1 appends, which a 0-based position can only express as the size
+                    position = exp.ArraySize(this=this.copy())
+                else:
+                    # Negative positions count from the end, so they shift in the opposite
+                    # direction, e.g. 0-based -1 (before the last element) is 1-based -2
+                    position = exp.Literal.number(value - offset)
+            else:
+                self.unsupported("ARRAY_INSERT position can only be converted if it's a literal")
+
+        return self.func("ARRAY_INSERT", this, position, expression.expression)
+
     def arrayany_sql(self, expression: exp.ArrayAny) -> str:
         if self.CAN_IMPLEMENT_ARRAY_ANY:
             filtered = exp.ArrayFilter(this=expression.this, expression=expression.expression)
@@ -5710,9 +5803,18 @@ class Generator:
 
     def multitableinserts_sql(self, expression: exp.MultitableInserts) -> str:
         kind = self.sql(expression, "kind")
-        expressions = self.seg(self.expressions(expression, sep=" "))
-        res = f"INSERT {kind}{expressions}{self.seg(self.sql(expression, 'source'))}"
-        return res
+        source = self.sql(expression, "source")
+
+        if kind:
+            expressions = self.seg(self.expressions(expression, sep=" "))
+            sql = f"INSERT {kind}{expressions}{self.seg(source)}"
+        else:
+            # If kind isn't present, we have Hive's FROM-first form:
+            # FROM x INSERT ... SELECT ... [INSERT ... SELECT ...]
+            inserts = self.sep().join(self.sql(e) for e in expression.expressions)
+            sql = f"FROM {source}{self.seg(inserts)}"
+
+        return self.prepend_ctes(expression, sql)
 
     def oncondition_sql(self, expression: exp.OnCondition) -> str:
         # Static options like "NULL ON ERROR" are stored as strings, in contrast to "DEFAULT <expr> ON ERROR"
@@ -6148,12 +6250,16 @@ class Generator:
         kind = self.sql(expression, "kind")
         this = self.sql(expression, "this")
         set = self.sql(expression, "expression")
+        to = self.sql(expression, "to")
+        to = f" TO {to}" if to else ""
+        default = self.sql(expression, "default")
+        default = f" DEFAULT {default}" if default else ""
         using = self.sql(expression, "using")
         using = f" USING {using}" if using else ""
 
         kind_sql = kind if kind == "CYCLE" else f"SEARCH {kind} FIRST BY"
 
-        return f"{kind_sql} {this} SET {set}{using}"
+        return f"{kind_sql} {this} SET {set}{to}{default}{using}"
 
     def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str:
         params = self.expressions(expression, key="params", flat=True)
@@ -6176,6 +6282,11 @@ class Generator:
         self.unsupported("Unsupported INSTALL statement")
         return ""
 
+    def liststage_sql(self, expression: exp.ListStage) -> str:
+        pattern = self.sql(expression, "pattern")
+        pattern = f" PATTERN = {pattern}" if pattern else ""
+        return f"LIST {self.sql(expression, 'this')}{pattern}"
+
     def get_put_sql(self, expression: exp.Put | exp.Get) -> str:
         # Snowflake GET/PUT statements:
         #   PUT <file> <internalStage> <properties>
@@ -6354,6 +6465,11 @@ class Generator:
         using = f" USING {charset}" if charset else ""
         return self.func(name, this + using)
 
+    def weightstring_sql(self, expression: exp.WeightString) -> str:
+        to = self.sql(expression, "to")
+        to = f" AS {to}" if to else ""
+        return self.func("WEIGHT_STRING", f"{self.sql(expression, 'this')}{to}")
+
     def block_sql(self, expression: exp.Block) -> str:
         expressions = self.expressions(expression, sep="; ", flat=True)
         begin = "BEGIN " if expression.args.get("begin") else ""

{sqlglotc-30.20.0 → sqlglotc-30.22.0}/sqlglot/generators/athena.py

@@ -122,7 +122,7 @@ class AthenaTrinoGenerator(TrinoGenerator):
     }
 
 
-class AthenaGenerator(generator.Generator):
+class AthenaGenerator(AthenaTrinoGenerator):
     SELECT_KINDS: tuple[str, ...] = ()
     SUPPORTS_DECODE_CASE = False
 

{sqlglotc-30.20.0 → sqlglotc-30.22.0}/sqlglot/generators/bigquery.py

@@ -15,6 +15,7 @@ from sqlglot.dialects.dialect import (
     inline_array_unless_query,
     max_or_greatest,
     min_or_least,
+    no_filter_sql,
     no_ilike_sql,
     regexp_replace_sql,
     rename_func,
@@ -229,8 +230,7 @@ def _levenshtein_sql(self: BigQueryGenerator, expression: exp.Levenshtein) -> st
 
 
 def _json_extract_sql(self: BigQueryGenerator, expression: JSON_EXTRACT_TYPE) -> str:
-    name = expression.meta_get("name") or expression.sql_name()
-    upper = name.upper()
+    upper = self.function_name(expression).upper()
 
     dquote_escaping = upper in DQUOTES_ESCAPING_JSON_FUNCTIONS
 
@@ -257,6 +257,7 @@ class BigQueryGenerator(generator.Generator):
     RENAME_TABLE_WITH_DB = False
     NVL2_SUPPORTED = False
     UNNEST_WITH_ORDINALITY = False
+    CAST_TO_INT_ROUNDS = True
     COLLATE_IS_FUNC = True
     LIMIT_ONLY_LITERALS = True
     SUPPORTS_TABLE_ALIAS_COLUMNS = False
@@ -335,6 +336,7 @@ 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.Filter: no_filter_sql,
         exp.FromTimeZone: lambda self, e: self.func(
             "DATETIME", self.func("TIMESTAMP", e.this, e.args.get("zone")), "'UTC'"
         ),