sqlglotc 30.15.0__tar.gz → 30.16.0__tar.gz

{sqlglotc-30.15.0/sqlglotc.egg-info → sqlglotc-30.16.0}/PKG-INFO

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

{sqlglotc-30.15.0 → sqlglotc-30.16.0}/sqlglot/errors.py

@@ -72,7 +72,21 @@ class ParseError(SqlglotError):
 
 
 class TokenError(SqlglotError):
-    pass
+    """Error raised when tokenizing fails.
+
+    When available, `start` and `end` are the offsets in the source SQL of the context
+    snippet quoted in the message, i.e. the snippet is `sql[start:end]`.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        start: int | None = None,
+        end: int | None = None,
+    ):
+        super().__init__(message)
+        self.start = start
+        self.end = end
 
 
 class OptimizeError(SqlglotError):

{sqlglotc-30.15.0 → sqlglotc-30.16.0}/sqlglot/expressions/array.py

@@ -8,6 +8,7 @@ from sqlglot.expressions.core import (
     Expr,
     Func,
     Binary,
+    Predicate,
     to_identifier,
 )
 from sqlglot.helper import trait
@@ -109,16 +110,16 @@ class ArrayAny(Expression, Func):
     arg_types = {"this": True, "expression": True}
 
 
-class ArrayContains(Expression, Binary, Func):
+class ArrayContains(Expression, Binary, Predicate, Func):
     arg_types = {"this": True, "expression": True, "ensure_variant": False, "check_null": False}
     _sql_names = ["ARRAY_CONTAINS", "ARRAY_HAS"]
 
 
-class ArrayContainsAll(Expression, Binary, Func):
+class ArrayContainsAll(Expression, Binary, Predicate, Func):
     _sql_names = ["ARRAY_CONTAINS_ALL", "ARRAY_HAS_ALL"]
 
 
-class ArrayContainedBy(Expression, Binary, Func):
+class ArrayContainedBy(Expression, Binary, Predicate, Func):
     pass
 
 
@@ -132,7 +133,7 @@ class ArrayIntersect(Expression, Func):
     _sql_names = ["ARRAY_INTERSECT", "ARRAY_INTERSECTION"]
 
 
-class ArrayOverlaps(Expression, Binary, Func):
+class ArrayOverlaps(Expression, Binary, Predicate, Func):
     arg_types = {"this": True, "expression": True, "null_safe": False}
 
 
@@ -343,6 +344,7 @@ class ToMap(Expression, Func):
 class VarMap(Expression, Func):
     arg_types = {"keys": True, "values": True}
     is_var_len_args = True
+    var_len_arg_key = "values"
 
     @property
     def keys(self) -> list[Expr]:

{sqlglotc-30.15.0 → sqlglotc-30.16.0}/sqlglot/expressions/core.py

@@ -14,7 +14,7 @@ from builtins import type as Type
 from collections import deque
 from collections.abc import Collection, Iterator, Mapping, MutableMapping, Sequence
 from copy import deepcopy
-from decimal import Decimal
+from decimal import Decimal, InvalidOperation
 from functools import reduce
 
 from sqlglot._typing import E, GeneratorNoDialectArgs, ParserNoDialectArgs, T
@@ -85,6 +85,7 @@ class Expr:
     arg_types: t.ClassVar[dict[str, bool]] = {"this": True}
     required_args: t.ClassVar[set[str]] = {"this"}
     is_var_len_args: t.ClassVar[bool] = False
+    var_len_arg_key: t.ClassVar[str] = "expressions"
     _hash_raw_args: t.ClassVar[bool] = False
     is_subquery: t.ClassVar[bool] = False
     is_cast: t.ClassVar[bool] = False
@@ -1577,7 +1578,7 @@ class Condition(Expr):
 
 @trait
 class Predicate(Condition):
-    """Relationships like x = y, x > 1, x >= y."""
+    """Any condition that evaluates to a boolean, e.g. x = y, x LIKE 'a%', a @> b."""
 
 
 class Cache(Expression):
@@ -1643,8 +1644,11 @@ class Func(Condition):
     The base class for all function expressions.
 
     Attributes:
-        is_var_len_args (bool): if set to True the last argument defined in arg_types will be
+        is_var_len_args (bool): if set to True the argument identified by var_len_arg_key will be
             treated as a variable length argument and the argument's value will be stored as a list.
+        var_len_arg_key (str): the arg_types key that collects the variable length arguments.
+            Arguments preceding it in arg_types are filled positionally; those following it (e.g.
+            dialect flags) are never populated by from_arg_list.
         _sql_names (list): the SQL name (1st item in the list) and aliases (subsequent items) for this
             function expression. These values are used to map this node to a name during parsing as
             well as to provide the function's name during SQL string generation. By default the SQL
@@ -1652,18 +1656,17 @@ class Func(Condition):
     """
 
     is_var_len_args: t.ClassVar[bool] = False
