fix(gfql/cypher): close wave-3 alias resolution and reentry where gaps (#1072)

Author: lmeyerov

graphistry/compute/gfql/cypher/lowering.py

@@ -5865,9 +5865,24 @@ def _where_clause_expr_text(where: WhereClause) -> Optional[ExpressionText]:
     derived from the same ``_span_from_meta(meta)`` of the
     ``generic_where_clause`` rule) to preserve error-position semantics.
     """
-    if where.expr_tree is None:
-        return None
-    return ExpressionText(text=boolean_expr_to_text(where.expr_tree), span=where.span)
+    if where.expr_tree is not None:
+        return ExpressionText(text=boolean_expr_to_text(where.expr_tree), span=where.span)
+
+    # Structured-predicate WHERE clauses can still require downstream rewrite
+    # (for example, multi-alias re-entry secondary carry demotion).  Synthesize
+    # equivalent row-expression text when all predicates are row-renderable.
+    if where.predicates:
+        predicate_texts: List[str] = []
+        for predicate in where.predicates:
+            if not isinstance(predicate, WherePredicate):
+                return None
+            row_text = _row_where_predicate_text(predicate)
+            if row_text is None:
+                return None
+            predicate_texts.append(row_text)
+        if predicate_texts:
+            return ExpressionText(text=" and ".join(predicate_texts), span=where.span)
+    return None
 
 
 def _rewrite_where_clause_and_resync(
@@ -5898,7 +5913,10 @@ def _rewrite_where_clause_and_resync(
         atom_text=rewritten.text,
         atom_span=rewritten.span,
     )
-    return replace(where, expr_tree=new_tree)
+    rewritten_where = replace(where, expr_tree=new_tree)
+    if where.expr_tree is None and where.predicates:
+        rewritten_where = replace(rewritten_where, predicates=())
+    return rewritten_where
 
 
 def _extract_relationship_type_where(

graphistry/compute/gfql/row/entity_props.py

@@ -374,7 +374,11 @@ def format_edge_entity_text(
     if type_col in df.columns:
         type_series = cast(SeriesT, df[type_col])
         type_text = _object_text(cast(SeriesT, type_series.astype(str)))
-        type_part = cast(SeriesT, (_const_text(df, alias_col, ":") + type_text).where(~_is_null_mask(type_series), ""))
+        include_type = cast(SeriesT, ~_is_null_mask(type_series))
+        if hasattr(type_text, "str"):
+            non_blank = cast(SeriesT, type_text.str.strip() != "")
+            include_type = cast(SeriesT, include_type & non_blank)
+        type_part = cast(SeriesT, (_const_text(df, alias_col, ":") + type_text).where(include_type, ""))
     else:
         type_part = _empty_text(df, alias_col)
     prop_text, has_props = append_property_segments(df, alias_col, property_columns)

graphistry/compute/gfql/row/pipeline.py

@@ -2297,23 +2297,19 @@ def _gfql_resolve_token(self, table_df: Any, token: str) -> Any:
         # identity column (alias.{node_id_col}).  This lets expressions like
         # count(post) work when the table has post.id, post.name, etc. (#880)
         if "." not in txt and RowPipelineMixin._gfql_has_bindings_alias_prefix(table_df, txt):
+            edge_aliases = getattr(self, "_gfql_rows_edge_aliases", None)
+            if edge_aliases is not None and txt in edge_aliases:
+                # Relationship aliases should render as entities (parity with
+                # Cypher RETURN <relAlias>) instead of collapsing to id-like
+                # scalar columns such as `<rel>.id`.
+                return self._gfql_render_relationship_alias(table_df, txt)
             node_id = getattr(self, "_node", None)
             id_col = f"{txt}.{node_id}" if node_id else None
             if id_col is not None and id_col in table_df.columns:
                 return table_df[id_col]
-            # Relationship alias: prefer the edge-id column, else render the
-            # relationship as a Cypher-style string so the bare alias can flow
-            # through select/where/group_by like a node alias. (#1072)
-            edge_id = getattr(self, "_edge", None)
-            edge_id_col = f"{txt}.{edge_id}" if edge_id else None
-            if edge_id_col is not None and edge_id_col in table_df.columns:
-                return table_df[edge_id_col]
-            edge_aliases = getattr(self, "_gfql_rows_edge_aliases", None)
             if edge_aliases is not None and txt not in edge_aliases:
                 raise ValueError(f"unsupported token in row expression: {token!r}")
-            if edge_aliases is None and f"{txt}.type" not in table_df.columns:
-                raise ValueError(f"unsupported token in row expression: {token!r}")
-            return self._gfql_render_relationship_alias(table_df, txt)
+            raise ValueError(f"unsupported token in row expression: {token!r}")
         raise ValueError(f"unsupported token in row expression: {token!r}")
 
     def _gfql_render_relationship_alias(self, table_df: Any, alias: str) -> Any:

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

@@ -5189,6 +5189,22 @@ def test_string_cypher_executes_or_xor_around_pattern_predicates(
     assert result._nodes.to_dict(orient="records") == expected_rows
 
 
+def test_string_cypher_failfast_rejects_not_over_pattern_or_expr_compound() -> None:
+    graph = _mk_graph(
+        pd.DataFrame({"id": ["a", "b", "c", "d"]}),
+        pd.DataFrame(
+            {
+                "s": ["a", "a", "b"],
+                "d": ["b", "c", "c"],
+                "type": ["R", "R", "R"],
+            }
+        ),
+    )
+
+    with pytest.raises(GFQLValidationError, match="Pattern existence expressions"):
+        graph.gfql("MATCH (n) WHERE NOT ((n)-[:R]->() OR n.id = 'd') RETURN n.id AS id")
+
+
 @pytest.mark.parametrize(
     "query",
     [
@@ -8039,6 +8055,47 @@ def test_string_cypher_executes_with_match_reentry_carried_scalar_where_on_cudf(
     assert result._nodes.to_pandas().to_dict(orient="records") == [{"property": 1, "id": "b1"}]
 
 
+def test_string_cypher_executes_with_match_reentry_secondary_alias_property_where() -> None:
+    query = (
+        "MATCH (a:A {id: 'a1'})-[:R]->(b:B) "
+        "WITH a, b "
+        "MATCH (b)-[:S]->(c:C) "
+        "WHERE a.id = 'a1' "
+        "RETURN a.id AS aid, c.id AS cid "
+        "ORDER BY cid"
+    )
+
+    result = _mk_connected_reentry_carried_scalar_graph().gfql(query)
+    assert result._nodes.to_dict(orient="records") == [{"aid": "a1", "cid": "c1"}]
+
+
+def test_string_cypher_executes_with_match_reentry_where_or_on_carried_and_trailing_alias_props() -> None:
+    query = (
+        "MATCH (a:A)-[:R]->(b:B) "
+        "WITH a, b "
+        "MATCH (b)-[:S]->(c:C) "
+        "WHERE a.id = 'a1' OR c.id = 'missing' "
+        "RETURN a.id AS aid, c.id AS cid "
+        "ORDER BY cid"
+    )
+
+    result = _mk_connected_reentry_carried_scalar_graph().gfql(query)
+    assert result._nodes.to_dict(orient="records") == [{"aid": "a1", "cid": "c1"}]
+
+
+def test_string_cypher_executes_with_match_reentry_where_xor_on_carried_and_trailing_alias_props() -> None:
+    query = (
+        "MATCH (a:A)-[:R]->(b:B) "
+        "WITH a, b "
+        "MATCH (b)-[:S]->(c:C) "
+        "WHERE a.id = 'a1' XOR c.id = 'c1' "
+        "RETURN a.id AS aid, c.id AS cid"
+    )
+
+    result = _mk_connected_reentry_carried_scalar_graph().gfql(query)
+    assert result._nodes.to_dict(orient="records") == []
+
+
 @pytest.mark.parametrize(
     ("query", "match"),
     [

graphistry/tests/compute/gfql/test_row_pipeline_ops.py

@@ -2369,7 +2369,45 @@ def test_select_bare_relationship_alias_multiple_rows(self):
             "[:WORKS_AT {workFrom: 2015}]",
         ]
 
+    def test_select_bare_relationship_alias_with_edge_id_property_renders_entity_not_scalar_id(self):
+        edges = pd.DataFrame([{"s": "p3", "d": "c1", "type": "WORKS_AT", "id": "edge-1", "workFrom": 2010}])
+        g = self._binding_graph(edges=edges)
+        select_result = g.gfql(self._binding_ops() + [select(items=[("rel", "workAt")])])
+        return_result = g.gfql(self._binding_ops() + [return_([("rel", "workAt")])])
+        assert select_result._nodes["rel"].tolist() == ["[:WORKS_AT {id: 'edge-1', workFrom: 2010}]"]
+        assert select_result._nodes["rel"].tolist() == return_result._nodes["rel"].tolist()
+
+    def test_select_bare_relationship_alias_with_only_id_property_parity(self):
+        edges = pd.DataFrame([{"s": "p3", "d": "c1", "type": "WORKS_AT", "id": "edge-1"}])
+        g = self._binding_graph(edges=edges)
+        select_result = g.gfql(self._binding_ops() + [select(items=[("rel", "workAt")])])
+        return_result = g.gfql(self._binding_ops() + [return_([("rel", "workAt")])])
+        assert select_result._nodes["rel"].tolist() == ["[:WORKS_AT {id: 'edge-1'}]"]
+        assert select_result._nodes["rel"].tolist() == return_result._nodes["rel"].tolist()
+
+    def test_select_bare_relationship_alias_with_empty_type_treated_as_missing_type(self):
+        edges = pd.DataFrame([{"s": "p3", "d": "c1", "type": "", "workFrom": 2010}])
+        g = self._binding_graph(edges=edges)
+        select_result = g.gfql(self._binding_ops(edge_match={}) + [select(items=[("rel", "workAt")])])
+        return_result = g.gfql(self._binding_ops(edge_match={}) + [return_([("rel", "workAt")])])
+        assert select_result._nodes["rel"].tolist() == ["[{workFrom: 2010}]"]
+        assert select_result._nodes["rel"].tolist() == return_result._nodes["rel"].tolist()
+
     def test_select_node_alias_without_node_id_does_not_render_as_relationship(self):
         g = self._binding_graph()
         with pytest.raises((ValueError, GFQLTypeError), match="unsupported token in row expression"):
             g.gfql(self._binding_ops() + [drop_cols(["friend", "friend.id"]), select(items=[("x", "friend")])])
+
+    def test_select_node_alias_with_type_property_without_node_id_does_not_render_as_relationship(self):
+        nodes = pd.DataFrame([
+            {"id": "p3", "label__Person": True, "label__Company": False, "name": "", "type": "PERSON"},
+            {"id": "c1", "label__Person": False, "label__Company": True, "name": "Acme", "type": "COMPANY"},
+        ])
+        g = self._binding_graph(nodes=nodes)
+        with pytest.raises((ValueError, GFQLTypeError), match="unsupported token in row expression"):
+            g.gfql(self._binding_ops() + [drop_cols(["friend", "friend.id"]), select(items=[("x", "friend")])])
+
+    def test_select_plain_rows_alias_like_columns_do_not_render_relationship_text(self):
+        nodes_df = pd.DataFrame({"id": ["a"], "a.type": ["X"], "a.k": [1]})
+        with pytest.raises((ValueError, GFQLTypeError), match="unsupported token in row expression"):
+            _run_node_steps(nodes_df, [rows(), select([("x", "a")])], edges_df=_self_loop_edges(nodes_df))