sqlglotc 30.8.0__tar.gz → 30.11.0__tar.gz

{sqlglotc-30.8.0/sqlglotc.egg-info → sqlglotc-30.11.0}/PKG-INFO

@@ -1,13 +1,15 @@
 Metadata-Version: 2.4
 Name: sqlglotc
-Version: 30.8.0
+Version: 30.11.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.11.0
 Provides-Extra: dev
 Requires-Dist: setuptools>=61.0; extra == "dev"
 Requires-Dist: setuptools_scm; extra == "dev"
-Requires-Dist: sqlglot-mypy>=1.20.0.post6; extra == "dev"
+Requires-Dist: sqlglot-mypy>=2.1.0.post2; extra == "dev"
+Dynamic: requires-dist

{sqlglotc-30.8.0 → sqlglotc-30.11.0}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "sqlglotc"
-dynamic = ["version"]
+dynamic = ["version", "dependencies"]
 description = "mypyc-compiled extensions for sqlglot"
 authors = [{ name = "Toby Mao", email = "toby.mao@gmail.com" }]
 license = "MIT"
 requires-python = ">= 3.10"
 
 [project.optional-dependencies]
-dev = ["setuptools >= 61.0", "setuptools_scm", "sqlglot-mypy >= 1.20.0.post6"]
+dev = ["setuptools >= 61.0", "setuptools_scm", "sqlglot-mypy >= 2.1.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 >= 1.20.0.post6",
+    "sqlglot-mypy >= 2.1.0.post2",
     "types-python-dateutil",
     "sqlglot",
 ]

{sqlglotc-30.8.0 → sqlglotc-30.11.0}/setup.py

@@ -128,9 +128,42 @@ class sdist(_sdist):
             shutil.rmtree(local_sqlglot, ignore_errors=True)
 
 
