fix(cypher): harden cartesian OR/XOR pattern guard via AST (#1391)

Author: lmeyerov

graphistry/compute/gfql/cypher/lowering.py

@@ -122,12 +122,7 @@
     rewrite_temporal_constructors_in_expr,
 )
 from graphistry.compute.gfql.same_path_types import WhereComparison, col, compare
-# #1295 / #1260 S2 — bounded reentry helpers extracted to focused subpackage.
-# These are re-exported here to keep existing imports
-# (``from graphistry.compute.gfql.cypher.lowering import _reentry_hidden_column_name``)
-# working unchanged across the codebase. The moved modules import this module
-# lazily inside function bodies for the few helpers (``_unsupported``,
-# ``_render_expr_node``, etc.) they still need from lowering.py.
+# Reentry helpers moved to focused subpackages and are re-exported here for compatibility.
 from graphistry.compute.gfql.cypher.reentry.naming import (
     _is_hidden_reentry_property,
     _reentry_hidden_column_name,
@@ -5637,12 +5632,7 @@ def _is_variable_length_relationship_pattern(relationship: RelationshipPattern)
 
 
 def _reject_nonterminal_variable_length_relationship_patterns(query: CypherQuery) -> None:  # noqa: ARG001
-    """No-op: variable-length rels in connected patterns are now supported.
-
-    The lowering sets ``prune_to_endpoints=True`` on non-terminal
-    variable-length edges so the next hop starts from the correct
-    wavefront endpoints only.  See #1001 for reentry-match follow-up.
-    """
+    """No-op: variable-length relationships in connected patterns are supported."""
 
 
 def _variable_length_relationship_aliases(
@@ -6231,9 +6221,19 @@ def lower_match_query(
     row_where: Optional[ExpressionText] = None
     row_where_predicates: List[str] = list(dynamic_row_where_predicates)
     if query.where is not None:
-        where_expr_upper = boolean_expr_to_text(query.where.expr_tree).upper() if query.where.expr_tree is not None else ""
-        if _cartesian_node_only_patterns(merged_match) is not None and query.where.expr_tree is not None and _where_expr_tree_pattern_predicates(query.where.expr_tree) and (" OR " in where_expr_upper or " XOR " in where_expr_upper):
-            raise _unsupported_at_span("Cypher WHERE pattern predicates mixed with OR/XOR are not yet supported for cartesian MATCH patterns", field="where", value=where_expr_upper, span=query.where.span)
+        if _cartesian_node_only_patterns(merged_match) is not None and query.where.expr_tree is not None:
+            where_expr_upper = boolean_expr_to_text(query.where.expr_tree).upper()
+            stack: List[BooleanExpr] = [query.where.expr_tree]
+            while stack:
+                cur = stack.pop()
+                left = cast(Optional[BooleanExpr], cur.left)
+                right = cast(Optional[BooleanExpr], cur.right)
+                if cur.op in {"or", "xor"} and ((left is not None and _where_expr_tree_pattern_predicates(left)) or (right is not None and _where_expr_tree_pattern_predicates(right))):
+                    raise _unsupported_at_span("Cypher WHERE pattern predicates mixed with OR/XOR are not yet supported for cartesian MATCH patterns", field="where", value=where_expr_upper, span=query.where.span)
+                if left is not None:
+                    stack.append(left)
+                if right is not None:
+                    stack.append(right)
         where_expr, where_pattern_row_filters = _rewrite_where_expr_patterns_to_markers(
             where=query.where,
             alias_targets=alias_targets,

graphistry/tests/compute/gfql/cypher/test_lowering.py

@@ -1574,6 +1574,33 @@ def test_string_cypher_rejects_cartesian_where_pattern_predicates_mixed_with_or(
         )
 
 
+def test_string_cypher_rejects_cartesian_where_pattern_predicates_mixed_with_xor() -> None:
+    graph = _mk_graph(
+        pd.DataFrame({"id": [0, 1], "label__TheLabel": [False, True]}),
+        pd.DataFrame({"s": [0], "d": [1], "type": ["T"]}),
+    )
+    with pytest.raises(GFQLValidationError, match="OR/XOR"):
+        graph.gfql(
+            "MATCH (a), (b) "
+            "WHERE (a)-[:T]->(b:TheLabel) XOR a.id = 0 "
+            "RETURN DISTINCT b"
+        )
+
+
+def test_string_cypher_supports_cartesian_scalar_or_without_pattern_predicates() -> None:
+    result = _mk_cartesian_node_graph().gfql(
+        "MATCH (a), (b) "
+        "WHERE a.num = 1 OR b.num = 1 "
+        "RETURN a.num AS a_num, b.num AS b_num "
+        "ORDER BY a_num, b_num"
+    )
+    assert result._nodes.to_dict(orient="records") == [
+        {"a_num": 1, "b_num": 1},
+        {"a_num": 1, "b_num": 2},
+        {"a_num": 2, "b_num": 1},
+    ]
+
+
 def test_string_cypher_supports_cartesian_dynamic_pattern_property_projection() -> None:
     graph = _mk_cartesian_dynamic_pattern_graph()