+    var_len_arg_key: t.ClassVar[str] = "expressions"
     _sql_names: t.ClassVar[list[str]] = []
 
     @classmethod
     def from_arg_list(cls, args: Sequence[object]) -> Self:
         if cls.is_var_len_args:
             all_arg_keys = tuple(cls.arg_types)
-            # If this function supports variable length argument treat the last argument as such.
-            non_var_len_arg_keys = all_arg_keys[:-1] if cls.is_var_len_args else all_arg_keys
-            num_non_var = len(non_var_len_arg_keys)
+            var_len_index = all_arg_keys.index(cls.var_len_arg_key)
 
-            args_dict = {arg_key: arg for arg, arg_key in zip(args, non_var_len_arg_keys)}
-            args_dict[all_arg_keys[-1]] = args[num_non_var:]
+            args_dict = {arg_key: arg for arg, arg_key in zip(args, all_arg_keys[:var_len_index])}
+            args_dict[cls.var_len_arg_key] = args[var_len_index:]
         else:
             args_dict = {arg_key: arg for arg, arg_key in zip(args, cls.arg_types)}
 
@@ -1764,7 +1767,10 @@ class Literal(Expression, Condition):
             try:
                 return int(self.this)
             except ValueError:
-                return Decimal(self.this)
+                try:
+                    return Decimal(self.this)
+                except InvalidOperation as e:
+                    raise ValueError(f"Invalid numeric literal: {self.this!r}") from e
         return self.this
 
 
@@ -2119,15 +2125,15 @@ class Div(Expression, Binary):
     arg_types = {"this": True, "expression": True, "typed": False, "safe": False}
 
 
-class Overlaps(Expression, Binary):
+class Overlaps(Expression, Binary, Predicate):
     pass
 
 
-class ExtendsLeft(Expression, Binary):
+class ExtendsLeft(Expression, Binary, Predicate):
     pass
 
 
-class ExtendsRight(Expression, Binary):
+class ExtendsRight(Expression, Binary, Predicate):
     pass
 
 
@@ -2231,7 +2237,7 @@ class Sub(Expression, Binary):
     pass
 
 
-class Adjacent(Expression, Binary):
+class Adjacent(Expression, Binary, Predicate):
     pass
 
 
@@ -2317,7 +2323,7 @@ class Pow(Expression, Binary, Func):
     _sql_names = ["POWER", "POW"]
 
 
-class RegexpLike(Expression, Binary, Func):
+class RegexpLike(Expression, Binary, Predicate, Func):
     arg_types = {"this": True, "expression": True, "flag": False, "full_match": False}
 
 

{sqlglotc-30.15.0 → sqlglotc-30.16.0}/sqlglot/expressions/ddl.py

@@ -250,6 +250,7 @@ class AlterColumn(Expression):
         "allow_null": False,
         "visible": False,
         "rename_to": False,
+        "exists": False,
     }
 
 

{sqlglotc-30.15.0 → sqlglotc-30.16.0}/sqlglot/expressions/json.py

@@ -46,15 +46,15 @@ class JSONArrayInsert(Expression, Func):
     _sql_names = ["JSON_ARRAY_INSERT"]
 
 
