fix: denormalized VLP cycle prevention skips table lookup for virtual nodes

Fixed-length VLP (*2, *3) on denormalized schemas failed with "Missing
table information for start node in cycle prevention" because
extract_table_name returns None for virtual nodes that have no separate
table.

Fix: move extract_table_name calls inside the non-denormalized branch
in both filter_builder.rs and plan_builder_utils.rs. For denormalized
patterns, cycle prevention uses relationship columns (from_id/to_id)
directly — no table name needed.

Promotes 19 xfails:
- 9 denormalized VLP tests (vlp_exact, vlp_range, vlp_path_var, shortest_path)
- 10 polymorphic VLP tests (already generating correct SQL)
Converts 3 invalid-property tests to skips (a.airport not valid).
12 coupled schema xfails remain (multi-relationship VLP untestable).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: genezhang

src/render_plan/filter_builder.rs

@@ -267,32 +267,30 @@ impl FilterBuilder for LogicalPlan {
                             let is_denormalized = is_node_denormalized(&graph_rel.left)
                                 && is_node_denormalized(&graph_rel.right);
 
-                            // Extract table/column info for cycle prevention
-                            // Use extract_table_name directly to avoid wrong fallbacks
-                            let start_table =
-                                extract_table_name(&graph_rel.left).ok_or_else(|| {
-                                    RenderBuildError::MissingTableInfo(
-                                        "start node in cycle prevention".to_string(),
-                                    )
-                                })?;
-                            let end_table =
-                                extract_table_name(&graph_rel.right).ok_or_else(|| {
-                                    RenderBuildError::MissingTableInfo(
-                                        "end node in cycle prevention".to_string(),
-                                    )
-                                })?;
-
                             let rel_cols = extract_relationship_columns(&graph_rel.center)
                                 .unwrap_or(RelationshipColumns {
                                     from_id: Identifier::Single("from_node_id".to_string()),
                                     to_id: Identifier::Single("to_node_id".to_string()),
                                 });
 
-                            // For denormalized, use relationship columns directly
-                            // For normal, use node ID columns
+                            // For denormalized, use relationship columns directly (nodes
+                            // have no separate table — extract_table_name would fail).
+                            // For normal schemas, use node ID columns from node tables.
                             let (start_id_col, end_id_col) = if is_denormalized {
                                 (rel_cols.from_id.to_string(), rel_cols.to_id.to_string())
                             } else {
+                                let start_table =
+                                    extract_table_name(&graph_rel.left).ok_or_else(|| {
+                                        RenderBuildError::MissingTableInfo(
+                                            "start node in cycle prevention".to_string(),
+                                        )
+                                    })?;
+                                let end_table =
+                                    extract_table_name(&graph_rel.right).ok_or_else(|| {
+                                        RenderBuildError::MissingTableInfo(
+                                            "end node in cycle prevention".to_string(),
+                                        )
+                                    })?;
                                 let start = extract_id_column(&graph_rel.left)
                                     .unwrap_or_else(|| table_to_id_column(&start_table));
                                 let end = extract_id_column(&graph_rel.right)

src/render_plan/plan_builder_utils.rs

@@ -1725,31 +1725,31 @@ pub fn extract_filters(plan: &LogicalPlan) -> RenderPlanBuilderResult<Option<Ren
                         let is_denormalized = is_node_denormalized(&graph_rel.left)
                             && is_node_denormalized(&graph_rel.right);
 
-                        // Extract table/column info for cycle prevention
-                        // Use extract_table_name directly to avoid wrong fallbacks
-                        let start_table = extract_table_name(&graph_rel.left).ok_or_else(|| {
-                            RenderBuildError::MissingTableInfo(
-                                "start node in cycle prevention".to_string(),
-                            )
-                        })?;
-                        let end_table = extract_table_name(&graph_rel.right).ok_or_else(|| {
-                            RenderBuildError::MissingTableInfo(
-                                "end node in cycle prevention".to_string(),
-                            )
-                        })?;
-
                         let rel_cols = extract_relationship_columns(&graph_rel.center).unwrap_or(
                             RelationshipColumns {
                                 from_id: Identifier::Single("from_node_id".to_string()),
                                 to_id: Identifier::Single("to_node_id".to_string()),
                             },
                         );
 
-                        // For denormalized, use relationship columns directly
-                        // For normal, use node ID columns
+                        // For denormalized, use relationship columns directly (nodes
+                        // have no separate table — extract_table_name would fail).
+                        // For normal schemas, use node ID columns from node tables.
                         let (start_id_col, end_id_col) = if is_denormalized {
                             (rel_cols.from_id.to_string(), rel_cols.to_id.to_string())
                         } else {
+                            let start_table =
+                                extract_table_name(&graph_rel.left).ok_or_else(|| {
+                                    RenderBuildError::MissingTableInfo(
+                                        "start node in cycle prevention".to_string(),
+                                    )
+                                })?;
+                            let end_table =
+                                extract_table_name(&graph_rel.right).ok_or_else(|| {
+                                    RenderBuildError::MissingTableInfo(
+                                        "end node in cycle prevention".to_string(),
+                                    )
+                                })?;
                             // Use extract_end_node_id_column for nested GraphRel patterns
                             // (e.g., (a)-[:R]->(b)-[:VLP*]->(c) where left is a GraphRel).
                             // extract_id_column follows rel.center (relationship table) returning FKs

tests/integration/query_patterns/test_pattern_schema_matrix.py

@@ -685,7 +685,6 @@ def test_multi_hop_2(self):
         result = execute_query(query, "ontime_flights")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Denormalized schema: node property resolution or VLP CTE gap")
     def test_vlp_exact_0(self):
         """
         Variable-length path with exact hops
@@ -695,7 +694,7 @@ def test_vlp_exact_0(self):
         result = execute_query(query, "ontime_flights")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Denormalized schema: node property resolution or VLP CTE gap")
+    @pytest.mark.skip(reason="Invalid test: Airport has no 'airport' property (valid: code, city, state)")
     def test_vlp_exact_1(self):
         """
         Variable-length path with exact hops
@@ -705,7 +704,6 @@ def test_vlp_exact_1(self):
         result = execute_query(query, "ontime_flights")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Denormalized schema: node property resolution or VLP CTE gap")
     def test_vlp_exact_2(self):
         """
         Variable-length path with exact hops
@@ -715,7 +713,6 @@ def test_vlp_exact_2(self):
         result = execute_query(query, "ontime_flights")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Denormalized schema: node property resolution or VLP CTE gap")
     def test_vlp_range_0(self):
         """
         Variable-length path with range
@@ -725,7 +722,6 @@ def test_vlp_range_0(self):
         result = execute_query(query, "ontime_flights")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Denormalized schema: node property resolution or VLP CTE gap")
     def test_vlp_range_1(self):
         """
         Variable-length path with range
@@ -735,7 +731,6 @@ def test_vlp_range_1(self):
         result = execute_query(query, "ontime_flights")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Denormalized schema: node property resolution or VLP CTE gap")
     def test_vlp_range_2(self):
         """
         Variable-length path with range
@@ -745,7 +740,6 @@ def test_vlp_range_2(self):
         result = execute_query(query, "ontime_flights")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Denormalized schema: node property resolution or VLP CTE gap")
     def test_vlp_path_var_0(self):
         """
         Path variable with functions
@@ -755,7 +749,6 @@ def test_vlp_path_var_0(self):
         result = execute_query(query, "ontime_flights")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Denormalized schema: node property resolution or VLP CTE gap")
     def test_vlp_path_var_1(self):
         """
         Path variable with functions
@@ -765,7 +758,6 @@ def test_vlp_path_var_1(self):
         result = execute_query(query, "ontime_flights")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Denormalized schema: node property resolution or VLP CTE gap")
     def test_vlp_path_var_2(self):
         """
         Path variable with functions
@@ -966,7 +958,7 @@ def test_order_limit_2(self):
         result = execute_query(query, "ontime_flights")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Denormalized schema: node property resolution or VLP CTE gap")
+    @pytest.mark.skip(reason="Invalid test: Airport has no 'airport' property (valid: code, city, state)")
     def test_shortest_path_0(self):
         """
         Shortest path query
@@ -976,7 +968,7 @@ def test_shortest_path_0(self):
         result = execute_query(query, "ontime_flights")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Denormalized schema: node property resolution or VLP CTE gap")
+    @pytest.mark.skip(reason="Invalid test: Airport has no 'airport' property (valid: code, city, state)")
     def test_shortest_path_1(self):
         """
         Shortest path query
@@ -986,7 +978,6 @@ def test_shortest_path_1(self):
         result = execute_query(query, "ontime_flights")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Denormalized schema: node property resolution or VLP CTE gap")
     def test_shortest_path_2(self):
         """
         Shortest path query
@@ -1182,7 +1173,6 @@ def test_vlp_exact_1(self):
         result = execute_query(query, "social_polymorphic")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Polymorphic schema: VLP or shortest path gap")
     def test_vlp_exact_2(self):
         """
         Variable-length path with exact hops
@@ -1192,7 +1182,6 @@ def test_vlp_exact_2(self):
         result = execute_query(query, "social_polymorphic")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Polymorphic schema: VLP or shortest path gap")
     def test_vlp_range_0(self):
         """
         Variable-length path with range
@@ -1202,7 +1191,6 @@ def test_vlp_range_0(self):
         result = execute_query(query, "social_polymorphic")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Polymorphic schema: VLP or shortest path gap")
     def test_vlp_range_1(self):
         """
         Variable-length path with range
@@ -1212,7 +1200,6 @@ def test_vlp_range_1(self):
         result = execute_query(query, "social_polymorphic")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Polymorphic schema: VLP or shortest path gap")
     def test_vlp_range_2(self):
         """
         Variable-length path with range
@@ -1222,7 +1209,6 @@ def test_vlp_range_2(self):
         result = execute_query(query, "social_polymorphic")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Polymorphic schema: VLP or shortest path gap")
     def test_vlp_path_var_0(self):
         """
         Path variable with functions
@@ -1232,7 +1218,6 @@ def test_vlp_path_var_0(self):
         result = execute_query(query, "social_polymorphic")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Polymorphic schema: VLP or shortest path gap")
     def test_vlp_path_var_1(self):
         """
         Path variable with functions
@@ -1242,7 +1227,6 @@ def test_vlp_path_var_1(self):
         result = execute_query(query, "social_polymorphic")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Polymorphic schema: VLP or shortest path gap")
     def test_vlp_path_var_2(self):
         """
         Path variable with functions
@@ -1441,7 +1425,6 @@ def test_order_limit_2(self):
         result = execute_query(query, "social_polymorphic")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Polymorphic schema: VLP or shortest path gap")
     def test_shortest_path_0(self):
         """
         Shortest path query
@@ -1451,7 +1434,6 @@ def test_shortest_path_0(self):
         result = execute_query(query, "social_polymorphic")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Polymorphic schema: VLP or shortest path gap")
     def test_shortest_path_1(self):
         """
         Shortest path query
@@ -1461,7 +1443,6 @@ def test_shortest_path_1(self):
         result = execute_query(query, "social_polymorphic")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Polymorphic schema: VLP or shortest path gap")
     def test_shortest_path_2(self):
         """
         Shortest path query
@@ -1642,7 +1623,7 @@ def test_multi_hop_2(self):
         result = execute_query(query, "zeek_dns")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Coupled schema: VLP not supported on denormalized edge tables")
+    @pytest.mark.xfail(reason="Coupled schema: VLP on multi-relationship denormalized tables")
     def test_vlp_exact_0(self):
         """
         Variable-length path with exact hops
@@ -1652,7 +1633,7 @@ def test_vlp_exact_0(self):
         result = execute_query(query, "zeek_dns")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Coupled schema: VLP not supported on denormalized edge tables")
+    @pytest.mark.xfail(reason="Coupled schema: VLP on multi-relationship denormalized tables")
     def test_vlp_exact_1(self):
         """
         Variable-length path with exact hops
@@ -1662,7 +1643,7 @@ def test_vlp_exact_1(self):
         result = execute_query(query, "zeek_dns")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Coupled schema: VLP not supported on denormalized edge tables")
+    @pytest.mark.xfail(reason="Coupled schema: VLP on multi-relationship denormalized tables")
     def test_vlp_exact_2(self):
         """
         Variable-length path with exact hops
@@ -1672,7 +1653,7 @@ def test_vlp_exact_2(self):
         result = execute_query(query, "zeek_dns")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Coupled schema: VLP not supported on denormalized edge tables")
+    @pytest.mark.xfail(reason="Coupled schema: VLP on multi-relationship denormalized tables")
     def test_vlp_range_0(self):
         """
         Variable-length path with range
@@ -1682,7 +1663,7 @@ def test_vlp_range_0(self):
         result = execute_query(query, "zeek_dns")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Coupled schema: VLP not supported on denormalized edge tables")
+    @pytest.mark.xfail(reason="Coupled schema: VLP on multi-relationship denormalized tables")
     def test_vlp_range_1(self):
         """
         Variable-length path with range
@@ -1692,7 +1673,7 @@ def test_vlp_range_1(self):
         result = execute_query(query, "zeek_dns")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Coupled schema: VLP not supported on denormalized edge tables")
+    @pytest.mark.xfail(reason="Coupled schema: VLP on multi-relationship denormalized tables")
     def test_vlp_range_2(self):
         """
         Variable-length path with range
@@ -1702,7 +1683,7 @@ def test_vlp_range_2(self):
         result = execute_query(query, "zeek_dns")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Coupled schema: VLP not supported on denormalized edge tables")
+    @pytest.mark.xfail(reason="Coupled schema: VLP on multi-relationship denormalized tables")
     def test_vlp_path_var_0(self):
         """
         Path variable with functions
@@ -1712,7 +1693,7 @@ def test_vlp_path_var_0(self):
         result = execute_query(query, "zeek_dns")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Coupled schema: VLP not supported on denormalized edge tables")
+    @pytest.mark.xfail(reason="Coupled schema: VLP on multi-relationship denormalized tables")
     def test_vlp_path_var_1(self):
         """
         Path variable with functions
@@ -1722,7 +1703,7 @@ def test_vlp_path_var_1(self):
         result = execute_query(query, "zeek_dns")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Coupled schema: VLP not supported on denormalized edge tables")
+    @pytest.mark.xfail(reason="Coupled schema: VLP on multi-relationship denormalized tables")
     def test_vlp_path_var_2(self):
         """
         Path variable with functions
@@ -1924,7 +1905,7 @@ def test_order_limit_2(self):
         result = execute_query(query, "zeek_dns")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Coupled schema: VLP/shortestPath not supported on denormalized edge tables")
+    @pytest.mark.xfail(reason="Coupled schema: VLP on multi-relationship denormalized tables")
     def test_shortest_path_0(self):
         """
         Shortest path query
@@ -1934,7 +1915,7 @@ def test_shortest_path_0(self):
         result = execute_query(query, "zeek_dns")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Coupled schema: VLP/shortestPath not supported on denormalized edge tables")
+    @pytest.mark.xfail(reason="Coupled schema: VLP on multi-relationship denormalized tables")
     def test_shortest_path_1(self):
         """
         Shortest path query
@@ -1944,7 +1925,7 @@ def test_shortest_path_1(self):
         result = execute_query(query, "zeek_dns")
         assert "error" not in result, f"Query failed: {result}"
 
-    @pytest.mark.xfail(reason="Coupled schema: VLP/shortestPath not supported on denormalized edge tables")
+    @pytest.mark.xfail(reason="Coupled schema: VLP on multi-relationship denormalized tables")
     def test_shortest_path_2(self):
         """
         Shortest path query