sqlglotc 30.15.0__tar.gz → 30.17.0__tar.gz

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

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

{sqlglotc-30.15.0 → sqlglotc-30.17.0}/pyproject.toml

@@ -7,7 +7,7 @@ license = "MIT"
 requires-python = ">= 3.10"
 
 [project.optional-dependencies]
-dev = ["setuptools >= 61.0", "setuptools_scm", "sqlglot-mypy >= 2.1.0.post9"]
+dev = ["setuptools >= 61.0", "setuptools_scm", "sqlglot-mypy >= 2.3.0.post1"]
 
 [project.urls]
 Homepage = "https://sqlglot.com/"
@@ -17,7 +17,7 @@ Repository = "https://github.com/tobymao/sqlglot"
 requires = [
     "setuptools >= 61.0",
     "setuptools_scm",
-    "sqlglot-mypy >= 2.1.0.post9",
+    "sqlglot-mypy >= 2.3.0.post1",
     "types-python-dateutil",
     "sqlglot",
 ]

{sqlglotc-30.15.0 → sqlglotc-30.17.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.17.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.17.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)}
 
@@ -1696,7 +1699,16 @@ class AggFunc(Func):
 
 
 class Column(Expression, Condition):
-    arg_types = {"this": True, "table": False, "db": False, "catalog": False, "join_mark": False}
+    # "shadow" marks a column whose qualifier is shadowed by a projection alias, so it must be
+    # rendered unqualified in dialects where PROJECTION_ALIASES_SHADOW_SOURCE_NAMES is set
+    arg_types = {
+        "this": True,
+        "table": False,
+        "db": False,
+        "catalog": False,
+        "join_mark": False,
+        "shadow": False,
+    }
 
     @property
     def table(self) -> str:
@@ -1764,7 +1776,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 +2134,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 +2246,7 @@ class Sub(Expression, Binary):
     pass
 
 
-class Adjacent(Expression, Binary):
+class Adjacent(Expression, Binary, Predicate):
     pass
 
 
@@ -2317,7 +2332,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.17.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.17.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.17.0}/sqlglot/expressions/query.py

@@ -1050,6 +1050,11 @@ class SetOperation(Expression, Query):
     def named_selects(self) -> list[str]:
         expr: Expr = self
         while isinstance(expr, SetOperation):
+            if expr.args.get("by_name"):
+                left = t.cast(Selectable, expr.this.unnest()).named_selects
+                right = t.cast(Selectable, expr.expression.unnest()).named_selects
+                return list(dict.fromkeys(left + right))
+
             expr = expr.this.unnest()
         return _named_selects(expr)
 
@@ -2119,8 +2124,28 @@ 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}
+    arg_types = {"this": True, "body": True, "label": False}
+
+
+class LoopBlock(Expression):
+    arg_types = {"body": True, "label": False}
+
+
+class RepeatBlock(Expression):
+    arg_types = {"body": True, "until": True, "label": False}
+
+
+class Leave(Expression):
+    pass
+
+
+class Iterate(Expression):
+    pass
 
 
 class EndStatement(Expression):

{sqlglotc-30.15.0 → sqlglotc-30.17.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.17.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
 
@@ -1144,6 +1151,10 @@ class Generator:
         return f"{default}CHARACTER SET={self.sql(expression, 'this')}"
 
     def column_parts(self, expression: exp.Column) -> str:
+        if expression.args.get("shadow") and self.dialect.PROJECTION_ALIASES_SHADOW_SOURCE_NAMES:
+            # The qualifier would be captured by a colliding projection alias (see qualify_columns)
+            return self.sql(expression, "this")
+
         return ".".join(
             self.sql(part)
             for part in (
@@ -1642,10 +1653,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 +1669,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 +1721,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 +4218,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 +4232,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 +4259,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"
 
-        return f"ALTER COLUMN {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 " NULL" if allow_null else " NOT NULL"
 
     def modifycolumn_sql(self, expression: exp.ModifyColumn) -> str:
         this = self.sql(expression, "this")
@@ -6272,10 +6315,30 @@ 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 ""
 
+    def loopblock_sql(self, expression: exp.LoopBlock) -> str:
+        self.unsupported("Unsupported Loop block syntax")
+        return ""
+
+    def repeatblock_sql(self, expression: exp.RepeatBlock) -> str:
+        self.unsupported("Unsupported Repeat block syntax")
+        return ""
+
+    def leave_sql(self, expression: exp.Leave) -> str:
+        self.unsupported("Unsupported Leave syntax")
+        return ""
+
+    def iterate_sql(self, expression: exp.Iterate) -> str:
+        self.unsupported("Unsupported Iterate syntax")
+        return ""
+
     def execute_sql(self, expression: exp.Execute) -> str:
         self.unsupported("Unsupported Execute syntax")
         return ""

{sqlglotc-30.15.0 → sqlglotc-30.17.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.17.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.17.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,