-class JSONBContains(Expression, Binary, Func):
+class JSONBContains(Expression, Binary, Predicate, Func):
     _sql_names = ["JSONB_CONTAINS"]
 
 
-class JSONBContainsAllTopKeys(Expression, Binary, Func):
+class JSONBContainsAllTopKeys(Expression, Binary, Predicate, Func):
     pass
 
 
-class JSONBContainsAnyTopKeys(Expression, Binary, Func):
+class JSONBContainsAnyTopKeys(Expression, Binary, Predicate, Func):
     pass
 
 
@@ -133,6 +133,7 @@ class JSONExtractScalar(Expression, Binary, Func):
         "expressions": False,
         "json_type": False,
         "scalar_only": False,
+        "json_subtype": False,
     }
     _sql_names = ["JSON_EXTRACT_SCALAR"]
     is_var_len_args = True

{sqlglotc-30.15.0 → sqlglotc-30.16.0}/sqlglot/expressions/query.py

@@ -2119,6 +2119,10 @@ class IfBlock(Expression):
     arg_types = {"this": True, "true": True, "false": False}
 
 
+class CaseStatement(Expression):
+    arg_types = {"this": False, "ifs": True, "default": False}
+
+
 class WhileBlock(Expression):
     arg_types = {"this": True, "body": True}
 

{sqlglotc-30.15.0 → sqlglotc-30.16.0}/sqlglot/expressions/string.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from sqlglot.expressions.core import Expression, Func, Binary
+from sqlglot.expressions.core import Expression, Func, Binary, Predicate
 
 
 # String basics
@@ -445,11 +445,11 @@ class RegexpExtractAll(Expression, Func):
     }
 
 
-class RegexpFullMatch(Expression, Binary, Func):
+class RegexpFullMatch(Expression, Binary, Predicate, Func):
     arg_types = {"this": True, "expression": True, "options": False}
 
 
-class RegexpILike(Expression, Binary, Func):
+class RegexpILike(Expression, Binary, Predicate, Func):
     arg_types = {"this": True, "expression": True, "flag": False}
 
 

{sqlglotc-30.15.0 → sqlglotc-30.16.0}/sqlglot/generator.py

@@ -4,6 +4,7 @@ import logging
 import re
 import typing as t
 from collections import defaultdict
+from decimal import Decimal
 from functools import reduce, wraps
 
 from sqlglot import exp
@@ -484,6 +485,12 @@ class Generator:
     # Whether ALTER TABLE ... CHANGE COLUMN column-rename-and-redefine syntax is supported
     SUPPORTS_CHANGE_COLUMN = False
 
+    # Whether ALTER COLUMN can set a column's nullability together with its type
+    SUPPORTS_ALTER_COLUMN_NULLABILITY = False
+
+    # Whether ALTER COLUMN IF EXISTS is supported
+    SUPPORTS_ALTER_COLUMN_IF_EXISTS = False
+
     # Whether the LikeProperty needs to be specified inside of the schema clause
     LIKE_PROPERTY_INSIDE_SCHEMA = False
 
@@ -1642,10 +1649,11 @@ class Generator:
     def unicodestring_sql(self, expression: exp.UnicodeString) -> str:
         this = self.sql(expression, "this")
         escape = expression.args.get("escape")
+        unicode_start = self.dialect.UNICODE_START
 
-        if self.dialect.UNICODE_START:
+        if unicode_start:
             escape_substitute = r"\\\1"
-            left_quote, right_quote = self.dialect.UNICODE_START, self.dialect.UNICODE_END
+            left_quote, right_quote = unicode_start, self.dialect.UNICODE_END or ""
         else:
             escape_substitute = r"\\u\1"
             left_quote, right_quote = self.dialect.QUOTE_START, self.dialect.QUOTE_END
@@ -1657,9 +1665,16 @@ class Generator:
             escape_pattern = ESCAPED_UNICODE_RE
             escape_sql = ""
 