+def _sqlglot_requirement():
+    """Pin sqlglot to the matching version so resolvers keep the two packages in lockstep."""
+    try:
+        pkg_info = os.path.join(os.path.dirname(os.path.abspath(__file__)), "PKG-INFO")
+        if os.path.isfile(pkg_info):
+            # Building from an sdist: no git metadata; the released version is frozen in PKG-INFO.
+            with open(pkg_info, encoding="utf-8") as fd:
+                version = next(
+                    (line.split(":", 1)[1].strip() for line in fd if line.startswith("Version:")),
+                    "",
+                )
+        else:
+            from setuptools_scm import get_version
+
+            version = get_version(
+                root="..",
+                relative_to=__file__,
+                local_scheme="no-local-version",
+                fallback_version="0.0.0",
+            )
+    except Exception as e:
+        print(f"sqlglotc: failed to determine the sqlglot version to pin: {e}")
+        version = ""
+
+    # Dev and fallback (no git metadata) builds have no matching sqlglot release on PyPI;
+    # depend on sqlglot unpinned since the extensions can't be imported without it.
+    if version in ("", "0.0.0") or ".dev" in version:
+        return ["sqlglot"]
+
+    return [f"sqlglot=={version}"]
+
+
 setup(
     name="sqlglotc",
     packages=[],
+    install_requires=_sqlglot_requirement(),
     ext_modules=mypycify(
         _source_paths(), opt_level=os.environ.get("MYPYC_OPT", "2"), separate=True, verbose=True
     ),

{sqlglotc-30.8.0 → sqlglotc-30.11.0}/sqlglot/expressions/aggregate.py

@@ -208,7 +208,7 @@ class NthValue(Expression, AggFunc):
 
 
 class ObjectAgg(Expression, AggFunc):
-    arg_types = {"this": True, "expression": True}
+    arg_types = {"this": True, "expression": False}
 
 
 class PercentileCont(Expression, AggFunc):

{sqlglotc-30.8.0 → sqlglotc-30.11.0}/sqlglot/expressions/builders.py

@@ -319,6 +319,11 @@ def parse_identifier(name: str | Identifier, dialect: DialectType = None) -> Ide
     Returns:
         The identifier ast node.
     """
+    if isinstance(name, str) and SAFE_IDENTIFIER_RE.match(name):
+        # Simple names parse to a single unquoted identifier in all dialects, so we can
+        # avoid the tokenizer/parser round-trip for them.
+        return Identifier(this=name, quoted=False)
+
     try:
         expression = maybe_parse(name, dialect=dialect, into=Identifier)
     except (ParseError, TokenError):
@@ -822,7 +827,7 @@ def replace_tables(
     mapping = {normalize_table_name(k, dialect=dialect): v for k, v in mapping.items()}
 
     def _replace_tables(node: Expr) -> Expr:
-        if isinstance(node, Table) and node.meta.get("replace") is not False:
+        if isinstance(node, Table) and node.meta_get("replace") is not False:
             original = normalize_table_name(node, dialect=dialect)
             new_name = mapping.get(original)
 

{sqlglotc-30.8.0 → sqlglotc-30.11.0}/sqlglot/expressions/core.py

@@ -88,6 +88,7 @@ class Expr:
     _hash_raw_args: t.ClassVar[bool] = False
     is_subquery: t.ClassVar[bool] = False
     is_cast: t.ClassVar[bool] = False
+    is_data_type: t.ClassVar[bool] = False
 
     args: dict[str, t.Any]
     parent: Expr | None
@@ -239,6 +240,9 @@ class Expr:
     def meta(self) -> dict[str, t.Any]:
         raise NotImplementedError
 
+    def meta_get(self, key: str, default: t.Any = None) -> t.Any:
+        raise NotImplementedError
+
     def __deepcopy__(self, memo: t.Any) -> Expr:
         raise NotImplementedError
 
@@ -837,26 +841,35 @@ class Expression(Expr):
     def __hash__(self) -> int:
         if self._hash is None:
             nodes: list[Expr] = []
-            queue: deque[Expr] = deque()
-            queue.append(self)
+            stack: list[Expr] = [self]
 
-            while queue:
-                node = queue.popleft()
+            # Collect nodes, finding child expressions inline instead of via the
+            # iter_expressions generator (whose per-node generator object dominates the
+            # hash's cost). reversed(nodes) is a valid post-order regardless of DFS/BFS.
+            while stack:
+                node = stack.pop()
                 nodes.append(node)
 
-                for child in node.iter_expressions():
-                    if child._hash is None:
-                        queue.append(child)
+                for v in node.args.values():
+                    if isinstance(v, Expr):
+                        if v._hash is None:
+                            stack.append(v)
+                    elif type(v) is list:
+                        for x in v:
+                            if isinstance(x, Expr) and x._hash is None:
+                                stack.append(x)
 
             for node in reversed(nodes):
                 hash_ = hash(node.key)
 
                 if node._hash_raw_args:
-                    for k, v in sorted(node.args.items()):
+                    for k in sorted(node.args):
+                        v = node.args[k]
                         if v:
                             hash_ = hash((hash_, k, v))
                 else:
-                    for k, v in sorted(node.args.items()):
+                    for k in sorted(node.args):
+                        v = node.args[k]
                         vt = type(v)
 
                         if vt is list:
@@ -953,6 +966,8 @@ class Expression(Expr):
 
     @property
     def type(self) -> DataType | None:
+        if self.is_data_type:
+            return self  # type: ignore[return-value]
         if self.is_cast:
             return self._type or self.to  # type: ignore[attr-defined]
         return self._type
@@ -978,6 +993,11 @@ class Expression(Expr):
             self._meta = {}
         return self._meta
 
+    def meta_get(self, key: str, default: t.Any = None) -> t.Any:
+        """Reads a meta value without allocating the meta dict (unlike the `meta` property)."""
+        meta = self._meta
+        return meta.get(key, default) if meta is not None else default
+
     def __deepcopy__(self, memo: t.Any) -> Expr:
         root = self.__class__()
         stack: list[tuple[Expr, Expr]] = [(self, root)]
@@ -1039,6 +1059,11 @@ class Expression(Expr):
         return comments
 
     def append(self, arg_key: str, value: t.Any) -> None:
+        node: Expr | None = self
+        while node and node._hash is not None:
+            node._hash = None
+            node = node.parent
+
         if type(self.args.get(arg_key)) is not list:
             self.args[arg_key] = []
         self._set_parent(arg_key, value)
@@ -2118,6 +2143,10 @@ class Distance(Expression, Binary):
     pass
 
 
+class DistanceNd(Expression, Binary):
+    pass
+
+
 class Escape(Expression, Binary):
     pass
 
@@ -2269,8 +2298,7 @@ class Or(Expression, Connector, Func):
 
 
 class Xor(Expression, Connector, Func):
-    arg_types = {"this": False, "expression": False, "expressions": False, "round_input": False}
-    is_var_len_args = True
+    arg_types = {"this": True, "expression": True, "round_input": False}
 
 
 class Pow(Expression, Binary, Func):
@@ -2428,6 +2456,7 @@ QUERY_MODIFIERS = {
     "settings": False,
     "format": False,
     "options": False,
+    "for_": False,
 }
 
 
@@ -2534,7 +2563,7 @@ def _to_s(node: t.Any, verbose: bool = False, level: int = 0, repr_str: bool = F
     if isinstance(node, Expr):
         args = {k: v for k, v in node.args.items() if (v is not None and v != []) or verbose}
 
-        if (node.type or verbose) and type(node).__name__ != "DataType":
+        if (node.type or verbose) and not node.is_data_type:
             args["_type"] = node.type
         if node.comments or verbose:
             args["_comments"] = node.comments

{sqlglotc-30.8.0 → sqlglotc-30.11.0}/sqlglot/expressions/datatypes.py

@@ -8,6 +8,7 @@ from enum import auto
 from sqlglot.helper import AutoName
 from sqlglot.errors import ErrorLevel, ParseError
 from sqlglot.expressions.core import (
+    Expr,
     Expression,
     _TimeUnit,
     Identifier,
@@ -17,13 +18,18 @@ from sqlglot.expressions.core import (
 from builtins import type as Type
 
 if t.TYPE_CHECKING:
+    from sqlglot._typing import DataTypeArgs
     from sqlglot.dialects.dialect import DialectType
-    from typing_extensions import Self
+    from typing_extensions import Self, Unpack
 
 
 class DataTypeParam(Expression):
     arg_types = {"this": True, "expression": False}
 
+    @property
+    def this(self) -> Expr:
+        return self.args["this"]
+
     @property
     def name(self) -> str:
         return self.this.name
@@ -181,6 +187,8 @@ class DataType(Expression):
         "collate": False,
     }
 
+    is_data_type: t.ClassVar[bool] = True
+
     Type: t.ClassVar[Type[DType]] = DType
 
     STRUCT_TYPES: t.ClassVar[set[DType]] = {
@@ -331,7 +339,7 @@ class DataType(Expression):
         dialect: DialectType = None,
         udt: bool = False,
         copy: bool = True,
-        **kwargs: object,
+        **kwargs: Unpack[DataTypeArgs],
     ) -> Self:
         """
         Constructs a DataType object.
@@ -364,7 +372,11 @@ class DataType(Expression):
 
     @classmethod
     def from_str(
-        cls, dtype: str, dialect: DialectType = None, udt: bool = False, **kwargs: object
+        cls,
+        dtype: str,
+        dialect: DialectType = None,
+        udt: bool = False,
+        **kwargs: Unpack[DataTypeArgs],
     ) -> Self:
         """
         Constructs a `DataType` object from a `str` representation.
@@ -405,10 +417,10 @@ class DataType(Expression):
         Returns:
             True, if and only if there is a type in `dtypes` which is equal to this DataType.
         """
-        self_is_nullable = self.args.get("nullable")
+        self_is_nullable: bool | None = self.args.get("nullable")
         for dtype in dtypes:
             other_type = DataType.build(dtype, copy=False, udt=True)
-            other_is_nullable = other_type.args.get("nullable")
+            other_is_nullable: bool | None = other_type.args.get("nullable")
             if (
                 other_type.expressions
                 or (check_nullable and (self_is_nullable or other_is_nullable))

{sqlglotc-30.8.0 → sqlglotc-30.11.0}/sqlglot/expressions/ddl.py

@@ -226,6 +226,14 @@ class UserDefinedFunction(Expression):
     arg_types = {"this": True, "expressions": False, "wrapped": False}
 
 
+class MacroOverloads(Expression):
+    arg_types = {"expressions": True}
+
+
+class MacroOverload(Expression):
+    arg_types = {"this": True, "expressions": False, "is_table": False}
+
+
 class CharacterSet(Expression):
     arg_types = {"this": True, "default": False}
 

{sqlglotc-30.8.0 → sqlglotc-30.11.0}/sqlglot/expressions/dml.py

@@ -283,6 +283,7 @@ class LoadData(Expression):
         "this": True,
         "local": False,
         "overwrite": False,
+        "temp": False,
         "inpath": False,
         "files": False,
         "partition": False,

{sqlglotc-30.8.0 → sqlglotc-30.11.0}/sqlglot/expressions/functions.py

@@ -70,7 +70,12 @@ class Cast(Expression, Func):
 
 
 class TryCast(Cast):
-    arg_types = {**Cast.arg_types, "requires_string": False}
+    arg_types = {
+        **Cast.arg_types,
+        "requires_string": False,
+        "null_on_text_overflow": False,
+        "probe_date_format": False,
+    }
 
 
 class JSONCast(Cast):
@@ -436,6 +441,10 @@ class XMLElement(Expression, Func):
     arg_types = {"this": True, "expressions": False, "evalname": False}
 
 
+class GetIgnoreCase(Expression, Func):
+    arg_types = {"this": True, "expression": True}
+
+
 class XMLGet(Expression, Func):
     _sql_names = ["XMLGET"]
     arg_types = {"this": True, "expression": True, "instance": False}

{sqlglotc-30.8.0 → sqlglotc-30.11.0}/sqlglot/expressions/properties.py

@@ -75,6 +75,10 @@ class ChecksumProperty(Property):
     arg_types = {"on": False, "default": False}
 
 
+class ClusterProperty(Property):
+    arg_types = {"this": False, "expressions": False}
+
+
 class CollateProperty(Property):
     arg_types = {"this": True, "default": False}
 

{sqlglotc-30.8.0 → sqlglotc-30.11.0}/sqlglot/expressions/query.py

@@ -859,8 +859,8 @@ class SkipJSONColumn(Expression):
     arg_types = {"regexp": False, "expression": True}
 
 
-class Cluster(Order):
-    pass
+class Cluster(Expression):
+    arg_types = {"expressions": True}
 
 
 class Distribute(Order):
@@ -915,6 +915,11 @@ class QueryOption(Expression):
     arg_types = {"this": True, "expression": False}
 
 
+# FOR { XML | JSON } query modifier; `kind` is the discriminant ("XML" or "JSON").
+class ForClause(Expression):
+    arg_types = {"kind": True, "expressions": False}
+
+
 class WithTableHint(Expression):
     arg_types = {"expressions": True}
 
@@ -1266,8 +1271,8 @@ class Select(Expression, Query):
         Set the CLUSTER BY expression.
 
         Example:
-            >>> Select().from_("tbl").select("x").cluster_by("x DESC").sql(dialect="hive")
-            'SELECT x FROM tbl CLUSTER BY x DESC'
+            >>> Select().from_("tbl").select("x").cluster_by("x").sql(dialect="hive")
+            'SELECT x FROM tbl CLUSTER BY x'
 
         Args:
             *expressions: the SQL code strings to parse.
@@ -1753,6 +1758,9 @@ class Pivot(Expression):
         "default_on_null": False,
         "into": False,
         "with_": False,
+        "identify_pivot_strings": False,
+        "prefixed_pivot_columns": False,
+        "pivot_column_naming": False,
     }
 
     @property

{sqlglotc-30.8.0 → sqlglotc-30.11.0}/sqlglot/expressions/string.py

@@ -375,6 +375,7 @@ class ToNumber(Expression, Func):
         "scale": False,
         "safe": False,
         "safe_name": False,
+        "default": False,
     }