GFQL/cypher: multi-part MATCH...WITH <alias> MATCH (alias)... does NOT carry the filtered binding (silent wrong answer)

[lmeyerov]

Summary (P0 correctness — silent wrong answer)

A multi-part Cypher query that filters in the first MATCH, carries a node via WITH, then re-references it in a second MATCH does not restrict the second MATCH to the filtered set — it re-matches the alias from the whole graph. The query runs without error and returns a wrong count. Affects pandas and cuDF (polars NIEs the projection separately).

Repro

import pandas as pd, graphistry
nodes = pd.DataFrame({'node_id':[0,1,2,10,20],
  'node_type':['Person','Person','Person','City','Interest'],
  'city':[None,None,None,'NYC',None], 'interest':[None,None,None,None,'Books']})
edges = pd.DataFrame({'src':[0,1,2,0], 'dst':[10,10,10,20],
  'rel':['LIVES_IN','LIVES_IN','LIVES_IN','HAS_INTEREST']})  # only p0 has interest Books; all live in NYC
g = graphistry.nodes(nodes,'node_id').edges(edges,'src','dst')

# first MATCH alone filters correctly -> 1  ✅
g.gfql("MATCH (p {node_type:'Person'})-[{rel:'HAS_INTEREST'}]->(i {node_type:'Interest'}) WHERE i.interest='Books' RETURN count(p) AS c")  # c=1

# carry via WITH into a second MATCH -> should still be 1, returns 3  ❌
g.gfql('''MATCH (p {node_type:'Person'})-[{rel:'HAS_INTEREST'}]->(i {node_type:'Interest'})
WHERE i.interest='Books'
WITH p
MATCH (p)-[{rel:'LIVES_IN'}]->(c {node_type:'City'})
RETURN count(p) AS numPersons''')  # numPersons = 3 (WRONG, expected 1) on pandas AND cudf

Impact

This is the canonical shape of graph-benchmark q2/q5/q6/q7 ('users with interest X and gender Y who live in city Z'). It means those queries cannot be run as single-query GFQL Cypher today without producing wrong numbers — they must be orchestrated as multiple GFQL calls (first MATCH → extract filtered node ids → seed the second MATCH). Blocks the #1710 fair benchmark rewrite.

Expected

Either carry the filtered binding correctly (numPersons=1), or — if the bounded-reentry carry isn't supported for this shape — raise NotImplementedError (honest NIE), never a silent wrong count.

Notes

• First-MATCH filtering alone is correct, so the bug is specifically the WITH→second-MATCH re-entry not restricting the alias domain.
• Related: bounded-reentry machinery ([BUG] Cypher reentry path mis-handles OPTIONAL prefix MATCH on no-match fixtures #1356/[POST-RERUN] #880 residual: joined row aggregation bucket #1413); benchmark integrity (benchmarks/gfql: q1-q9 runner uses dataframe shortcuts (bypasses GFQL engine) + untimed lowercase precompute — unfair vs competitor DBs #1710).

[lmeyerov]

Refined trigger (2026-07-06): it is specifically subset carry. The bug does NOT depend on inline maps vs labels, nor on collect:

• Existing passing tests (e.g. test_issue_1413_ic3_entity_membership_...) carry a node filtered by a unique $personId → single carried node → re-match finds the one node → correct.
• But when the first MATCH filters to a subset of >1 node and carries via WITH p, the second MATCH (p)-... re-matches p from the whole graph, ignoring the carried subset.

Minimal (labels; p0,p1 have Books, p2 has Music; all LIVES_IN NYC → expect 2, both with and without collect):

MATCH (p:Person)-[:HAS_INTEREST]->(i:Interest) WHERE i.interest="Books"
WITH p              # (or: WITH p, collect(i.interest) AS ii)
MATCH (p)-[:LIVES_IN]->(c:City) RETURN count(p) AS numPersons

Returns 3, expected 2 (pandas + cuDF). So the coverage gap is exactly the multi-node subset carry — which is the shape of graph-benchmark q5/q6/q7. Adding an xfail-locked correctness test in test_lowering.py that flips to pass when this is fixed.

[lmeyerov]

Root-caused (2026-07-06) — deeper than a single path; both multi-part lowering routes drop the carried-subset constraint:

1. Flatten route (reentry/flatten.py): the WITH p is treated as a pure carry and flattened to a comma-pattern MATCH (p)-[R1]->(i), (p)-[R2]->(c) WHERE i.interest=.... But the resulting lowering emits rows(binding_ops) for only the second pattern (p, LIVES_IN, c) — the p node carries no filter and the HAS_INTEREST pattern is gone. Confirmed via compiled-chain inspection.
2. Bounded-reentry route (flatten disabled): also returns 3 — the reentry executor re-matches p from the whole graph, not the first-MATCH-filtered subset.
3. Direct comma-form MATCH (p)-[R1]->(i),(p)-[R2]->(c) WHERE i.interest=... (no WITH at all): also returns 3 — it routes through the logical-plan executor (0-op chain) and the two patterns sharing p are not intersected on the shared alias.

So the underlying defect is: a connected multi-pattern sharing a node alias does not intersect the two patterns' constraints on that alias — one pattern's filter is dropped. The multi-part WITH shape inherits it via flatten. This is the graph-benchmark q5/q6/q7 shape (and any "friends who are also X" star query).

Scope: a correct fix touches the connected-match-join / logical-plan intersection (and the reentry executor's seed restriction) — a substantial, careful change, not a targeted patch. The strict-xfail correctness test is committed (test_issue_1712_subset_with_carry_restricts_second_match) and will verify the fix + auto-fail if it regresses. Deferring the fix itself rather than risk a bad change to core lowering.

[lmeyerov]

FIXED (commit f5d05674). Root-caused to a shared-alias filter drop with two manifestations, both fixed + now correct on pandas & cuDF (numPersons=2):

1. Comma-form MATCH (p)-[R1]->(i),(p)-[R2]->(c) WHERE i.k=...: the connected-match-join only handled the expr_tree WHERE form and silently dropped the structured predicates form. Relaxed the gate (renders both; NIEs honestly if unrenderable).
2. WITH-form ...WHERE... WITH p MATCH (p)...: the bounded-reentry seed was computed but never wired to _gfql_start_nodes for an all-call binding-ops chain, so p re-matched the whole graph. Wired it in _execute_compiled_query_chain_non_union.

The strict-xfail correctness test (subset carry, WITH + WITH-collect) now passes + a comma-form intersection test added. Unblocks graph-benchmark q5/q6/q7 (as comma-form with tolower). gfql 3047 + compute 4334 green.