-        if not self.dialect.UNICODE_START or (escape and not self.SUPPORTS_UESCAPE):
+        if not unicode_start or (escape and not self.SUPPORTS_UESCAPE):
             this = escape_pattern.sub(self.UNICODE_SUBSTITUTE or escape_substitute, this)
 
+        if unicode_start:
+            # A Unicode literal only escapes its delimiter by doubling it; the escape character
+            # introduces a code point, so the dialect's ordinary string escapes don't apply here
+            this = self._replace_line_breaks(this).replace(right_quote, right_quote * 2)
+        else:
+            this = self.escape_str(this, escape_backslash=False)
+
         return f"{left_quote}{this}{right_quote}{escape_sql}"
 
     def rawstring_sql(self, expression: exp.RawString) -> str:
@@ -1702,11 +1717,12 @@ class Generator:
                 continue
 
             param_value = param.this if isinstance(param, exp.DataTypeParam) else param
-            if (
-                isinstance(param_value, exp.Literal)
-                and param_value.is_number
-                and int(param_value.to_py()) > bound
-            ):
+            value = (
+                param_value.to_py()
+                if isinstance(param_value, exp.Literal) and param_value.is_number
+                else None
+            )
+            if isinstance(value, (int, Decimal)) and value > bound:
                 self.unsupported(
                     f"{type_value.value} parameter {param_value.name} exceeds "
                     f"{self.dialect.__class__.__name__}'s maximum of {bound}; capping"
@@ -4198,6 +4214,13 @@ class Generator:
     def altercolumn_sql(self, expression: exp.AlterColumn) -> str:
         this = self.sql(expression, "this")
 
+        exists = ""
+        if expression.args.get("exists"):
+            if self.SUPPORTS_ALTER_COLUMN_IF_EXISTS:
+                exists = " IF EXISTS"
+            else:
+                self.unsupported("ALTER COLUMN IF EXISTS is not supported by this dialect")
+
         dtype = self.sql(expression, "dtype")
         if dtype:
             collate = self.sql(expression, "collate")
@@ -4205,19 +4228,24 @@ class Generator:
             using = self.sql(expression, "using")
             using = f" USING {using}" if using else ""
             alter_set_type = self.ALTER_SET_TYPE + " " if self.ALTER_SET_TYPE else ""
-            return f"ALTER COLUMN {this} {alter_set_type}{dtype}{collate}{using}"
+            null_constraint = self._alter_column_null_constraint_sql(expression)
+
+            return (
+                f"ALTER COLUMN{exists} {this} {alter_set_type}{dtype}"
+                f"{collate}{using}{null_constraint}"
+            )
 
         default = self.sql(expression, "default")
         if default:
-            return f"ALTER COLUMN {this} SET DEFAULT {default}"
+            return f"ALTER COLUMN{exists} {this} SET DEFAULT {default}"
 
         comment = self.sql(expression, "comment")
         if comment:
-            return f"ALTER COLUMN {this} COMMENT {comment}"
+            return f"ALTER COLUMN{exists} {this} COMMENT {comment}"
 
         visible = expression.args.get("visible")
         if visible:
-            return f"ALTER COLUMN {this} SET {visible}"
+            return f"ALTER COLUMN{exists} {this} SET {visible}"
 
         allow_null = expression.args.get("allow_null")
         drop = expression.args.get("drop")
@@ -4227,9 +4255,20 @@ class Generator:
 
         if allow_null is not None:
             keyword = "DROP" if drop else "SET"
-            return f"ALTER COLUMN {this} {keyword} NOT NULL"
+            return f"ALTER COLUMN{exists} {this} {keyword} NOT NULL"
+
+        return f"ALTER COLUMN{exists} {this} DROP DEFAULT"
+
+    def _alter_column_null_constraint_sql(self, expression: exp.AlterColumn) -> str:
+        allow_null = expression.args.get("allow_null")
+        if allow_null is None:
+            return ""
+
+        if not self.SUPPORTS_ALTER_COLUMN_NULLABILITY:
+            self.unsupported("ALTER COLUMN cannot set nullability along with a type")
+            return ""
 
-        return f"ALTER COLUMN {this} DROP DEFAULT"
+        return " NULL" if allow_null else " NOT NULL"
 
     def modifycolumn_sql(self, expression: exp.ModifyColumn) -> str:
         this = self.sql(expression, "this")
@@ -6272,6 +6311,10 @@ class Generator:
         self.unsupported("Unsupported If block syntax")
         return ""
 
+    def casestatement_sql(self, expression: exp.CaseStatement) -> str:
+        self.unsupported("Unsupported Case statement syntax")
+        return ""
+
     def whileblock_sql(self, expression: exp.WhileBlock) -> str:
         self.unsupported("Unsupported While block syntax")
         return ""

{sqlglotc-30.15.0 → sqlglotc-30.16.0}/sqlglot/generators/bigquery.py

@@ -292,7 +292,7 @@ class BigQueryGenerator(generator.Generator):
         exp.RowNumber,
     )
 
