fix: support renamed cypher reentry alias

Author: lmeyerov

graphistry/compute/gfql/cypher/lowering.py

@@ -5953,7 +5953,7 @@ def _bounded_reentry_carry_columns(
     *,
     query: CypherQuery,
     prefix_stage: ProjectionStage,
-) -> Tuple[str, ...]:
+) -> Tuple[str, Tuple[str, ...]]:
     whole_row_columns = [column for column in prefix_projection.columns if column.kind == "whole_row"]
     if len(whole_row_columns) != 1:
         raise _unsupported(
@@ -5964,7 +5964,7 @@ def _bounded_reentry_carry_columns(
             column=prefix_stage.span.column,
         )
     if len(prefix_projection.columns) == 1:
-        return ()
+        return whole_row_columns[0].output_name, ()
     seed_alias = _single_node_seed_alias(query.matches[0]) if len(query.matches) == 1 else None
     if seed_alias is None or seed_alias != prefix_projection.alias:
         raise _unsupported(
@@ -5998,7 +5998,7 @@ def _bounded_reentry_carry_columns(
             )
         hidden_names.add(hidden_column)
         carried_columns.append(column.output_name)
-    return tuple(carried_columns)
+    return whole_row_columns[0].output_name, tuple(carried_columns)
 
 
 def _literal_limit_value(limit_clause: Optional[LimitClause]) -> Optional[int]:
@@ -6101,7 +6101,7 @@ def _compile_bounded_reentry_query(
             line=prefix_stage.span.line,
             column=prefix_stage.span.column,
         )
-    carry_columns = _bounded_reentry_carry_columns(
+    reentry_alias, carry_columns = _bounded_reentry_carry_columns(
         prefix_projection,
         query=query,
         prefix_stage=prefix_stage,
@@ -6137,7 +6137,7 @@ def _compile_bounded_reentry_query(
 
     reentry_match = query.reentry_matches[0]
     first_alias = _first_pattern_node_alias(reentry_match)
-    if first_alias is None or first_alias != prefix_projection.alias:
+    if first_alias is None or first_alias != reentry_alias:
         raise _unsupported(
             "Cypher MATCH after WITH currently requires the trailing MATCH to start from the same carried node alias",
             field="match",
@@ -6152,7 +6152,7 @@ def _compile_bounded_reentry_query(
             reentry_where,
             expr=_rewrite_reentry_expr_to_hidden_properties(
                 reentry_where.expr,
-                carried_alias=prefix_projection.alias,
+                carried_alias=reentry_alias,
                 carried_columns=carry_columns,
                 field="where",
             ),
@@ -6171,7 +6171,7 @@ def _compile_bounded_reentry_query(
                 for rewritten_expr in (
                     _rewrite_reentry_expr_to_hidden_properties(
                         item.expression,
-                        carried_alias=prefix_projection.alias,
+                        carried_alias=reentry_alias,
                         carried_columns=carry_columns,
                         field=query.return_.kind,
                     ),
@@ -6187,7 +6187,7 @@ def _compile_bounded_reentry_query(
                     item,
                     expression=_rewrite_reentry_expr_to_hidden_properties(
                         item.expression,
-                        carried_alias=prefix_projection.alias,
+                        carried_alias=reentry_alias,
                         carried_columns=carry_columns,
                         field="order_by",
                     ),
@@ -6219,7 +6219,7 @@ def _compile_bounded_reentry_query(
             column=reentry_match.span.column,
         )
     result_projection = suffix_compiled.result_projection
-    if result_projection is not None and result_projection.alias == prefix_projection.alias and carry_columns:
+    if result_projection is not None and result_projection.alias == reentry_alias and carry_columns:
         result_projection = replace(
             result_projection,
             exclude_columns=tuple(

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

@@ -5046,14 +5046,15 @@ def test_string_cypher_executes_with_match_reentry_multihop_shape() -> None:
 
 
 @pytest.mark.parametrize(
-    ("query", "expected_columns"),
+    ("query", "expected_whole_row_output", "expected_columns"),
     [
         (
             "MATCH (a:A) "
             "WITH a, a.num AS property "
             "MATCH (a)-->(b) "
             "RETURN property "
             "ORDER BY property DESC",
+            "a",
             ("property",),
         ),
         (
@@ -5062,21 +5063,43 @@ def test_string_cypher_executes_with_match_reentry_multihop_shape() -> None:
             "MATCH (a)-->(b) "
             "RETURN property, property2 "
             "ORDER BY property DESC",
+            "a",
             ("property", "property2"),
         ),
+        (
+            "MATCH (a:A) "
+            "WITH a AS x, a.num AS property "
+            "MATCH (x)-->(b) "
+            "RETURN property "
+            "ORDER BY property DESC",
+            "x",
+            ("property",),
+        ),
     ],
 )
-def test_compile_cypher_tracks_reentry_carried_scalar_columns(query: str, expected_columns: Tuple[str, ...]) -> None:
+def test_compile_cypher_tracks_reentry_carried_scalar_columns(
+    query: str,
+    expected_whole_row_output: str,
+    expected_columns: Tuple[str, ...],
+) -> None:
     compiled = _compile_query(query)
     whole_row_output, carried_columns = _compiled_reentry_projection_outputs(compiled)
 
-    assert whole_row_output == "a"
+    assert whole_row_output == expected_whole_row_output
     assert carried_columns == expected_columns
 
 
 @pytest.mark.parametrize(
     ("query", "expected"),
     [
+        (
+            "MATCH (a:A) "
+            "WITH a AS x "
+            "MATCH (x)-->(b) "
+            "RETURN b.id AS bid "
+            "ORDER BY bid",
+            [{"bid": "b1"}, {"bid": "b2"}],
+        ),
         (
             "MATCH (a:A) "
             "WITH a, a.num AS property "
@@ -5101,6 +5124,14 @@ def test_compile_cypher_tracks_reentry_carried_scalar_columns(query: str, expect
             "ORDER BY property DESC",
             [{"property": 2, "property2": 12}, {"property": 1, "property2": 11}],
         ),
+        (
+            "MATCH (a:A) "
+            "WITH a AS x, a.num AS property "
+            "MATCH (x)-->(b) "
+            "RETURN x, property "
+            "ORDER BY property DESC",
+            [{"x": "(:A {num: 2})", "property": 2}, {"x": "(:A {num: 1})", "property": 1}],
+        ),
     ],
 )
 def test_string_cypher_executes_with_match_reentry_carried_scalar_shapes(query: str, expected: List[Dict[str, Any]]) -> None:

graphistry/tests/compute/test_gfql.py

@@ -488,22 +488,32 @@ def test_gfql_chain_dict_envelope(self):
 class TestGFQLCypherReentryCarrier:
 
     @staticmethod
-    def _compile_reentry_query(with_clause: str = "a, a.num AS property"):
+    def _compile_reentry_query(
+        with_clause: str = "a, a.num AS property",
+        *,
+        match_alias: str = "a",
+    ):
         return compile_cypher(
             "MATCH (a:A) "
             f"WITH {with_clause} "
-            "MATCH (a)-->(b) "
+            f"MATCH ({match_alias})-->(b) "
             "RETURN b.id AS bid"
         )
 
     @staticmethod
-    def _bind_reentry_prefix_result(g, rows: Dict[str, List[Any]], ids: List[Any]):
+    def _bind_reentry_prefix_result(
+        g,
+        rows: Dict[str, List[Any]],
+        ids: List[Any],
+        *,
+        output_name: str = "a",
+    ):
         prefix_result = g.bind()
         prefix_result._nodes = pd.DataFrame(rows)
         prefix_result._cypher_entity_projection_meta = {
-            "a": {
+            output_name: {
                 "table": "nodes",
-                "alias": "a",
+                "alias": output_name,
                 "id_column": "id",
                 "ids": pd.Series(ids, name="id"),
             }
@@ -682,3 +692,25 @@ def test_reentry_state_overrides_internal_hidden_column_collisions(self):
         )
 
         assert g._nodes["__cypher_reentry_property__"].tolist() == ["orig1", "orig2", None, None]
+
+    def test_reentry_state_uses_projected_whole_row_alias_for_contract(self):
+        g = _mk_reentry_scalar_graph()
+        self._assert_reentry_state(
+            g=g,
+            compiled=self._compile_reentry_query("a AS x, a.num AS property", match_alias="x"),
+            prefix_result=self._bind_reentry_prefix_result(
+                g,
+                rows={"property": [2, 1]},
+                ids=["a2", "a1"],
+                output_name="x",
+            ),
+            expected_rows=[
+                {"id": "a2", "label__A": True, "num": 2, "__cypher_reentry_property__": 2},
+                {"id": "a1", "label__A": True, "num": 1, "__cypher_reentry_property__": 1},
+            ],
+            expected_carry={
+                "a1": {"__cypher_reentry_property__": 1},
+                "a2": {"__cypher_reentry_property__": 2},
+            },
+            expect_same_graph=False,
+        )