ydb-sqlglot-plugin 0.2.0__tar.gz → 0.2.2__tar.gz

{ydb_sqlglot_plugin-0.2.0 → ydb_sqlglot_plugin-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ydb-sqlglot-plugin
-Version: 0.2.0
+Version: 0.2.2
 Summary: YDB dialect plugin for sqlglot
 Author: YDB Team
 License: Apache-2.0

{ydb_sqlglot_plugin-0.2.0 → ydb_sqlglot_plugin-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ydb-sqlglot-plugin"
-version = "0.2.0"  # AUTOVERSION
+version = "0.2.2"  # AUTOVERSION
 description = "YDB dialect plugin for sqlglot"
 readme = "README.md"
 license = {text = "Apache-2.0"}

ydb_sqlglot_plugin-0.2.2/ydb_sqlglot/version.py

@@ -0,0 +1 @@
+VERSION = "0.2.2"

{ydb_sqlglot_plugin-0.2.0 → ydb_sqlglot_plugin-0.2.2}/ydb_sqlglot/ydb.py

@@ -1,3 +1,4 @@
+import inspect as _inspect
 import re
 import typing as t
 
@@ -403,26 +404,6 @@ def _apply_subquery_alias_columns(expression: exp.Expression) -> None:
         alias.set("columns", [])
 
 
-def _has_implicit_cross_join(expression: exp.Expression) -> bool:
-    """Return True if the expression tree contains an implicit cross join.
-
-    An implicit cross join arises from comma-separated FROM tables, e.g.
-    ``FROM t1, t2``.  In the sqlglot AST this appears as a ``Join`` node
-    with no ``kind``, no ``on`` clause, and no ``using`` clause.
-    YDB disables implicit cross joins by default; callers can prepend
-    ``PRAGMA AnsiImplicitCrossJoin;`` when this returns True.
-    """
-    for node in expression.walk():
-        if isinstance(node, exp.Join):
-            if (
-                not node.args.get("kind")
-                and not node.args.get("on")
-                and not node.args.get("using")
-            ):
-                return True
-    return False
-
-
 class FlattenBy(exp.Expression):
     """YDB-specific FLATTEN [LIST|DICT] BY clause on a table reference."""
     arg_types = {"this": True, "expressions": True, "kind": False}
@@ -446,6 +427,13 @@ _YDB_GENERIC_TYPES = {
 }
 
 
+# sqlglot >= 30.0.0 changed Parser.expression() to take a pre-built instance instead of
+# (cls, **kwargs). Detect once so the YDB parser override below can support both APIs.
+_EXPRESSION_TAKES_INSTANCE = (
+    "instance" in _inspect.signature(parser.Parser.expression).parameters
+)
+
+
 def _reassemble_ctes(
     statements: t.List[t.Optional[exp.Expression]],
 ) -> t.List[t.Optional[exp.Expression]]:
@@ -602,6 +590,38 @@ class YDB(Dialect):
             statements = super().parse(raw_tokens, sql)
             return _reassemble_ctes(statements)
 
+        def expression(self, exp_class_or_instance, token=None, comments=None, **kwargs):
+            """Bridge sqlglot's two `Parser.expression()` calling conventions.
+
+            sqlglot < 30 expects ``expression(cls, **kwargs)`` and instantiates internally.
+            sqlglot >= 30 expects a pre-built ``expression(instance)`` and rejects kwargs.
+            Several call sites in this dialect (and a few in upstream code paths we exercise)
+            mix both styles, so normalise here before delegating.
+            """
+            if _EXPRESSION_TAKES_INSTANCE:
+                if not isinstance(exp_class_or_instance, exp.Expression):
+                    exp_class_or_instance = exp_class_or_instance(**kwargs)
+                return super().expression(
+                    exp_class_or_instance, token=token, comments=comments
+                )
+
+            if isinstance(exp_class_or_instance, exp.Expression):
+                # Old super() would attempt instance(**kwargs) -> "object is not callable".
+                instance = exp_class_or_instance
+                if token is not None:
+                    update_positions = getattr(instance, "update_positions", None)
+                    if update_positions is not None:
+                        update_positions(token)
+                if comments:
+                    instance.add_comments(comments)
+                else:
+                    self._add_comments(instance)
+                return self.validate_expression(instance)
+
+            return super().expression(
+                exp_class_or_instance, token=token, comments=comments, **kwargs
+            )
+
         def _parse_dcolon(self) -> t.Optional[exp.Expression]:
             return self._parse_function(anonymous=True) or self._parse_var(any_token=True)
 
@@ -779,7 +799,9 @@ class YDB(Dialect):
 
         def _parse_lambda_body(self, params):
             if (
-                    self._curr.token_type != TokenType.R_PAREN
+                    self._curr is None
+                    or self._curr.token_type != TokenType.R_PAREN
+                    or self._next is None
                     or self._next.token_type != TokenType.ARROW
             ):
                 return None
@@ -1384,12 +1406,6 @@ class YDB(Dialect):
             else:
                 sql = self._generate_create_table(expression)
 
-            # Prepend PRAGMA AnsiImplicitCrossJoin only when the query contains
-            # implicit cross joins (FROM t1, t2 syntax).  YDB disables them by
-            # default; the pragma restores standard SQL semantics.
-            if _has_implicit_cross_join(expression):
-                sql = "PRAGMA AnsiImplicitCrossJoin;\n" + sql
-
             return sql
 
         def unnest_subqueries(self, expression):
@@ -2180,15 +2196,15 @@ class YDB(Dialect):
         # we move the WHERE expression from ON, using literals
         def join_sql(self, expression: exp.Join) -> str:
             on_condition = expression.args.get("on")
-            join_kind = expression.kind or ""
-
-            # If LEFT/RIGHT/FULL JOIN has no ON clause, convert to CROSS JOIN
-            # YDB requires LEFT JOINs to have an ON clause
-            if not on_condition and any(
-                    kind in join_kind.upper() for kind in ["LEFT", "RIGHT", "FULL", "OUTER", ""]
-            ):
-                expression.set("kind", None)
-                expression.set("on", None)
+            using = expression.args.get("using")
+
+            # Any join with no ON/USING clause becomes an explicit CROSS JOIN.
+            # YDB requires an ON clause for outer joins, and emitting CROSS JOIN
+            # explicitly (instead of the comma-separated form) keeps the output
+            # valid without any extra pragma.
+            if not on_condition and not using:
+                expression.set("kind", "CROSS")
+                expression.set("side", None)
                 return super().join_sql(expression)
 
             if on_condition:
@@ -2256,18 +2272,11 @@ class YDB(Dialect):
                             on_condition = exp.and_(on_condition, cond)
                     expression.set("on", on_condition)
                 else:
-                    # No valid equality conditions
-                    # For LEFT/RIGHT/FULL JOINs, YDB requires ON clause, so convert to CROSS JOIN
-                    join_kind = expression.side or ""
-                    if any(
-                            kind in join_kind.upper() for kind in ["LEFT", "RIGHT", "FULL", "OUTER"]
-                    ):
-                        # Convert to CROSS JOIN by removing kind and ON
-                        expression.set("kind", None)
-                        expression.set("on", None)
-                        expression.set("side", "CROSS")
-                    else:
-                        expression.set("on", None)
+                    # No valid equality conditions remain on the JOIN — fall back
+                    # to an explicit CROSS JOIN regardless of the original kind.
+                    expression.set("kind", "CROSS")
+                    expression.set("on", None)
+                    expression.set("side", None)
 
                 if conditions_to_move:
                     select_stmt = expression.find_ancestor(exp.Select)

{ydb_sqlglot_plugin-0.2.0 → ydb_sqlglot_plugin-0.2.2}/ydb_sqlglot_plugin.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ydb-sqlglot-plugin
-Version: 0.2.0
+Version: 0.2.2
 Summary: YDB dialect plugin for sqlglot
 Author: YDB Team
 License: Apache-2.0

ydb_sqlglot_plugin-0.2.0/ydb_sqlglot/version.py

@@ -1 +0,0 @@
-VERSION = "0.2.0"