-    TS_OR_DS_TYPES = (
+    TS_OR_DS_TYPES: t.ClassVar = (
         exp.TsOrDsToDatetime,
         exp.TsOrDsToTimestamp,
         exp.TsOrDsToTime,

{sqlglotc-30.15.0 → sqlglotc-30.16.0}/sqlglot/generators/clickhouse.py

@@ -175,6 +175,7 @@ class ClickHouseGenerator(generator.Generator):
     STRUCT_DELIMITER = ("(", ")")
     NVL2_SUPPORTED = False
     ALTER_SET_TYPE = "TYPE"
+    SUPPORTS_ALTER_COLUMN_IF_EXISTS = True
     TABLESAMPLE_REQUIRES_PARENS = False
     TABLESAMPLE_SIZE_IS_ROWS = False
     TABLESAMPLE_KEYWORDS = "SAMPLE"
@@ -398,7 +399,7 @@ class ClickHouseGenerator(generator.Generator):
 
     # There's no list in docs, but it can be found in Clickhouse code
     # see `ClickHouse/src/Parsers/ParserCreate*.cpp`
-    ON_CLUSTER_TARGETS = {
+    ON_CLUSTER_TARGETS: t.ClassVar = {
         "SCHEMA",  # Transpiled CREATE SCHEMA may have OnCluster property set
         "DATABASE",
         "TABLE",
@@ -410,7 +411,7 @@ class ClickHouseGenerator(generator.Generator):
     }
 
     # https://clickhouse.com/docs/en/sql-reference/data-types/nullable
-    NON_NULLABLE_TYPES = {
+    NON_NULLABLE_TYPES: t.ClassVar = {
         exp.DType.ARRAY,
         exp.DType.MAP,
         exp.DType.STRUCT,

{sqlglotc-30.15.0 → sqlglotc-30.16.0}/sqlglot/generators/doris.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import typing as t
+
 from sqlglot import exp
 from sqlglot.dialects.dialect import (
     approx_count_distinct_sql,
@@ -22,6 +24,7 @@ def _lag_lead_sql(self, expression: exp.Lag | exp.Lead) -> str:
 
 class DorisGenerator(MySQLGenerator):
     LAST_DAY_SUPPORTS_DATE_PART = False
+    SUPPORTS_ALTER_COLUMN_NULLABILITY = False
     VARCHAR_REQUIRES_SIZE = False
     WITH_PROPERTIES_PREFIX = "PROPERTIES"
     RENAME_TABLE_WITH_DB = False
@@ -41,8 +44,8 @@ class DorisGenerator(MySQLGenerator):
         exp.BuildProperty: exp.Properties.Location.POST_SCHEMA,
     }
 
-    CAST_MAPPING = {}
-    TIMESTAMP_FUNC_TYPES = set()
+    CAST_MAPPING: t.ClassVar[dict[exp.DType, str]] = {}
+    TIMESTAMP_FUNC_TYPES: t.ClassVar[set[exp.DType]] = set()
 
     TRANSFORMS = {
         **MySQLGenerator.TRANSFORMS,

{sqlglotc-30.15.0 → sqlglotc-30.16.0}/sqlglot/generators/duckdb.py

@@ -1951,7 +1951,7 @@ class DuckDBGenerator(generator.Generator):
     IGNORE_RESPECT_NULLS_WINDOW_FUNCTIONS: t.ClassVar = _IGNORE_RESPECT_NULLS_WINDOW_FUNCTIONS
 
     # Template for ZIPF transpilation - placeholders get replaced with actual parameters
-    ZIPF_TEMPLATE: exp.Expr = exp.maybe_parse(
+    ZIPF_TEMPLATE: t.ClassVar[exp.Expr] = exp.maybe_parse(
         """
         WITH rand AS (SELECT :random_expr AS r),
         weights AS (
@@ -1970,22 +1970,24 @@ class DuckDBGenerator(generator.Generator):
 
     # Template for NORMAL transpilation using Box-Muller transform
     # mean + (stddev * sqrt(-2 * ln(u1)) * cos(2 * pi * u2))
-    NORMAL_TEMPLATE: exp.Expr = exp.maybe_parse(
+    NORMAL_TEMPLATE: t.ClassVar[exp.Expr] = exp.maybe_parse(
         ":mean + (:stddev * SQRT(-2 * LN(GREATEST(:u1, 1e-10))) * COS(2 * PI() * :u2))"
     )
 
     # Template for generating a seeded pseudo-random value in [0, 1) from a hash
-    SEEDED_RANDOM_TEMPLATE: exp.Expr = exp.maybe_parse("(ABS(HASH(:seed)) % 1000000) / 1000000.0")
+    SEEDED_RANDOM_TEMPLATE: t.ClassVar[exp.Expr] = exp.maybe_parse(
+        "(ABS(HASH(:seed)) % 1000000) / 1000000.0"
+    )
 
     # Template for generating signed and unsigned SEQ values within a specified range
-    SEQ_UNSIGNED: exp.Expr = _SEQ_UNSIGNED
-    SEQ_SIGNED: exp.Expr = _SEQ_SIGNED
+    SEQ_UNSIGNED: t.ClassVar[exp.Expr] = _SEQ_UNSIGNED
+    SEQ_SIGNED: t.ClassVar[exp.Expr] = _SEQ_SIGNED
 
     # Template for MAP_CAT transpilation - Snowflake semantics:
     # 1. Returns NULL if either input is NULL
     # 2. For duplicate keys, prefers non-NULL value (COALESCE(m2[k], m1[k]))
     # 3. Filters out entries with NULL values from the result
-    MAPCAT_TEMPLATE: exp.Expr = exp.maybe_parse(
+    MAPCAT_TEMPLATE: t.ClassVar[exp.Expr] = exp.maybe_parse(
         """
         CASE
             WHEN :map1 IS NULL OR :map2 IS NULL THEN NULL
@@ -1999,7 +2001,7 @@ class DuckDBGenerator(generator.Generator):
 
     # Mappings for EXTRACT/DATE_PART transpilation
     # Maps Snowflake specifiers unsupported in DuckDB to strftime format codes
-    EXTRACT_STRFTIME_MAPPINGS: dict[str, tuple[str, str]] = {
+    EXTRACT_STRFTIME_MAPPINGS: t.ClassVar[dict[str, tuple[str, str]]] = {
         "WEEKISO": ("%V", "INTEGER"),
         "YEAROFWEEK": ("%G", "INTEGER"),
         "YEAROFWEEKISO": ("%G", "INTEGER"),
@@ -2007,7 +2009,7 @@ class DuckDBGenerator(generator.Generator):
     }
 
     # Maps epoch-based specifiers to DuckDB epoch functions
-    EXTRACT_EPOCH_MAPPINGS: dict[str, str] = {
+    EXTRACT_EPOCH_MAPPINGS: t.ClassVar[dict[str, str]] = {
         "EPOCH_SECOND": "EPOCH",
         "EPOCH_MILLISECOND": "EPOCH_MS",
         "EPOCH_MICROSECOND": "EPOCH_US",
@@ -2057,7 +2059,7 @@ class DuckDBGenerator(generator.Generator):
     #   - Large format: Fixed 10-byte header + values (no padding needed)
     #   Result: Complete binary bitmap as BLOB
     #
-    BITMAP_CONSTRUCT_AGG_TEMPLATE: exp.Expr = exp.maybe_parse(
+    BITMAP_CONSTRUCT_AGG_TEMPLATE: t.ClassVar[exp.Expr] = exp.maybe_parse(
         """
         SELECT CASE
             WHEN l IS NULL OR LENGTH(l) = 0 THEN NULL
@@ -2076,7 +2078,7 @@ class DuckDBGenerator(generator.Generator):
     )
 
     # Template for RANDSTR transpilation - placeholders get replaced with actual parameters
-    RANDSTR_TEMPLATE: exp.Expr = exp.maybe_parse(
+    RANDSTR_TEMPLATE: t.ClassVar[exp.Expr] = exp.maybe_parse(
         f"""
         SELECT LISTAGG(
             SUBSTRING(
@@ -2096,7 +2098,7 @@ class DuckDBGenerator(generator.Generator):
     # Template for MINHASH transpilation
     # Computes k minimum hash values across aggregated data using DuckDB list functions
     # Returns JSON matching Snowflake format: {"state": [...], "type": "minhash", "version": 1}
-    MINHASH_TEMPLATE: exp.Expr = exp.maybe_parse(
+    MINHASH_TEMPLATE: t.ClassVar[exp.Expr] = exp.maybe_parse(
         """
         SELECT JSON_OBJECT('state', LIST(min_h ORDER BY seed), 'type', 'minhash', 'version', 1)
         FROM (
@@ -2108,7 +2110,7 @@ class DuckDBGenerator(generator.Generator):
 
     # Template for MINHASH_COMBINE transpilation
     # Combines multiple minhash signatures by taking element-wise minimum
-    MINHASH_COMBINE_TEMPLATE: exp.Expr = exp.maybe_parse(
+    MINHASH_COMBINE_TEMPLATE: t.ClassVar[exp.Expr] = exp.maybe_parse(
         """
         SELECT JSON_OBJECT('state', LIST(min_h ORDER BY idx), 'type', 'minhash', 'version', 1)
         FROM (
@@ -2125,7 +2127,7 @@ class DuckDBGenerator(generator.Generator):
 
     # Template for APPROXIMATE_SIMILARITY transpilation
     # Computes multi-way Jaccard similarity: fraction of positions where ALL signatures agree
-    APPROXIMATE_SIMILARITY_TEMPLATE: exp.Expr = exp.maybe_parse(
+    APPROXIMATE_SIMILARITY_TEMPLATE: t.ClassVar[exp.Expr] = exp.maybe_parse(
         """
         SELECT CAST(SUM(CASE WHEN num_distinct = 1 THEN 1 ELSE 0 END) AS DOUBLE) / COUNT(*)
         FROM (
@@ -2143,7 +2145,7 @@ class DuckDBGenerator(generator.Generator):
     # Template for ARRAYS_ZIP transpilation
     # Snowflake pads to longest array; DuckDB LIST_ZIP truncates to shortest
     # Uses RANGE + indexing to match Snowflake behavior
-    ARRAYS_ZIP_TEMPLATE: exp.Expr = exp.maybe_parse(
+    ARRAYS_ZIP_TEMPLATE: t.ClassVar[exp.Expr] = exp.maybe_parse(
         """
         CASE WHEN :null_check THEN NULL
         WHEN :all_empty_check THEN [:empty_struct]
@@ -2152,7 +2154,7 @@ class DuckDBGenerator(generator.Generator):
         """,
     )
 
-    UUID_V5_TEMPLATE: exp.Expr = exp.maybe_parse(
+    UUID_V5_TEMPLATE: t.ClassVar[exp.Expr] = exp.maybe_parse(
         """
         (SELECT
             LOWER(
@@ -2176,7 +2178,7 @@ class DuckDBGenerator(generator.Generator):
     #   INTERSECTION (<=): keep the N-th occurrence only if N <= count in arr2
     #                      e.g. [2,2,2] INTERSECT [2,2] -> [2,2]
     # IS NOT DISTINCT FROM is used for NULL-safe element comparison.
-    ARRAY_BAG_TEMPLATE: exp.Expr = exp.maybe_parse(
+    ARRAY_BAG_TEMPLATE: t.ClassVar[exp.Expr] = exp.maybe_parse(
         """
         CASE
             WHEN :arr1 IS NULL OR :arr2 IS NULL THEN NULL
@@ -2191,12 +2193,12 @@ class DuckDBGenerator(generator.Generator):
         """
     )
 
-    ARRAY_EXCEPT_CONDITION: exp.Expr = exp.maybe_parse(
+    ARRAY_EXCEPT_CONDITION: t.ClassVar[exp.Expr] = exp.maybe_parse(
         "LEN(LIST_FILTER(:arr1[1:pair[1]], e -> e IS NOT DISTINCT FROM pair[0]))"
         " > LEN(LIST_FILTER(:arr2, e -> e IS NOT DISTINCT FROM pair[0]))"
     )
 
-    ARRAY_INTERSECTION_CONDITION: exp.Expr = exp.maybe_parse(
+    ARRAY_INTERSECTION_CONDITION: t.ClassVar[exp.Expr] = exp.maybe_parse(
         "LEN(LIST_FILTER(:arr1[1:pair[1]], e -> e IS NOT DISTINCT FROM pair[0]))"
         " <= LEN(LIST_FILTER(:arr2, e -> e IS NOT DISTINCT FROM pair[0]))"
     )
@@ -2205,7 +2207,7 @@ class DuckDBGenerator(generator.Generator):
     # filters out any element that appears at least once in arr2.
     #   e.g. [1,1,2,3] EXCEPT [1] -> [2,3]
     # IS NOT DISTINCT FROM is used for NULL-safe element comparison.
-    ARRAY_EXCEPT_SET_TEMPLATE: exp.Expr = exp.maybe_parse(
+    ARRAY_EXCEPT_SET_TEMPLATE: t.ClassVar[exp.Expr] = exp.maybe_parse(
         """
         CASE
             WHEN :arr1 IS NULL OR :arr2 IS NULL THEN NULL
@@ -2225,7 +2227,7 @@ class DuckDBGenerator(generator.Generator):
     #   1 IN UNNEST([])         -> FALSE
     # The default `IN (SELECT UNNEST(...))` rewrite creates a correlated subquery
     # that DuckDB rejects inside non-inner joins, so a CASE expression is used instead.
-    IN_UNNEST_TEMPLATE: exp.Expr = exp.maybe_parse(
+    IN_UNNEST_TEMPLATE: t.ClassVar[exp.Expr] = exp.maybe_parse(
         """
         CASE
             WHEN :arr IS NULL OR ARRAY_LENGTH(:arr) = 0 THEN FALSE
@@ -2236,7 +2238,7 @@ class DuckDBGenerator(generator.Generator):
         """
     )
 
-    STRTOK_TO_ARRAY_TEMPLATE: exp.Expr = exp.maybe_parse(
+    STRTOK_TO_ARRAY_TEMPLATE: t.ClassVar[exp.Expr] = exp.maybe_parse(
         """
         CASE WHEN :delimiter IS NULL THEN NULL
         ELSE LIST_FILTER(
@@ -2285,7 +2287,7 @@ class DuckDBGenerator(generator.Generator):
     #         x -> NOT x = ''
     #     )[index]
     # END
-    STRTOK_TEMPLATE: exp.Expr = exp.maybe_parse(
+    STRTOK_TEMPLATE: t.ClassVar[exp.Expr] = exp.maybe_parse(
         """
         CASE
             WHEN :delimiter = '' AND :string = '' THEN NULL