gqlite 1.8.1 → 1.8.2

data/ext/gqlitedb/src/tests/compiler.rs

@@ -124,11 +124,13 @@ fn test_compile_logicalplan_nodescan_filter()
     &function_manager,
     vec![LogicalPlan::Filter {
       source: Box::new(LogicalPlan::NodeScan {
-        patterns: vec![gqlparser::oc::ast::Pattern::Node(
+        patterns: vec![planner::PlannedPattern::Node(
           gqlparser::oc::ast::NodePattern {
             variable: Some(node_identifier.clone()),
             labels: gqlparser::oc::ast::LabelExpression::None,
             properties: None,
+
+            predicate: None,
           },
         )],
         optional: false,
@@ -288,3 +290,2453 @@ fn test_compile_multiple_vector_indexes_produces_distinct_instructions()
   assert!(debug.contains("\"idx1\""));
   assert!(debug.contains("\"idx2\""));
 }
+
+#[test]
+fn test_compile_match_node_with_inline_predicate()
+{
+  let function_manager = functions::Manager::new();
+  use gqlparser::oc::ast::*;
+
+  let identifiers = VariableIdentifiers::default();
+  let n_identifier = identifiers.create_variable_from_name("n");
+
+  // Construct the predicate: n.name = 'X'
+  let predicate = Expression::RelationalEqual(Box::new(RelationalEqual {
+    left: Expression::MemberAccess(Box::new(MemberAccess {
+      left: Expression::Variable(Variable {
+        identifier: n_identifier.clone(),
+      }),
+      path: vec!["name".to_string()],
+    })),
+    right: Expression::Value(Value { value: "X".into() }),
+  }));
+
+  // Construct the logical plan with predicate
+  let program = compile(
+    &function_manager,
+    vec![LogicalPlan::NodeScan {
+      patterns: vec![planner::PlannedPattern::Node(NodePattern {
+        variable: Some(n_identifier.clone()),
+        labels: LabelExpression::None,
+        properties: None,
+        predicate: Some(predicate),
+      })],
+      optional: false,
+    }],
+  )
+  .unwrap();
+
+  let debug = format!("{:?}", program);
+  // Verify that the predicate instructions are present
+  assert!(
+    debug.contains("GetVariable"),
+    "Expected GetVariable instruction for variable access in predicate"
+  );
+  assert!(
+    debug.contains("AndBinaryOperator"),
+    "Expected AndBinaryOperator to combine predicate with filter stack"
+  );
+  assert!(
+    debug.contains("EqualBinaryOperator"),
+    "Expected EqualBinaryOperator for '=' comparison in predicate"
+  );
+}
+
+#[test]
+fn test_compile_match_edge_with_inline_predicate()
+{
+  let function_manager = functions::Manager::new();
+  use gqlparser::oc::ast::*;
+
+  let identifiers = VariableIdentifiers::default();
+  let a_identifier = identifiers.create_variable_from_name("a");
+  let b_identifier = identifiers.create_variable_from_name("b");
+  let e_identifier = identifiers.create_variable_from_name("e");
+
+  // Construct the predicate: e.distance < 10
+  let predicate = Expression::RelationalInferior(Box::new(RelationalInferior {
+    left: Expression::MemberAccess(Box::new(MemberAccess {
+      left: Expression::Variable(Variable {
+        identifier: e_identifier.clone(),
+      }),
+      path: vec!["distance".to_string()],
+    })),
+    right: Expression::Value(Value {
+      value: 10i64.into(),
+    }),
+  }));
+
+  // Construct the logical plan with edge predicate
+  // Note: Edge patterns are represented as PlannedPattern::Edge within a NodeScan
+  let program = compile(
+    &function_manager,
+    vec![LogicalPlan::NodeScan {
+      patterns: vec![planner::PlannedPattern::Edge(EdgePattern {
+        source: NodePattern {
+          variable: Some(a_identifier.clone()),
+          labels: LabelExpression::None,
+          properties: None,
+          predicate: None,
+        },
+        variable: Some(e_identifier.clone()),
+        directivity: graphcore::EdgeDirectivity::Directed,
+        labels: LabelExpression::None,
+        properties: None,
+        predicate: Some(predicate),
+        destination: NodePattern {
+          variable: Some(b_identifier.clone()),
+          labels: LabelExpression::None,
+          properties: None,
+          predicate: None,
+        },
+      })],
+      optional: false,
+    }],
+  )
+  .unwrap();
+
+  let debug = format!("{:?}", program);
+  // Verify that the predicate instructions are present
+  assert!(
+    debug.contains("GetVariable"),
+    "Expected GetVariable instruction for variable access in predicate"
+  );
+  assert!(
+    debug.contains("AndBinaryOperator"),
+    "Expected AndBinaryOperator to combine predicate with filter stack"
+  );
+  assert!(
+    debug.contains("InferiorBinaryOperator"),
+    "Expected InferiorBinaryOperator for '<' comparison in predicate"
+  );
+}
+
+#[test]
+fn test_compile_quantified_edge_legacy_syntax()
+{
+  use gqlparser::oc::parse_oc_query as parse;
+
+  let function_manager = functions::Manager::new();
+
+  // Parse legacy [*1..3] syntax
+  let queries = parse("MATCH (a)-[:R*1..3]->(b) RETURN a").unwrap();
+  let gqlparser::oc::ast::Query::Statements(statements) = queries.into_iter().next().unwrap()
+  else
+  {
+    panic!("Expected Statements query");
+  };
+
+  let program = compile_statements(&function_manager, statements);
+  let debug = format!("{:?}", program);
+
+  // Verify that the program contains MatchEdge with the quantifier range
+  assert!(
+    debug.contains("recursive_range: Some(1..3)"),
+    "Expected recursive_range: Some(1..3) in compiled program"
+  );
+}
+
+#[test]
+fn test_compile_quantified_edge_new_syntax()
+{
+  use gqlparser::oc::parse_oc_query as parse;
+
+  let function_manager = functions::Manager::new();
+
+  // Parse new {1,3} syntax
+  let queries = parse("MATCH (a)-[:R]->{1,3}(b) RETURN a").unwrap();
+  let gqlparser::oc::ast::Query::Statements(statements) = queries.into_iter().next().unwrap()
+  else
+  {
+    panic!("Expected Statements query");
+  };
+
+  let program = compile_statements(&function_manager, statements);
+  let debug = format!("{:?}", program);
+
+  // Verify that the program contains MatchEdge with the quantifier range
+  assert!(
+    debug.contains("recursive_range: Some(1..3)"),
+    "Expected recursive_range: Some(1..3) in compiled program"
+  );
+}
+
+#[test]
+fn test_compile_legacy_and_new_quantifier_syntax_identical()
+{
+  use gqlparser::oc::parse_oc_query as parse;
+
+  let function_manager = functions::Manager::new();
+
+  // Parse legacy [*1..3] syntax
+  let queries_legacy = parse("MATCH (a)-[:R*1..3]->(b) RETURN a").unwrap();
+  let gqlparser::oc::ast::Query::Statements(statements_legacy) =
+    queries_legacy.into_iter().next().unwrap()
+  else
+  {
+    panic!("Expected Statements query");
+  };
+  let program_legacy = compile_statements(&function_manager, statements_legacy);
+
+  // Parse new {1,3} syntax
+  let queries_new = parse("MATCH (a)-[:R]->{1,3}(b) RETURN a").unwrap();
+  let gqlparser::oc::ast::Query::Statements(statements_new) =
+    queries_new.into_iter().next().unwrap()
+  else
+  {
+    panic!("Expected Statements query");
+  };
+  let program_new = compile_statements(&function_manager, statements_new);
+
+  // Both should produce identical compiled programs
+  compare_program(program_legacy, program_new);
+}
+
+#[test]
+fn test_compile_quantified_edge_with_path_variable()
+{
+  use gqlparser::oc::parse_oc_query as parse;
+
+  let function_manager = functions::Manager::new();
+
+  // Parse path variable with quantified edge
+  let queries = parse("MATCH p = (a)-[:R*1..3]->(b) RETURN p").unwrap();
+  let gqlparser::oc::ast::Query::Statements(statements) = queries.into_iter().next().unwrap()
+  else
+  {
+    panic!("Expected Statements query");
+  };
+
+  let program = compile_statements(&function_manager, statements);
+  let debug = format!("{:?}", program);
+
+  // Verify that the program contains MatchEdge with the quantifier range and path variable
+  assert!(
+    debug.contains("recursive_range: Some(1..3)"),
+    "Expected recursive_range: Some(1..3) in compiled program"
+  );
+  assert!(
+    debug.contains("path_variable: Some("),
+    "Expected path_variable to be set in compiled program"
+  );
+}
+
+#[test]
+fn test_compile_create_quantified_edge_rejects()
+{
+  use gqlparser::oc::parse_oc_query as parse;
+
+  let function_manager = functions::Manager::new();
+
+  // Parse CREATE with quantified edge
+  let queries = parse("CREATE (a)-[:R*1..3]->(b)").unwrap();
+  let gqlparser::oc::ast::Query::Statements(statements) = queries.into_iter().next().unwrap()
+  else
+  {
+    panic!("Expected Statements query");
+  };
+
+  // But compilation should fail with CreatingVarLength error
+  let compile_result = compile(
+    &function_manager,
+    statements
+      .into_iter()
+      .map(planner::plan)
+      .collect::<Result<Vec<_>, _>>()
+      .unwrap(),
+  );
+
+  assert!(
+    compile_result.is_err(),
+    "Expected compilation error for CREATE with quantified edge"
+  );
+  let error_msg = format!("{:?}", compile_result.err().unwrap());
+  assert!(
+    error_msg.contains("CreatingVarLength"),
+    "Expected CreatingVarLength error, got: {}",
+    error_msg
+  );
+}
+
+#[test]
+fn test_compile_mixed_quantified_and_unquantified_edges()
+{
+  use gqlparser::oc::parse_oc_query as parse;
+
+  let function_manager = functions::Manager::new();
+
+  // Parse MATCH with both quantified and unquantified edges as separate patterns
+  let queries = parse("MATCH (a)-[:R]->(b), (a)-[:S*1..2]->(c) RETURN a").unwrap();
+  let gqlparser::oc::ast::Query::Statements(statements) = queries.into_iter().next().unwrap()
+  else
+  {
+    panic!("Expected Statements query");
+  };
+
+  let program = compile_statements(&function_manager, statements);
+  let debug = format!("{:?}", program);
+
+  // Verify that the program contains instructions for both patterns
+  // The first edge pattern should have no quantifier (None)
+  // The second edge pattern should have the quantifier (Some(1..2))
+  assert!(
+    debug.contains("recursive_range: None"),
+    "Expected recursive_range: None for unquantified edge"
+  );
+  assert!(
+    debug.contains("recursive_range: Some(1..2)"),
+    "Expected recursive_range: Some(1..2) for quantified edge"
+  );
+}
+
+#[test]
+fn test_compile_quantified_path_through_planner()
+{
+  use gqlparser::oc::parse_oc_query as parse;
+
+  let function_manager = functions::Manager::new();
+
+  // Parse single-element quantified path: MATCH (a)-[:R*1..3]->(b) RETURN a
+  // This should compile to MatchEdge with recursive_range, not MatchQuantifiedPath
+  let queries = parse("MATCH (a)-[:R*1..3]->(b) RETURN a").unwrap();
+  let gqlparser::oc::ast::Query::Statements(statements) = queries.into_iter().next().unwrap()
+  else
+  {
+    panic!("Expected Statements query");
+  };
+
+  let program = compile_statements(&function_manager, statements);
+  let debug = format!("{:?}", program);
+
+  // Single-element quantified paths use MatchEdge with recursive_range for optimization
+  assert!(
+    debug.contains("recursive_range: Some(1..3)"),
+    "Expected MatchEdge with recursive_range: Some(1..3) for single-element quantified path, got: {}",
+    debug
+  );
+}
+
+#[test]
+fn test_compile_bfs_strategy_quantified_path_succeeds()
+{
+  use gqlparser::oc::ast::*;
+
+  let function_manager = functions::Manager::new();
+  let identifiers = VariableIdentifiers::default();
+  let a_identifier = identifiers.create_variable_from_name("a");
+  let b_identifier = identifiers.create_variable_from_name("b");
+
+  // Construct a LogicalPlan::NodeScan with PlannedPattern::QuantifiedPath using BFS strategy
+  let node_a = NodePattern {
+    variable: Some(a_identifier.clone()),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let node_b = NodePattern {
+    variable: Some(b_identifier),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let qp_source = node_a.clone();
+  let qp_destination = node_b.clone();
+  let edge_pattern = EdgePattern {
+    variable: None,
+    source: node_a,
+    destination: node_b,
+    directivity: graphcore::EdgeDirectivity::Directed,
+    labels: LabelExpression::String("R".into()),
+    properties: None,
+    predicate: None,
+  };
+
+  let quantified_pattern = QuantifiedPathPattern {
+    variable: None,
+    source: qp_source,
+    group: vec![
+      Pattern::Edge(edge_pattern.clone()),
+      Pattern::Edge(edge_pattern),
+    ],
+    group_where: None,
+    path_where: None,
+    quantifier: Some(1..3),
+    destination: qp_destination,
+    selector: PathSelector::Shortest(Value { value: 1.into() }.into()),
+  };
+
+  // This uses PathStrategy::Bfs (because Shortest selector maps to Bfs)
+  let planned_pattern = planner::PlannedPattern::QuantifiedPath {
+    pattern: quantified_pattern.clone(),
+    strategy: planner::PathStrategy::Bfs {
+      stop_condition: planner::StopCondition::Shortest(Value { value: 1.into() }.into()),
+    },
+  };
+
+  let logical_plan = LogicalPlan::NodeScan {
+    patterns: vec![planned_pattern],
+    optional: false,
+  };
+
+  let compile_result = compile(&function_manager, vec![logical_plan]);
+  assert!(
+    compile_result.is_ok(),
+    "BFS strategy should compile successfully with multi-element group, got: {:?}",
+    compile_result.err()
+  );
+}
+
+#[test]
+fn test_compile_multi_element_group_is_rejected_cleanly()
+{
+  use gqlparser::oc::parse_oc_query as parse;
+
+  let function_manager = functions::Manager::new();
+
+  // Parse a real query containing a multi-element quantified group.
+  // This now compiles successfully since WI #634 implemented support.
+  let queries = parse("MATCH (a) ((n)-[:R]->(m)-[:S]->(k)){1,5} (b) RETURN a").unwrap();
+  let gqlparser::oc::ast::Query::Statements(statements) = queries.into_iter().next().unwrap()
+  else
+  {
+    panic!("Expected Statements query");
+  };
+
+  let compile_result = compile(
+    &function_manager,
+    statements
+      .into_iter()
+      .map(planner::plan)
+      .collect::<Result<Vec<_>, _>>()
+      .unwrap(),
+  );
+
+  // Multi-element quantified groups now compile successfully
+  assert!(
+    compile_result.is_ok(),
+    "Expected successful compilation for multi-element quantified group, got error: {:?}",
+    compile_result.err()
+  );
+}
+
+#[test]
+fn test_compile_create_with_quantified_edge_error()
+{
+  use gqlparser::oc::parse_oc_query as parse;
+
+  let function_manager = functions::Manager::new();
+
+  // Parse CREATE (a)-[:R*1..3]->(b)
+  let queries = parse("CREATE (a)-[:R*1..3]->(b)").unwrap();
+  let gqlparser::oc::ast::Query::Statements(statements) = queries.into_iter().next().unwrap()
+  else
+  {
+    panic!("Expected Statements query");
+  };
+
+  let compile_result = compile(
+    &function_manager,
+    statements
+      .into_iter()
+      .map(planner::plan)
+      .collect::<Result<Vec<_>, _>>()
+      .unwrap(),
+  );
+
+  assert!(
+    compile_result.is_err(),
+    "Expected compilation error for CREATE with quantified edge"
+  );
+  let error_msg = format!("{:?}", compile_result.err().unwrap());
+  assert!(
+    error_msg.contains("CreatingVarLength"),
+    "Expected CreatingVarLength error, got: {}",
+    error_msg
+  );
+}
+
+#[test]
+fn test_variables_manager_quantified_path_variable_binding()
+{
+  use gqlparser::oc::parse_oc_query as parse;
+
+  let function_manager = functions::Manager::new();
+
+  // Test 1: Basic binding - MATCH p = (a)-[:R*1..3]->(b) RETURN p
+  // Verify the path variable is properly declared
+  let queries = parse("MATCH p = (a)-[:R*1..3]->(b) RETURN p").unwrap();
+  let gqlparser::oc::ast::Query::Statements(statements) = queries.into_iter().next().unwrap()
+  else
+  {
+    panic!("Expected Statements query");
+  };
+
+  let program = compile_statements(&function_manager, statements);
+  let debug = format!("{:?}", program);
+
+  // Verify bytecode includes the quantified path setup
+  assert!(
+    debug.contains("recursive_range: Some(1..3)"),
+    "Expected quantified range in compiled output"
+  );
+
+  // Test 2: Variable usage - Verify binding by using p in a projection
+  // If p is not properly bound, this would fail during analysis
+  let queries2 = parse("MATCH p = (a)-[:R*1..3]->(b) RETURN a, b, p").unwrap();
+  let gqlparser::oc::ast::Query::Statements(statements2) = queries2.into_iter().next().unwrap()
+  else
+  {
+    panic!("Expected Statements query");
+  };
+
+  let compile_result = compile_statements(&function_manager, statements2);
+  let debug2 = format!("{:?}", compile_result);
+
+  // Verify compilation succeeded, meaning p was properly declared and accessible
+  assert!(
+    !debug2.is_empty(),
+    "Expected successful compilation with path variable in return projection"
+  );
+}
+
+#[test]
+fn test_variables_manager_merge_quantified_path_conflict_detection_scenario_a()
+{
+  use gqlparser::oc::parse_oc_query as parse;
+
+  let function_manager = functions::Manager::new();
+
+  // Scenario A: Verify that MERGE allows proper variable handling with quantified paths
+  // MERGE (a:Person)-[:R*1..3]->(b) should compile successfully
+  // The conflict detection is in place as a safety check even if normal queries don't trigger it
+  let queries = parse("MERGE (a:Person)-[:R*1..3]->(b) RETURN a, b").unwrap();
+  let gqlparser::oc::ast::Query::Statements(statements) = queries.into_iter().next().unwrap()
+  else
+  {
+    panic!("Expected Statements query");
+  };
+
+  let planned_statements = statements
+    .into_iter()
+    .map(planner::plan)
+    .collect::<Result<Vec<_>, _>>()
+    .unwrap();
+
+  // This should fail with CreatingVarLength since MERGE's on_create falls back to CREATE
+  let compile_result = compile(&function_manager, planned_statements);
+
+  assert!(
+    compile_result.is_err(),
+    "Expected error for quantified path in MERGE on_create"
+  );
+}
+
+#[test]
+fn test_variables_manager_merge_quantified_path_conflict_detection_scenario_b()
+{
+  use gqlparser::oc::parse_oc_query as parse;
+
+  let function_manager = functions::Manager::new();
+
+  // Scenario B: Verify the QuantifiedPath arm's conflict check is properly in place
+  // Test that MERGE with a bound quantified path variable triggers the CreatingVarLength error
+  let queries = parse("MERGE p = (a:Person)-[:R*1..3]->(b) RETURN p").unwrap();
+  let gqlparser::oc::ast::Query::Statements(statements) = queries.into_iter().next().unwrap()
+  else
+  {
+    panic!("Expected Statements query");
+  };
+
+  let planned_statements = statements
+    .into_iter()
+    .map(planner::plan)
+    .collect::<Result<Vec<_>, _>>()
+    .unwrap();
+
+  // This should fail due to quantified paths not being supported in MERGE on_create
+  let compile_result = compile(&function_manager, planned_statements);
+
+  assert!(
+    compile_result.is_err(),
+    "Expected error for quantified path variable in MERGE (on_create fallback)"
+  );
+  let error_msg = format!("{:?}", compile_result.err().unwrap());
+  assert!(
+    error_msg.contains("CreatingVarLength"),
+    "Expected CreatingVarLength error, got: {}",
+    error_msg
+  );
+}
+
+#[test]
+fn test_variables_manager_merge_with_quantified_path_creates_var_length_error()
+{
+  use gqlparser::oc::parse_oc_query as parse;
+
+  let function_manager = functions::Manager::new();
+
+  // Verify that MERGE with quantified paths triggers CreatingVarLength error
+  // This tests the on_create fallback that uses compile_create_patterns
+  let queries = parse("MERGE (a)-[:R*1..2]->(b) RETURN a").unwrap();
+  let gqlparser::oc::ast::Query::Statements(statements) = queries.into_iter().next().unwrap()
+  else
+  {
+    panic!("Expected Statements query");
+  };
+
+  let planned_statements = statements
+    .into_iter()
+    .map(planner::plan)
+    .collect::<Result<Vec<_>, _>>()
+    .unwrap();
+
+  let compile_result = compile(&function_manager, planned_statements);
+
+  assert!(
+    compile_result.is_err(),
+    "Expected compilation error for quantified path in MERGE on_create fallback"
+  );
+  let error_msg = format!("{:?}", compile_result.err().unwrap());
+  assert!(
+    error_msg.contains("CreatingVarLength"),
+    "Expected CreatingVarLength error for quantified path in MERGE, got: {}",
+    error_msg
+  );
+}
+
+#[test]
+fn test_compile_quantified_path_group_variables_and_quantifier()
+{
+  use gqlparser::oc::ast::*;
+
+  let function_manager = functions::Manager::new();
+  let identifiers = VariableIdentifiers::default();
+  let a_identifier = identifiers.create_variable_from_name("a");
+  let b_identifier = identifiers.create_variable_from_name("b");
+  let n_identifier = identifiers.create_variable_from_name("n");
+  let r_identifier = identifiers.create_variable_from_name("r");
+  let m_identifier = identifiers.create_variable_from_name("m");
+
+  // Construct a QuantifiedPathPattern: (a:Station) ((n)-[r:KNOWS]->(m)){1,5} (b:Station)
+  let node_a = NodePattern {
+    variable: Some(a_identifier.clone()),
+    labels: LabelExpression::String("Station".into()),
+    properties: None,
+    predicate: None,
+  };
+
+  let node_b = NodePattern {
+    variable: Some(b_identifier.clone()),
+    labels: LabelExpression::String("Station".into()),
+    properties: None,
+    predicate: None,
+  };
+
+  let node_n = NodePattern {
+    variable: Some(n_identifier.clone()),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let node_m = NodePattern {
+    variable: Some(m_identifier.clone()),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let o_identifier = identifiers.create_variable_from_name("o");
+  let node_o = NodePattern {
+    variable: Some(o_identifier.clone()),
+    labels: LabelExpression::String("Person".into()),
+    properties: None,
+    predicate: None,
+  };
+
+  let edge_pattern = EdgePattern {
+    variable: Some(r_identifier.clone()),
+    source: node_n,
+    destination: node_m,
+    directivity: graphcore::EdgeDirectivity::Directed,
+    labels: LabelExpression::String("KNOWS".into()),
+    properties: None,
+    predicate: None,
+  };
+
+  let quantified_pattern = QuantifiedPathPattern {
+    variable: None,
+    source: node_a,
+    group: vec![Pattern::Edge(edge_pattern), Pattern::Node(node_o)],
+    group_where: None,
+    path_where: None,
+    quantifier: Some(1..5),
+    destination: node_b,
+    selector: PathSelector::All,
+  };
+
+  let planned_pattern = planner::PlannedPattern::QuantifiedPath {
+    pattern: quantified_pattern,
+    strategy: planner::PathStrategy::Dfs,
+  };
+
+  let logical_plan = LogicalPlan::NodeScan {
+    patterns: vec![planned_pattern],
+    optional: false,
+  };
+
+  let compile_result = compile(&function_manager, vec![logical_plan]);
+  assert!(
+    compile_result.is_ok(),
+    "Expected successful compilation for quantified path, got error: {:?}",
+    compile_result.err()
+  );
+
+  let program = compile_result.unwrap();
+  assert!(!program.is_empty(), "Expected non-empty program blocks");
+
+  // Find the Match block
+  let match_block = program.iter().find_map(|block| {
+    if let Block::Match { blocks, .. } = block
+    {
+      Some(blocks)
+    }
+    else
+    {
+      None
+    }
+  });
+
+  assert!(
+    match_block.is_some(),
+    "Expected to find a Match block in the program"
+  );
+
+  let match_blocks = match_block.unwrap();
+
+  // Find the MatchQuantifiedPath
+  let quantified_match = match_blocks
+    .iter()
+    .find(|block_match| matches!(block_match, BlockMatch::MatchQuantifiedPath { .. }));
+
+  assert!(
+    quantified_match.is_some(),
+    "Expected to find a MatchQuantifiedPath block"
+  );
+
+  let BlockMatch::MatchQuantifiedPath {
+    group_variables,
+    quantifier,
+    source_instructions,
+    destination_filter,
+    group_where_filter,
+    ..
+  } = quantified_match.unwrap()
+  else
+  {
+    unreachable!()
+  };
+
+  // Verify group_variables has exactly 3 entries (n, r, m, o) - updated from 3 to 4
+  assert_eq!(
+    group_variables.len(),
+    4,
+    "Expected 4 group variables (n, r, m, o), got {}",
+    group_variables.len()
+  );
+
+  // Verify quantifier is Some(1..5)
+  assert_eq!(
+    quantifier,
+    &(1..5),
+    "Expected quantifier to be 1..5, got {:?}",
+    quantifier
+  );
+
+  // Verify group_where_filter is None (no WHERE clause specified)
+  assert!(
+    group_where_filter.is_none(),
+    "Expected group_where_filter to be None"
+  );
+
+  // Verify source_instructions contain Station label filter
+  assert!(
+    !source_instructions.is_empty(),
+    "Expected non-empty source_instructions"
+  );
+
+  // Verify destination_filter contain Station label check (not destination_instructions,
+  // since destination is only validated, not queried from store)
+  assert!(
+    !destination_filter.is_empty(),
+    "Expected non-empty destination_filter"
+  );
+}
+
+#[test]
+fn test_compile_quantified_path_with_group_where_clause()
+{
+  use gqlparser::oc::ast::*;
+
+  let function_manager = functions::Manager::new();
+  let identifiers = VariableIdentifiers::default();
+  let a_identifier = identifiers.create_variable_from_name("a");
+  let b_identifier = identifiers.create_variable_from_name("b");
+  let n_identifier = identifiers.create_variable_from_name("n");
+  let r_identifier = identifiers.create_variable_from_name("r");
+  let m_identifier = identifiers.create_variable_from_name("m");
+
+  // Construct a QuantifiedPathPattern with a WHERE clause on the group
+  let node_a = NodePattern {
+    variable: Some(a_identifier.clone()),
+    labels: LabelExpression::String("Station".into()),
+    properties: None,
+    predicate: None,
+  };
+
+  let node_b = NodePattern {
+    variable: Some(b_identifier.clone()),
+    labels: LabelExpression::String("Station".into()),
+    properties: None,
+    predicate: None,
+  };
+
+  let node_n = NodePattern {
+    variable: Some(n_identifier.clone()),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let node_m = NodePattern {
+    variable: Some(m_identifier.clone()),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let o_identifier = identifiers.create_variable_from_name("o");
+  let node_o = NodePattern {
+    variable: Some(o_identifier.clone()),
+    labels: LabelExpression::String("Person".into()),
+    properties: None,
+    predicate: None,
+  };
+
+  let edge_pattern = EdgePattern {
+    variable: Some(r_identifier.clone()),
+    source: node_n,
+    destination: node_m,
+    directivity: graphcore::EdgeDirectivity::Directed,
+    labels: LabelExpression::String("KNOWS".into()),
+    properties: None,
+    predicate: None,
+  };
+
+  // Create a WHERE clause on the group: WHERE r.weight > 10
+  let group_where = Some(Expression::RelationalSuperior(Box::new(
+    RelationalSuperior {
+      left: Expression::MemberAccess(Box::new(MemberAccess {
+        left: Expression::Variable(Variable {
+          identifier: r_identifier.clone(),
+        }),
+        path: vec!["weight".to_string()],
+      })),
+      right: Expression::Value(Value {
+        value: 10i64.into(),
+      }),
+    },
+  )));
+
+  // Create a multi-element group: (n)-[r:KNOWS]->(m) (o)
+  let quantified_pattern = QuantifiedPathPattern {
+    variable: None,
+    source: node_a,
+    group: vec![Pattern::Edge(edge_pattern), Pattern::Node(node_o)],
+    group_where,
+    path_where: None,
+    quantifier: Some(1..5),
+    destination: node_b,
+    selector: PathSelector::All,
+  };
+
+  let planned_pattern = planner::PlannedPattern::QuantifiedPath {
+    pattern: quantified_pattern,
+    strategy: planner::PathStrategy::Dfs,
+  };
+
+  let logical_plan = LogicalPlan::NodeScan {
+    patterns: vec![planned_pattern],
+    optional: false,
+  };
+
+  let compile_result = compile(&function_manager, vec![logical_plan]);
+  assert!(
+    compile_result.is_ok(),
+    "Expected successful compilation for quantified path with GROUP WHERE, got error: {:?}",
+    compile_result.err()
+  );
+
+  let program = compile_result.unwrap();
+
+  // Find the Match block
+  let match_block = program.iter().find_map(|block| {
+    if let Block::Match { blocks, .. } = block
+    {
+      Some(blocks)
+    }
+    else
+    {
+      None
+    }
+  });
+
+  let match_blocks = match_block.unwrap();
+
+  // Find the MatchQuantifiedPath
+  let BlockMatch::MatchQuantifiedPath {
+    group_where_filter, ..
+  } = match_blocks
+    .iter()
+    .find(|block_match| matches!(block_match, BlockMatch::MatchQuantifiedPath { .. }))
+    .unwrap()
+  else
+  {
+    unreachable!()
+  };
+
+  // Verify group_where_filter is Some (WHERE clause is present)
+  assert!(
+    group_where_filter.is_some(),
+    "Expected group_where_filter to be Some"
+  );
+}
+
+#[test]
+fn test_compile_quantified_path_without_group_where_clause()
+{
+  use gqlparser::oc::ast::*;
+
+  let function_manager = functions::Manager::new();
+  let identifiers = VariableIdentifiers::default();
+  let a_identifier = identifiers.create_variable_from_name("a");
+  let b_identifier = identifiers.create_variable_from_name("b");
+  let n_identifier = identifiers.create_variable_from_name("n");
+  let r_identifier = identifiers.create_variable_from_name("r");
+  let m_identifier = identifiers.create_variable_from_name("m");
+
+  // Construct a QuantifiedPathPattern without a WHERE clause
+  let node_a = NodePattern {
+    variable: Some(a_identifier.clone()),
+    labels: LabelExpression::String("Station".into()),
+    properties: None,
+    predicate: None,
+  };
+
+  let node_b = NodePattern {
+    variable: Some(b_identifier.clone()),
+    labels: LabelExpression::String("Station".into()),
+    properties: None,
+    predicate: None,
+  };
+
+  let node_n = NodePattern {
+    variable: Some(n_identifier.clone()),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let node_m = NodePattern {
+    variable: Some(m_identifier.clone()),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let o_identifier = identifiers.create_variable_from_name("o");
+  let node_o = NodePattern {
+    variable: Some(o_identifier.clone()),
+    labels: LabelExpression::String("Person".into()),
+    properties: None,
+    predicate: None,
+  };
+
+  let edge_pattern = EdgePattern {
+    variable: Some(r_identifier.clone()),
+    source: node_n,
+    destination: node_m,
+    directivity: graphcore::EdgeDirectivity::Directed,
+    labels: LabelExpression::String("KNOWS".into()),
+    properties: None,
+    predicate: None,
+  };
+
+  // Create a multi-element group: (n)-[r:KNOWS]->(m) (o)
+  let quantified_pattern = QuantifiedPathPattern {
+    variable: None,
+    source: node_a,
+    group: vec![Pattern::Edge(edge_pattern), Pattern::Node(node_o)],
+    group_where: None,
+    path_where: None,
+    quantifier: Some(1..5),
+    destination: node_b,
+    selector: PathSelector::All,
+  };
+
+  let planned_pattern = planner::PlannedPattern::QuantifiedPath {
+    pattern: quantified_pattern,
+    strategy: planner::PathStrategy::Dfs,
+  };
+
+  let logical_plan = LogicalPlan::NodeScan {
+    patterns: vec![planned_pattern],
+    optional: false,
+  };
+
+  let compile_result = compile(&function_manager, vec![logical_plan]);
+  assert!(
+    compile_result.is_ok(),
+    "Expected successful compilation for quantified path without GROUP WHERE, got error: {:?}",
+    compile_result.err()
+  );
+
+  let program = compile_result.unwrap();
+
+  // Find the Match block
+  let match_block = program.iter().find_map(|block| {
+    if let Block::Match { blocks, .. } = block
+    {
+      Some(blocks)
+    }
+    else
+    {
+      None
+    }
+  });
+
+  let match_blocks = match_block.unwrap();
+
+  // Find the MatchQuantifiedPath
+  let BlockMatch::MatchQuantifiedPath {
+    group_where_filter, ..
+  } = match_blocks
+    .iter()
+    .find(|block_match| matches!(block_match, BlockMatch::MatchQuantifiedPath { .. }))
+    .unwrap()
+  else
+  {
+    unreachable!()
+  };
+
+  // Verify group_where_filter is None (no WHERE clause specified)
+  assert!(
+    group_where_filter.is_none(),
+    "Expected group_where_filter to be None"
+  );
+}
+
+#[test]
+fn test_quantified_path_strategy_is_compiled()
+{
+  use gqlparser::oc::ast::*;
+
+  let function_manager = functions::Manager::new();
+  let identifiers = VariableIdentifiers::default();
+  let a_identifier = identifiers.create_variable_from_name("a");
+  let b_identifier = identifiers.create_variable_from_name("b");
+
+  let node_a = NodePattern {
+    variable: Some(a_identifier.clone()),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let node_b = NodePattern {
+    variable: Some(b_identifier),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let qp_source = node_a.clone();
+  let qp_destination = node_b.clone();
+  let edge_pattern = EdgePattern {
+    variable: None,
+    source: node_a,
+    destination: node_b,
+    directivity: graphcore::EdgeDirectivity::Directed,
+    labels: LabelExpression::String("R".into()),
+    properties: None,
+    predicate: None,
+  };
+
+  // Create a quantified pattern with group.len() > 1 to trigger compile_quantified_path
+  let quantified_pattern = QuantifiedPathPattern {
+    variable: None,
+    source: qp_source,
+    group: vec![
+      Pattern::Edge(edge_pattern.clone()),
+      Pattern::Edge(edge_pattern),
+    ],
+    group_where: None,
+    path_where: None,
+    quantifier: Some(1..3),
+    destination: qp_destination,
+    selector: PathSelector::Shortest(Value { value: 3.into() }.into()),
+  };
+
+  // Create a PlannedPattern with Bfs strategy and Shortest(3)
+  let planned_pattern = planner::PlannedPattern::QuantifiedPath {
+    pattern: quantified_pattern,
+    strategy: planner::PathStrategy::Bfs {
+      stop_condition: planner::StopCondition::Shortest(Value { value: 3.into() }.into()),
+    },
+  };
+
+  let logical_plan = LogicalPlan::NodeScan {
+    patterns: vec![planned_pattern],
+    optional: false,
+  };
+
+  let compile_result = compile(&function_manager, vec![logical_plan]);
+  assert!(compile_result.is_ok(), "compilation should succeed");
+
+  let compiled = compile_result.unwrap();
+
+  // Find the MatchQuantifiedPath in the compiled output
+  let quantified_match = compiled
+    .iter()
+    .find_map(|block| {
+      if let Block::Match { blocks, .. } = block
+      {
+        blocks
+          .iter()
+          .find(|block_match| matches!(block_match, BlockMatch::MatchQuantifiedPath { .. }))
+      }
+      else
+      {
+        None
+      }
+    })
+    .expect("should find MatchQuantifiedPath");
+
+  // Verify the strategy field is present and has the correct value
+  match quantified_match
+  {
+    BlockMatch::MatchQuantifiedPath { strategy, .. } =>
+    {
+      match strategy
+      {
+        interpreter::instructions::PathStrategy::Bfs { stop_condition } =>
+        {
+          match stop_condition
+          {
+            interpreter::instructions::StopCondition::Shortest(_) =>
+            {
+              // Success - the strategy was properly compiled
+            }
+            _ => panic!("Expected Shortest stop condition"),
+          }
+        }
+        _ => panic!("Expected Bfs strategy"),
+      }
+    }
+    _ => panic!("Expected MatchQuantifiedPath"),
+  }
+}
+
+#[test]
+fn test_single_element_quantified_path_bfs_strategy_routes_to_quantified_path()
+{
+  use gqlparser::oc::ast::*;
+
+  let function_manager = functions::Manager::new();
+  let identifiers = VariableIdentifiers::default();
+  let a_identifier = identifiers.create_variable_from_name("a");
+  let b_identifier = identifiers.create_variable_from_name("b");
+
+  let node_a = NodePattern {
+    variable: Some(a_identifier.clone()),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let node_b = NodePattern {
+    variable: Some(b_identifier),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let edge_pattern = EdgePattern {
+    variable: None,
+    source: node_a.clone(),
+    destination: node_b.clone(),
+    directivity: graphcore::EdgeDirectivity::Directed,
+    labels: LabelExpression::String("R".into()),
+    properties: None,
+    predicate: None,
+  };
+
+  // Create a quantified pattern with group.len() == 1 but Bfs strategy
+  let quantified_pattern = QuantifiedPathPattern {
+    variable: None,
+    source: node_a,
+    group: vec![Pattern::Edge(edge_pattern)],
+    group_where: None,
+    path_where: None,
+    quantifier: Some(1..3),
+    destination: node_b,
+    selector: PathSelector::Shortest(Value { value: 1.into() }.into()),
+  };
+
+  let planned_pattern = planner::PlannedPattern::QuantifiedPath {
+    pattern: quantified_pattern,
+    strategy: planner::PathStrategy::Bfs {
+      stop_condition: planner::StopCondition::Shortest(Value { value: 1.into() }.into()),
+    },
+  };
+
+  let logical_plan = LogicalPlan::NodeScan {
+    patterns: vec![planned_pattern],
+    optional: false,
+  };
+
+  let compile_result = compile(&function_manager, vec![logical_plan]);
+  assert!(compile_result.is_ok(), "compilation should succeed");
+
+  let compiled = compile_result.unwrap();
+
+  // Verify we get MatchQuantifiedPath, not MatchEdge
+  let found_quantified_path = compiled.iter().any(|block| {
+    if let Block::Match { blocks, .. } = block
+    {
+      blocks
+        .iter()
+        .any(|block_match| matches!(block_match, BlockMatch::MatchQuantifiedPath { .. }))
+    }
+    else
+    {
+      false
+    }
+  });
+
+  assert!(
+    found_quantified_path,
+    "single-element quantified path with Bfs strategy should route to MatchQuantifiedPath"
+  );
+}
+
+#[test]
+fn test_single_element_quantified_path_dfs_strategy_routes_to_edge()
+{
+  use gqlparser::oc::ast::*;
+
+  let function_manager = functions::Manager::new();
+  let identifiers = VariableIdentifiers::default();
+  let a_identifier = identifiers.create_variable_from_name("a");
+  let b_identifier = identifiers.create_variable_from_name("b");
+
+  let node_a = NodePattern {
+    variable: Some(a_identifier.clone()),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let node_b = NodePattern {
+    variable: Some(b_identifier),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let edge_pattern = EdgePattern {
+    variable: None,
+    source: node_a.clone(),
+    destination: node_b.clone(),
+    directivity: graphcore::EdgeDirectivity::Directed,
+    labels: LabelExpression::String("R".into()),
+    properties: None,
+    predicate: None,
+  };
+
+  // Create a quantified pattern with group.len() == 1 and Dfs strategy
+  let quantified_pattern = QuantifiedPathPattern {
+    variable: None,
+    source: node_a,
+    group: vec![Pattern::Edge(edge_pattern)],
+    group_where: None,
+    path_where: None,
+    quantifier: Some(1..3),
+    destination: node_b,
+    selector: PathSelector::All,
+  };
+
+  let planned_pattern = planner::PlannedPattern::QuantifiedPath {
+    pattern: quantified_pattern,
+    strategy: planner::PathStrategy::Dfs,
+  };
+
+  let logical_plan = LogicalPlan::NodeScan {
+    patterns: vec![planned_pattern],
+    optional: false,
+  };
+
+  let compile_result = compile(&function_manager, vec![logical_plan]);
+  assert!(compile_result.is_ok(), "compilation should succeed");
+
+  let compiled = compile_result.unwrap();
+
+  // Verify we get MatchEdge, not MatchQuantifiedPath
+  let found_match_edge = compiled.iter().any(|block| {
+    if let Block::Match { blocks, .. } = block
+    {
+      blocks
+        .iter()
+        .any(|block_match| matches!(block_match, BlockMatch::MatchEdge { .. }))
+    }
+    else
+    {
+      false
+    }
+  });
+
+  assert!(
+    found_match_edge,
+    "single-element quantified path with Dfs strategy should route to MatchEdge"
+  );
+}
+
+#[test]
+fn test_compile_shortest_with_literal_k()
+{
+  use gqlparser::oc::parse_oc_query as parse;
+
+  let function_manager = functions::Manager::new();
+
+  let queries = parse("MATCH p = SHORTEST 3 (a)-[:R*1..3]->(b) RETURN p").unwrap();
+  let gqlparser::oc::ast::Query::Statements(statements) = queries.into_iter().next().unwrap()
+  else
+  {
+    panic!("Expected Statements query");
+  };
+
+  let compile_result = compile(&function_manager, {
+    statements
+      .into_iter()
+      .map(planner::plan)
+      .collect::<Result<Vec<_>, _>>()
+      .unwrap()
+  });
+
+  assert!(compile_result.is_ok(), "compilation should succeed");
+
+  let compiled = compile_result.unwrap();
+
+  // Find the MatchQuantifiedPath in the compiled output
+  let quantified_match = compiled
+    .iter()
+    .find_map(|block| {
+      if let Block::Match { blocks, .. } = block
+      {
+        blocks
+          .iter()
+          .find(|block_match| matches!(block_match, BlockMatch::MatchQuantifiedPath { .. }))
+      }
+      else
+      {
+        None
+      }
+    })
+    .expect("should find MatchQuantifiedPath");
+
+  // Verify strategy contains Shortest with compiled instructions
+  match quantified_match
+  {
+    BlockMatch::MatchQuantifiedPath { strategy, .. } =>
+    {
+      match strategy
+      {
+        interpreter::instructions::PathStrategy::Bfs { stop_condition } =>
+        {
+          match stop_condition
+          {
+            interpreter::instructions::StopCondition::Shortest(instructions) =>
+            {
+              // Verify that we have instructions (not just an empty buffer)
+              assert!(
+                !instructions.is_empty(),
+                "Shortest(3) should compile to non-empty instructions"
+              );
+            }
+            _ => panic!("Expected Shortest stop condition, got ShortestGroups"),
+          }
+        }
+        _ => panic!("Expected Bfs strategy"),
+      }
+    }
+    _ => panic!("Expected MatchQuantifiedPath"),
+  }
+}
+
+#[test]
+fn test_compile_shortest_with_parameter_k()
+{
+  use gqlparser::oc::parse_oc_query as parse;
+
+  let function_manager = functions::Manager::new();
+
+  let queries = parse("MATCH p = SHORTEST $k (a)-[:R*1..3]->(b) RETURN p").unwrap();
+  let gqlparser::oc::ast::Query::Statements(statements) = queries.into_iter().next().unwrap()
+  else
+  {
+    panic!("Expected Statements query");
+  };
+
+  let compile_result = compile(&function_manager, {
+    statements
+      .into_iter()
+      .map(planner::plan)
+      .collect::<Result<Vec<_>, _>>()
+      .unwrap()
+  });
+
+  assert!(compile_result.is_ok(), "compilation should succeed");
+
+  let compiled = compile_result.unwrap();
+
+  // Find the MatchQuantifiedPath in the compiled output
+  let quantified_match = compiled
+    .iter()
+    .find_map(|block| {
+      if let Block::Match { blocks, .. } = block
+      {
+        blocks
+          .iter()
+          .find(|block_match| matches!(block_match, BlockMatch::MatchQuantifiedPath { .. }))
+      }
+      else
+      {
+        None
+      }
+    })
+    .expect("should find MatchQuantifiedPath");
+
+  // Verify strategy contains Shortest with compiled instructions that reference the parameter
+  match quantified_match
+  {
+    BlockMatch::MatchQuantifiedPath { strategy, .. } =>
+    {
+      match strategy
+      {
+        interpreter::instructions::PathStrategy::Bfs { stop_condition } =>
+        {
+          match stop_condition
+          {
+            interpreter::instructions::StopCondition::Shortest(instructions) =>
+            {
+              // Verify that we have instructions (not just an empty buffer)
+              assert!(
+                !instructions.is_empty(),
+                "Shortest($k) should compile to non-empty instructions"
+              );
+              // Verify the instructions contain a parameter reference
+              let has_parameter = instructions
+                .iter()
+                .any(|instr| matches!(instr, Instruction::GetParameter { .. }));
+              assert!(
+                has_parameter,
+                "Shortest($k) instructions should contain GetParameter instruction"
+              );
+            }
+            _ => panic!("Expected Shortest stop condition, got ShortestGroups"),
+          }
+        }
+        _ => panic!("Expected Bfs strategy"),
+      }
+    }
+    _ => panic!("Expected MatchQuantifiedPath"),
+  }
+}
+
+#[test]
+fn test_compile_shortest_groups_with_literal_k()
+{
+  use gqlparser::oc::parse_oc_query as parse;
+
+  let function_manager = functions::Manager::new();
+
+  let queries = parse("MATCH p = SHORTEST 2 GROUPS (a)-[:R*1..3]->(b) RETURN p").unwrap();
+  let gqlparser::oc::ast::Query::Statements(statements) = queries.into_iter().next().unwrap()
+  else
+  {
+    panic!("Expected Statements query");
+  };
+
+  let compile_result = compile(&function_manager, {
+    statements
+      .into_iter()
+      .map(planner::plan)
+      .collect::<Result<Vec<_>, _>>()
+      .unwrap()
+  });
+
+  assert!(compile_result.is_ok(), "compilation should succeed");
+
+  let compiled = compile_result.unwrap();
+
+  // Find the MatchQuantifiedPath in the compiled output
+  let quantified_match = compiled
+    .iter()
+    .find_map(|block| {
+      if let Block::Match { blocks, .. } = block
+      {
+        blocks
+          .iter()
+          .find(|block_match| matches!(block_match, BlockMatch::MatchQuantifiedPath { .. }))
+      }
+      else
+      {
+        None
+      }
+    })
+    .expect("should find MatchQuantifiedPath");
+
+  // Verify strategy contains ShortestGroups (not Shortest)
+  match quantified_match
+  {
+    BlockMatch::MatchQuantifiedPath { strategy, .. } =>
+    {
+      match strategy
+      {
+        interpreter::instructions::PathStrategy::Bfs { stop_condition } =>
+        {
+          match stop_condition
+          {
+            interpreter::instructions::StopCondition::ShortestGroups(instructions) =>
+            {
+              // Verify that we have instructions (not just an empty buffer)
+              assert!(
+                !instructions.is_empty(),
+                "ShortestGroups(2) should compile to non-empty instructions"
+              );
+            }
+            interpreter::instructions::StopCondition::Shortest(_) =>
+            {
+              panic!("Expected ShortestGroups, got Shortest — the distinction is lost!");
+            }
+          }
+        }
+        _ => panic!("Expected Bfs strategy"),
+      }
+    }
+    _ => panic!("Expected MatchQuantifiedPath"),
+  }
+}
+
+#[test]
+fn test_inline_predicate_compiles_to_pattern_filter()
+{
+  use gqlparser::oc::parse_oc_query as parse;
+
+  let function_manager = functions::Manager::new();
+
+  // Baseline test: inline predicate on pattern
+  let queries = parse("MATCH (a:Node {name: 'test'}) RETURN a").unwrap();
+  let gqlparser::oc::ast::Query::Statements(statements) = queries.into_iter().next().unwrap()
+  else
+  {
+    panic!("Expected Statements query");
+  };
+
+  let program = compile(&function_manager, {
+    statements
+      .into_iter()
+      .map(planner::plan)
+      .collect::<Result<Vec<_>, _>>()
+      .unwrap()
+  })
+  .unwrap();
+
+  // Find the Match block
+  let match_block = program
+    .iter()
+    .find(|block| matches!(block, Block::Match { .. }))
+    .expect("should find Match block");
+
+  match match_block
+  {
+    Block::Match {
+      blocks: _, filter, ..
+    } =>
+    {
+      // The block-level filter should be empty (no top-level WHERE)
+      assert!(
+        filter.is_empty(),
+        "Block-level filter should be empty when only inline predicate present"
+      );
+    }
+    _ => panic!("Expected Match block"),
+  }
+}
+
+#[test]
+fn test_top_level_where_compiles_to_block_filter()
+{
+  use gqlparser::oc::parse_oc_query as parse;
+
+  let function_manager = functions::Manager::new();
+
+  // Baseline test: top-level WHERE clause should compile to block-level filter
+  let queries = parse("MATCH (a:Node) WHERE a.value > 10 RETURN a").unwrap();
+  let gqlparser::oc::ast::Query::Statements(statements) = queries.into_iter().next().unwrap()
+  else
+  {
+    panic!("Expected Statements query");
+  };
+
+  let program = compile(&function_manager, {
+    statements
+      .into_iter()
+      .map(planner::plan)
+      .collect::<Result<Vec<_>, _>>()
+      .unwrap()
+  })
+  .unwrap();
+
+  // Find the Match block
+  let match_block = program
+    .iter()
+    .find(|block| matches!(block, Block::Match { .. }))
+    .expect("should find Match block");
+
+  match match_block
+  {
+    Block::Match { blocks, filter, .. } =>
+    {
+      // The block-level filter should have instructions (the WHERE clause)
+      assert!(
+        !filter.is_empty(),
+        "Block-level filter should contain instructions for WHERE clause"
+      );
+
+      // Pattern filters should not include the WHERE clause
+      let all_patterns_empty = blocks.iter().all(|bm| match bm
+      {
+        BlockMatch::MatchNode { filter, .. } => filter.is_empty(),
+        _ => true,
+      });
+
+      assert!(
+        all_patterns_empty,
+        "Pattern filters should be empty when WHERE is top-level"
+      );
+    }
+    _ => panic!("Expected Match block"),
+  }
+}
+
+#[test]
+fn test_wrapper_group_where_compiles_to_group_where_filter()
+{
+  use gqlparser::oc::parse_oc_query as parse;
+
+  let function_manager = functions::Manager::new();
+
+  // Test that quantified paths can compile without errors
+  let queries = parse("MATCH (a:A)-[*1..3]->(b:B) RETURN a, b").unwrap();
+  let gqlparser::oc::ast::Query::Statements(statements) = queries.into_iter().next().unwrap()
+  else
+  {
+    panic!("Expected Statements query");
+  };
+
+  let program = compile(&function_manager, {
+    statements
+      .into_iter()
+      .map(planner::plan)
+      .collect::<Result<Vec<_>, _>>()
+      .unwrap()
+  })
+  .unwrap();
+
+  // Ensure at least one Match block exists
+  let has_match = program
+    .iter()
+    .any(|block| matches!(block, Block::Match { .. }));
+
+  assert!(has_match, "Should have a Match block");
+}
+
+#[test]
+fn test_post_filter_form_compiles_to_block_filter()
+{
+  use gqlparser::oc::parse_oc_query as parse;
+
+  let function_manager = functions::Manager::new();
+
+  // Equivalent form with WHERE outside the wrapper scope
+  // MATCH p = (:A)-[:R]->(:B) WHERE p RETURN p
+  let queries = parse("MATCH p = (:A)-[:R]->(:B) WHERE p IS NOT NULL RETURN p").unwrap();
+  let gqlparser::oc::ast::Query::Statements(statements) = queries.into_iter().next().unwrap()
+  else
+  {
+    panic!("Expected Statements query");
+  };
+
+  let program = compile(&function_manager, {
+    statements
+      .into_iter()
+      .map(planner::plan)
+      .collect::<Result<Vec<_>, _>>()
+      .unwrap()
+  })
+  .unwrap();
+
+  // Find the Match block
+  let match_block = program
+    .iter()
+    .find(|block| matches!(block, Block::Match { .. }))
+    .expect("should find Match block");
+
+  match match_block
+  {
+    Block::Match {
+      blocks: _, filter, ..
+    } =>
+    {
+      // The block-level filter should have instructions (the WHERE clause)
+      assert!(
+        !filter.is_empty(),
+        "Block-level filter should contain instructions for top-level WHERE clause"
+      );
+    }
+    _ => panic!("Expected Match block"),
+  }
+}
+
+// WI#669: Tests for path_filter field on MatchQuantifiedPath
+#[test]
+fn test_genuine_group_predicate_compiles_to_group_where_filter()
+{
+  use crate::interpreter::instructions::BlockMatch;
+  use gqlparser::oc::ast::*;
+
+  let function_manager = functions::Manager::new();
+  let identifiers = VariableIdentifiers::default();
+  let a_identifier = identifiers.create_variable_from_name("a");
+  let b_identifier = identifiers.create_variable_from_name("b");
+  let n_identifier = identifiers.create_variable_from_name("n");
+  let r_identifier = identifiers.create_variable_from_name("r");
+  let m_identifier = identifiers.create_variable_from_name("m");
+
+  // Construct a multi-element group with a group_where predicate
+  let node_a = NodePattern {
+    variable: Some(a_identifier.clone()),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let node_b = NodePattern {
+    variable: Some(b_identifier),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let node_n = NodePattern {
+    variable: Some(n_identifier.clone()),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let node_m = NodePattern {
+    variable: Some(m_identifier),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  // Create edge pattern: (n)-[r]->(m)
+  let edge_pattern = EdgePattern {
+    variable: Some(r_identifier),
+    source: node_n.clone(),
+    destination: node_m.clone(),
+    directivity: graphcore::EdgeDirectivity::Directed,
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  // Create edge pattern 2: (m)-[s]->(p) to make multi-element group
+  let node_p = NodePattern {
+    variable: Some(identifiers.create_variable_from_name("p")),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let edge_pattern_2 = EdgePattern {
+    variable: Some(identifiers.create_variable_from_name("s")),
+    source: node_m,
+    destination: node_p,
+    directivity: graphcore::EdgeDirectivity::Directed,
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  // Create the group_where expression: n.x > 1
+  let group_where = Some(Expression::RelationalSuperior(Box::new(
+    RelationalSuperior {
+      left: Expression::MemberAccess(Box::new(MemberAccess {
+        left: Expression::Variable(Variable {
+          identifier: n_identifier.clone(),
+        }),
+        path: vec!["x".to_string()],
+      })),
+      right: Expression::Value(Value { value: 1i64.into() }),
+    },
+  )));
+
+  // Create quantified pattern with group_where predicate
+  let quantified_pattern = QuantifiedPathPattern {
+    variable: None,
+    source: node_a,
+    group: vec![Pattern::Edge(edge_pattern), Pattern::Edge(edge_pattern_2)],
+    group_where,
+    path_where: None, // No wrapper predicate
+    quantifier: Some(1..5),
+    destination: node_b,
+    selector: PathSelector::All,
+  };
+
+  let planned_pattern = planner::PlannedPattern::QuantifiedPath {
+    pattern: quantified_pattern,
+    strategy: planner::PathStrategy::Dfs,
+  };
+
+  let logical_plan = LogicalPlan::NodeScan {
+    patterns: vec![planned_pattern],
+    optional: false,
+  };
+
+  let program = compile(&function_manager, vec![logical_plan]).unwrap();
+
+  // Find the MatchQuantifiedPath instruction and verify field placement
+  let mut found_group_where = false;
+  for block in &program
+  {
+    if let crate::interpreter::instructions::Block::Match { blocks, .. } = block
+    {
+      for match_block in blocks
+      {
+        if let BlockMatch::MatchQuantifiedPath {
+          path_filter,
+          group_where_filter,
+          ..
+        } = match_block
+        {
+          // For genuine groups, group_where_filter should have instructions
+          // and path_filter should be None
+          if group_where_filter.is_some()
+          {
+            found_group_where = true;
+            assert!(
+              path_filter.is_none(),
+              "Genuine group predicate should not land in path_filter, found both path_filter and group_where_filter as Some"
+            );
+          }
+        }
+      }
+    }
+  }
+
+  assert!(
+    found_group_where,
+    "Should have found group_where_filter for genuine group with WHERE clause"
+  );
+}
+
+#[test]
+fn test_path_filter_and_group_where_filter_never_both_some()
+{
+  use crate::interpreter::instructions::BlockMatch;
+  use gqlparser::oc::ast::*;
+
+  let function_manager = functions::Manager::new();
+  let identifiers = VariableIdentifiers::default();
+  let a_identifier = identifiers.create_variable_from_name("a");
+  let b_identifier = identifiers.create_variable_from_name("b");
+  let n_identifier = identifiers.create_variable_from_name("n");
+  let r_identifier = identifiers.create_variable_from_name("r");
+  let m_identifier = identifiers.create_variable_from_name("m");
+
+  // Construct a multi-element group with a group_where predicate
+  let node_a = NodePattern {
+    variable: Some(a_identifier.clone()),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let node_b = NodePattern {
+    variable: Some(b_identifier),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let node_n = NodePattern {
+    variable: Some(n_identifier.clone()),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let node_m = NodePattern {
+    variable: Some(m_identifier),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let edge_pattern = EdgePattern {
+    variable: Some(r_identifier),
+    source: node_n.clone(),
+    destination: node_m.clone(),
+    directivity: graphcore::EdgeDirectivity::Directed,
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let node_p = NodePattern {
+    variable: Some(identifiers.create_variable_from_name("p")),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let edge_pattern_2 = EdgePattern {
+    variable: Some(identifiers.create_variable_from_name("s")),
+    source: node_m,
+    destination: node_p,
+    directivity: graphcore::EdgeDirectivity::Directed,
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  // Create quantified pattern with only group_where (no path_where)
+  let group_where = Some(Expression::RelationalSuperior(Box::new(
+    RelationalSuperior {
+      left: Expression::MemberAccess(Box::new(MemberAccess {
+        left: Expression::Variable(Variable {
+          identifier: n_identifier.clone(),
+        }),
+        path: vec!["x".to_string()],
+      })),
+      right: Expression::Value(Value { value: 1i64.into() }),
+    },
+  )));
+
+  let quantified_pattern = QuantifiedPathPattern {
+    variable: None,
+    source: node_a,
+    group: vec![Pattern::Edge(edge_pattern), Pattern::Edge(edge_pattern_2)],
+    group_where,
+    path_where: None,
+    quantifier: Some(1..5),
+    destination: node_b,
+    selector: PathSelector::All,
+  };
+
+  let planned_pattern = planner::PlannedPattern::QuantifiedPath {
+    pattern: quantified_pattern,
+    strategy: planner::PathStrategy::Dfs,
+  };
+
+  let logical_plan = LogicalPlan::NodeScan {
+    patterns: vec![planned_pattern],
+    optional: false,
+  };
+
+  let program = compile(&function_manager, vec![logical_plan]).unwrap();
+
+  // Verify: both path_filter and group_where_filter should not be Some simultaneously
+  for block in &program
+  {
+    if let crate::interpreter::instructions::Block::Match { blocks, .. } = block
+    {
+      for match_block in blocks
+      {
+        if let BlockMatch::MatchQuantifiedPath {
+          path_filter,
+          group_where_filter,
+          ..
+        } = match_block
+        {
+          assert!(
+            !(group_where_filter.is_some() && path_filter.is_some()),
+            "Both path_filter and group_where_filter should never be Some on the same MatchQuantifiedPath — \
+             path_filter is for wrapper predicates, group_where_filter is for genuine group predicates"
+          );
+        }
+      }
+    }
+  }
+}
+
+// WI#670: Tests for PathUniqueness seam
+#[test]
+fn test_path_uniqueness_trail_is_reusable_empty_set()
+{
+  use crate::graph::Key;
+  use crate::interpreter::path::PathUniqueness;
+  use rustc_hash::FxHashSet;
+
+  let uniqueness = PathUniqueness::Trail;
+  let mut used_edges: FxHashSet<Key> = FxHashSet::default();
+
+  // Create mock edge keys
+  let edge_key = Key::new(1);
+
+  // Initially, edge should be reusable (not in used set)
+  assert!(
+    uniqueness.is_reusable(&used_edges, &edge_key),
+    "Edge should be reusable when not in used_edges set"
+  );
+
+  // After marking used, edge should not be reusable
+  uniqueness.mark_used(&mut used_edges, edge_key);
+  assert!(
+    !uniqueness.is_reusable(&used_edges, &edge_key),
+    "Edge should not be reusable after mark_used"
+  );
+
+  // After marking unused, edge should be reusable again
+  uniqueness.mark_unused(&mut used_edges, &edge_key);
+  assert!(
+    uniqueness.is_reusable(&used_edges, &edge_key),
+    "Edge should be reusable after mark_unused"
+  );
+}
+
+#[test]
+fn test_path_uniqueness_trail_round_trip()
+{
+  use crate::graph::Key;
+  use crate::interpreter::path::PathUniqueness;
+  use rustc_hash::FxHashSet;
+
+  let uniqueness = PathUniqueness::Trail;
+  let mut used_edges: FxHashSet<Key> = FxHashSet::default();
+
+  let edge_key_1 = Key::new(1);
+  let edge_key_2 = Key::new(2);
+
+  // Mark multiple edges as used
+  uniqueness.mark_used(&mut used_edges, edge_key_1);
+  uniqueness.mark_used(&mut used_edges, edge_key_2);
+
+  // Both should be non-reusable
+  assert!(!uniqueness.is_reusable(&used_edges, &edge_key_1));
+  assert!(!uniqueness.is_reusable(&used_edges, &edge_key_2));
+
+  // Mark first edge as unused
+  uniqueness.mark_unused(&mut used_edges, &edge_key_1);
+
+  // First should now be reusable, second should still be non-reusable
+  assert!(uniqueness.is_reusable(&used_edges, &edge_key_1));
+  assert!(!uniqueness.is_reusable(&used_edges, &edge_key_2));
+
+  // Mark second edge as unused
+  uniqueness.mark_unused(&mut used_edges, &edge_key_2);
+
+  // Both should now be reusable again
+  assert!(uniqueness.is_reusable(&used_edges, &edge_key_1));
+  assert!(uniqueness.is_reusable(&used_edges, &edge_key_2));
+
+  // Set should be empty
+  assert!(
+    used_edges.is_empty(),
+    "used_edges should be empty after all edges unmarked"
+  );
+}
+
+#[test]
+fn test_path_uniqueness_trail_preserves_state()
+{
+  use crate::graph::Key;
+  use crate::interpreter::path::PathUniqueness;
+  use rustc_hash::FxHashSet;
+
+  let uniqueness = PathUniqueness::Trail;
+  let mut used_edges: FxHashSet<Key> = FxHashSet::default();
+
+  let edge_key_1 = Key::new(1);
+  let edge_key_2 = Key::new(2);
+  let edge_key_3 = Key::new(3);
+
+  // Simulate a DFS path traversal: mark edges as we go down, unmark as we backtrack
+  uniqueness.mark_used(&mut used_edges, edge_key_1);
+  assert_eq!(used_edges.len(), 1);
+
+  uniqueness.mark_used(&mut used_edges, edge_key_2);
+  assert_eq!(used_edges.len(), 2);
+
+  uniqueness.mark_used(&mut used_edges, edge_key_3);
+  assert_eq!(used_edges.len(), 3);
+
+  // Backtrack from edge_3
+  uniqueness.mark_unused(&mut used_edges, &edge_key_3);
+  assert_eq!(used_edges.len(), 2);
+  assert!(!used_edges.contains(&edge_key_3));
+  assert!(used_edges.contains(&edge_key_1));
+  assert!(used_edges.contains(&edge_key_2));
+
+  // Backtrack from edge_2
+  uniqueness.mark_unused(&mut used_edges, &edge_key_2);
+  assert_eq!(used_edges.len(), 1);
+  assert!(!used_edges.contains(&edge_key_2));
+  assert!(used_edges.contains(&edge_key_1));
+
+  // Backtrack from edge_1
+  uniqueness.mark_unused(&mut used_edges, &edge_key_1);
+  assert_eq!(used_edges.len(), 0);
+  assert!(used_edges.is_empty());
+}
+
+// WI689 Tests: Group terminal variable tracking
+
+#[test]
+fn test_group_terminal_variable_compiled_for_unnamed_node()
+{
+  use gqlparser::oc::ast::*;
+
+  let function_manager = functions::Manager::new();
+  let identifiers = VariableIdentifiers::default();
+  let a_identifier = identifiers.create_variable_from_name("a");
+  let b_identifier = identifiers.create_variable_from_name("b");
+
+  let node_a = NodePattern {
+    variable: Some(a_identifier.clone()),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let node_b = NodePattern {
+    variable: Some(b_identifier),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let qp_source = node_a.clone();
+  let qp_destination = node_b.clone();
+
+  // Inner group: unnamed nodes with one edge
+  let node_n = NodePattern {
+    variable: Some(identifiers.create_variable_from_name("n")),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let node_m = NodePattern {
+    variable: Some(identifiers.create_variable_from_name("m")),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let edge_pattern = EdgePattern {
+    variable: Some(identifiers.create_variable_from_name("r")),
+    source: node_n.clone(),
+    destination: node_m,
+    directivity: graphcore::EdgeDirectivity::Directed,
+    labels: LabelExpression::String("R".into()),
+    properties: None,
+    predicate: None,
+  };
+
+  let quantified_pattern = QuantifiedPathPattern {
+    variable: None,
+    source: qp_source,
+    group: vec![Pattern::Node(node_n), Pattern::Edge(edge_pattern)],
+    group_where: None,
+    path_where: None,
+    quantifier: Some(1..5),
+    destination: qp_destination,
+    selector: PathSelector::All,
+  };
+
+  // Create a PlannedPattern with Dfs strategy (default)
+  let planned_pattern = planner::PlannedPattern::QuantifiedPath {
+    pattern: quantified_pattern,
+    strategy: planner::PathStrategy::Dfs,
+  };
+
+  let logical_plan = LogicalPlan::NodeScan {
+    patterns: vec![planned_pattern],
+    optional: false,
+  };
+
+  let compile_result = compile(&function_manager, vec![logical_plan]);
+  assert!(compile_result.is_ok(), "compilation should succeed");
+
+  let compiled = compile_result.unwrap();
+
+  // Find the MatchQuantifiedPath in the compiled output
+  let quantified_match = compiled
+    .iter()
+    .find_map(|block| {
+      if let Block::Match { blocks, .. } = block
+      {
+        blocks
+          .iter()
+          .find(|block_match| matches!(block_match, BlockMatch::MatchQuantifiedPath { .. }))
+      }
+      else
+      {
+        None
+      }
+    })
+    .expect("should find MatchQuantifiedPath");
+
+  // Verify the group_terminal_variable field exists and is set
+  match quantified_match
+  {
+    BlockMatch::MatchQuantifiedPath {
+      group_terminal_variable: _,
+      group_variables,
+      ..
+    } =>
+    {
+      // The group_terminal_variable should be a valid column ID
+      // (we can't easily check the exact value, but we can verify it exists)
+      assert!(
+        !group_variables.is_empty(),
+        "group_variables should not be empty"
+      );
+      // group_terminal_variable should point to one of the group variables
+      // (this will be verified by not panicking during compilation)
+    }
+    _ => panic!("Expected MatchQuantifiedPath"),
+  }
+}
+
+#[test]
+fn test_group_terminal_variable_compiled_for_named_node()
+{
+  use gqlparser::oc::ast::*;
+
+  let function_manager = functions::Manager::new();
+  let identifiers = VariableIdentifiers::default();
+  let a_identifier = identifiers.create_variable_from_name("a");
+  let b_identifier = identifiers.create_variable_from_name("b");
+
+  let node_a = NodePattern {
+    variable: Some(a_identifier.clone()),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let node_b = NodePattern {
+    variable: Some(b_identifier),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let qp_source = node_a.clone();
+  let qp_destination = node_b.clone();
+
+  // Inner group: named nodes with one edge
+  let node_n = NodePattern {
+    variable: Some(identifiers.create_variable_from_name("n")),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let node_m = NodePattern {
+    variable: Some(identifiers.create_variable_from_name("m")),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let edge_pattern = EdgePattern {
+    variable: Some(identifiers.create_variable_from_name("r")),
+    source: node_n.clone(),
+    destination: node_m,
+    directivity: graphcore::EdgeDirectivity::Directed,
+    labels: LabelExpression::String("R".into()),
+    properties: None,
+    predicate: None,
+  };
+
+  let quantified_pattern = QuantifiedPathPattern {
+    variable: None,
+    source: qp_source,
+    group: vec![Pattern::Node(node_n), Pattern::Edge(edge_pattern)],
+    group_where: None,
+    path_where: None,
+    quantifier: Some(1..5),
+    destination: qp_destination,
+    selector: PathSelector::All,
+  };
+
+  // Create a PlannedPattern with Dfs strategy (default)
+  let planned_pattern = planner::PlannedPattern::QuantifiedPath {
+    pattern: quantified_pattern,
+    strategy: planner::PathStrategy::Dfs,
+  };
+
+  let logical_plan = LogicalPlan::NodeScan {
+    patterns: vec![planned_pattern],
+    optional: false,
+  };
+
+  let compile_result = compile(&function_manager, vec![logical_plan]);
+  assert!(compile_result.is_ok(), "compilation should succeed");
+
+  let compiled = compile_result.unwrap();
+
+  // Find the MatchQuantifiedPath in the compiled output
+  let quantified_match = compiled
+    .iter()
+    .find_map(|block| {
+      if let Block::Match { blocks, .. } = block
+      {
+        blocks
+          .iter()
+          .find(|block_match| matches!(block_match, BlockMatch::MatchQuantifiedPath { .. }))
+      }
+      else
+      {
+        None
+      }
+    })
+    .expect("should find MatchQuantifiedPath");
+
+  // Verify the group_terminal_variable field exists and is set
+  match quantified_match
+  {
+    BlockMatch::MatchQuantifiedPath {
+      group_terminal_variable: _,
+      group_variables,
+      ..
+    } =>
+    {
+      // The group_terminal_variable should be a valid column ID
+      assert!(
+        !group_variables.is_empty(),
+        "group_variables should not be empty"
+      );
+      // group_terminal_variable should point to one of the group variables
+    }
+    _ => panic!("Expected MatchQuantifiedPath"),
+  }
+}
+
+#[test]
+fn test_path_filter_shortest_query_compiles()
+{
+  // WI#711: Verify that SHORTEST queries with WHERE clauses compile correctly
+  // and produce a MatchQuantifiedPath block
+  //
+  // Query: MATCH p = SHORTEST 1 (a:Station)-[:LINK]-+(d:Station) WHERE length(p) % 2 = 0 RETURN p
+  //
+  // This test verifies the compilation pipeline handles path filtering queries correctly.
+
+  use gqlparser::oc::parse_oc_query as parse;
+
+  let function_manager = functions::Manager::new();
+
+  let query_str = "MATCH p = SHORTEST 1 (a:Station {name:'A'})-[:LINK]-+(d:Station {name:'D'}) WHERE length(p) % 2 = 0 RETURN p";
+  let queries = parse(query_str).expect("Should parse successfully");
+
+  let gqlparser::oc::ast::Query::Statements(statements) =
+    queries.into_iter().next().expect("Should have a query")
+  else
+  {
+    panic!("Expected Statements query");
+  };
+
+  let program = compile_statements(&function_manager, statements);
+
+  // Find the Match block
+  let match_block = program.iter().find_map(|block| {
+    if let Block::Match { blocks, .. } = block
+    {
+      Some(blocks)
+    }
+    else
+    {
+      None
+    }
+  });
+
+  assert!(
+    match_block.is_some(),
+    "Expected to find a Match block in the program"
+  );
+
+  let match_blocks = match_block.unwrap();
+
+  // Find the MatchQuantifiedPath
+  let quantified_match = match_blocks
+    .iter()
+    .find(|block_match| matches!(block_match, BlockMatch::MatchQuantifiedPath { .. }))
+    .expect("Expected to find a MatchQuantifiedPath block for SHORTEST query");
+
+  // Just verify it's a MatchQuantifiedPath - the WHERE clause handling
+  // is verified through end-to-end evaluator tests, not compiler structure
+  assert!(
+    matches!(quantified_match, BlockMatch::MatchQuantifiedPath { .. }),
+    "MatchQuantifiedPath should be present in compiled SHORTEST query"
+  );
+}
+
+#[test]
+fn test_compile_group_single_edge_range()
+{
+  let function_manager = functions::Manager::new();
+
+  let program = compile_statements(&function_manager, ast::group_single_edge_range());
+  compare_program(program, programs::group_single_edge_range())
+}
+
+#[test]
+fn test_compile_group_two_edges_range()
+{
+  let function_manager = functions::Manager::new();
+
+  let program = compile_statements(&function_manager, ast::group_two_edges_range());
+  compare_program(program, programs::group_two_edges_range())
+}
+
+#[test]
+fn test_compile_shortest_single_edge_full_return()
+{
+  let function_manager = functions::Manager::new();
+
+  let program = compile_statements(&function_manager, ast::shortest_single_edge_full_return());
+  compare_program(
+    program,
+    programs::shortest_single_edge_full_return(&function_manager),
+  )
+}