gqlite 1.8.0 → 1.8.2

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

@@ -110,3 +110,1228 @@ fn test_parse_multiple_vector_index_creation()
   expected.extend(ast::create_vector_index("idx2"));
   compare_ast(ast, expected)
 }
+
+#[test]
+fn test_parse_edge_pattern_with_predicate()
+{
+  let ast = parse_query("MATCH (a)-[l:LINK WHERE l.distance < 10]->(b) RETURN l");
+  // Find the MATCH statement
+  let match_stmt = ast
+    .iter()
+    .find_map(|stmt| {
+      if let oc::ast::Statement::Match(m) = stmt
+      {
+        Some(m)
+      }
+      else
+      {
+        None
+      }
+    })
+    .expect("Expected to find a MATCH statement");
+
+  assert_eq!(match_stmt.patterns.len(), 1);
+  if let oc::ast::Pattern::Edge(edge_pattern) = &match_stmt.patterns[0]
+  {
+    assert!(
+      edge_pattern.predicate.is_some(),
+      "Expected predicate to be Some"
+    );
+  }
+  else
+  {
+    panic!("Expected Pattern::Edge");
+  }
+}
+
+#[test]
+fn test_parse_edge_pattern_with_properties_and_predicate()
+{
+  let ast = parse_query("MATCH (a)-[l:LINK {weight: 1} WHERE l.distance < 10]->(b) RETURN l");
+  // Find the MATCH statement
+  let match_stmt = ast
+    .iter()
+    .find_map(|stmt| {
+      if let oc::ast::Statement::Match(m) = stmt
+      {
+        Some(m)
+      }
+      else
+      {
+        None
+      }
+    })
+    .expect("Expected to find a MATCH statement");
+
+  assert_eq!(match_stmt.patterns.len(), 1);
+  if let oc::ast::Pattern::Edge(edge_pattern) = &match_stmt.patterns[0]
+  {
+    assert!(
+      edge_pattern.properties.is_some(),
+      "Expected properties to be Some"
+    );
+    assert!(
+      edge_pattern.predicate.is_some(),
+      "Expected predicate to be Some"
+    );
+  }
+  else
+  {
+    panic!("Expected Pattern::Edge");
+  }
+}
+
+#[test]
+fn test_parse_edge_pattern_without_predicate()
+{
+  let ast = parse_query("MATCH (a)-[l]->(b) RETURN l");
+  // Find the MATCH statement
+  let match_stmt = ast
+    .iter()
+    .find_map(|stmt| {
+      if let oc::ast::Statement::Match(m) = stmt
+      {
+        Some(m)
+      }
+      else
+      {
+        None
+      }
+    })
+    .expect("Expected to find a MATCH statement");
+
+  assert_eq!(match_stmt.patterns.len(), 1);
+  if let oc::ast::Pattern::Edge(edge_pattern) = &match_stmt.patterns[0]
+  {
+    assert!(
+      edge_pattern.predicate.is_none(),
+      "Expected predicate to be None"
+    );
+  }
+  else
+  {
+    panic!("Expected Pattern::Edge");
+  }
+}
+
+#[test]
+fn test_parse_path_pattern_with_predicate()
+{
+  let ast = parse_query("MATCH p = (a)-[l:LINK WHERE l.distance < 10]->(b) RETURN p");
+  // Find the MATCH statement
+  let match_stmt = ast
+    .iter()
+    .find_map(|stmt| {
+      if let oc::ast::Statement::Match(m) = stmt
+      {
+        Some(m)
+      }
+      else
+      {
+        None
+      }
+    })
+    .expect("Expected to find a MATCH statement");
+
+  assert_eq!(match_stmt.patterns.len(), 1);
+  if let oc::ast::Pattern::Path(path_pattern) = &match_stmt.patterns[0]
+  {
+    assert!(
+      path_pattern.edge.predicate.is_some(),
+      "Expected path edge predicate to be Some"
+    );
+  }
+  else
+  {
+    panic!("Expected Pattern::Path");
+  }
+}
+
+#[test]
+fn test_parse_create_with_edge_predicate_fails()
+{
+  let result = parse("CREATE (a)-[l:LINK WHERE l.x = 1]->(b)");
+  assert!(
+    result.is_err(),
+    "Expected parsing CREATE with edge predicate to fail"
+  );
+  if let Err(ref err) = result
+  {
+    // Verify the error is CreatingWithPredicate
+    assert!(
+      err.to_string().contains("CreatingWithPredicate"),
+      "Expected CreatingWithPredicate error, got: {}",
+      err
+    );
+  }
+}
+
+#[test]
+fn test_parse_create_with_destination_node_predicate_fails()
+{
+  let result = parse("CREATE (a)-[:LINK]->(b WHERE b.x = 1)");
+  assert!(
+    result.is_err(),
+    "Expected parsing CREATE with node predicate to fail"
+  );
+  if let Err(ref err) = result
+  {
+    // Verify the error is CreatingWithPredicate
+    assert!(
+      err.to_string().contains("CreatingWithPredicate"),
+      "Expected CreatingWithPredicate error, got: {}",
+      err
+    );
+  }
+}
+
+#[test]
+fn test_parse_conflicting_quantifiers_fails()
+{
+  let result = parse("MATCH (a)-[:R*1..3]->{4,5}(b) RETURN a");
+  assert!(
+    result.is_err(),
+    "Expected parsing with both legacy and new quantifiers to fail"
+  );
+  if let Err(ref err) = result
+  {
+    // Verify the error is ConflictingQuantifiers
+    assert!(
+      err.to_string().contains("ConflictingQuantifiers"),
+      "Expected ConflictingQuantifiers error, got: {}",
+      err
+    );
+  }
+}
+
+#[test]
+fn test_parse_legacy_quantifier_only_succeeds()
+{
+  let result = parse("MATCH (a)-[:R*1..3]->(b) RETURN a");
+  assert!(
+    result.is_ok(),
+    "Expected parsing with legacy quantifier only to succeed, got: {:?}",
+    result.err()
+  );
+}
+
+#[test]
+fn test_parse_new_quantifier_only_succeeds()
+{
+  let result = parse("MATCH (a)-[:R]->{4,5}(b) RETURN a");
+  assert!(
+    result.is_ok(),
+    "Expected parsing with new quantifier only to succeed, got: {:?}",
+    result.err()
+  );
+}
+
+#[test]
+fn test_parse_legacy_quantifier_emits_quantified_path()
+{
+  let result = parse("MATCH (a)-[:R*1..3]->(b) RETURN a");
+  assert!(
+    result.is_ok(),
+    "Expected parsing legacy quantifier to succeed, got: {:?}",
+    result.err()
+  );
+  if let Ok(queries) = result
+  {
+    assert!(!queries.is_empty(), "Expected at least one query");
+    if let gqlparser::oc::ast::Query::Statements(statements) = &queries[0]
+    {
+      assert!(!statements.is_empty(), "Expected at least one statement");
+      if let gqlparser::oc::ast::Statement::Match(match_clause) = &statements[0]
+      {
+        assert!(
+          !match_clause.patterns.is_empty(),
+          "Expected patterns in MATCH"
+        );
+        // Find the QuantifiedPath pattern
+        let has_quantified_path = match_clause.patterns.iter().any(|p| {
+          matches!(p, gqlparser::oc::ast::Pattern::QuantifiedPath(qp) 
+            if qp.variable.is_none() 
+            && qp.quantifier == Some(1..3)
+            && qp.group.len() == 1
+            && matches!(&qp.group[0], gqlparser::oc::ast::Pattern::Edge(_)))
+        });
+        assert!(
+          has_quantified_path,
+          "Expected QuantifiedPath pattern with quantifier Some(1..3) and group containing single Edge"
+        );
+      }
+    }
+  }
+}
+
+#[test]
+fn test_parse_new_quantifier_emits_quantified_path()
+{
+  let result = parse("MATCH (a)-[:R]->{1,3}(b) RETURN a");
+  assert!(
+    result.is_ok(),
+    "Expected parsing new quantifier to succeed, got: {:?}",
+    result.err()
+  );
+  if let Ok(queries) = result
+  {
+    assert!(!queries.is_empty(), "Expected at least one query");
+    if let gqlparser::oc::ast::Query::Statements(statements) = &queries[0]
+    {
+      assert!(!statements.is_empty(), "Expected at least one statement");
+      if let gqlparser::oc::ast::Statement::Match(match_clause) = &statements[0]
+      {
+        assert!(
+          !match_clause.patterns.is_empty(),
+          "Expected patterns in MATCH"
+        );
+        // Find the QuantifiedPath pattern
+        let has_quantified_path = match_clause.patterns.iter().any(|p| {
+          matches!(p, gqlparser::oc::ast::Pattern::QuantifiedPath(qp)
+            if qp.variable.is_none()
+            && qp.quantifier == Some(1..3)
+            && qp.group.len() == 1
+            && matches!(&qp.group[0], gqlparser::oc::ast::Pattern::Edge(_)))
+        });
+        assert!(
+          has_quantified_path,
+          "Expected QuantifiedPath pattern with quantifier Some(1..3) and group containing single Edge"
+        );
+      }
+    }
+  }
+}
+
+#[test]
+fn test_parse_quantified_edge_chain_preserves_continuity()
+{
+  let result = parse("MATCH (a)-[:R]->(b)-[:S*1..2]->(c) RETURN a");
+  assert!(
+    result.is_ok(),
+    "Expected parsing edge chain with quantified edge to succeed, got: {:?}",
+    result.err()
+  );
+  if let Ok(queries) = result
+  {
+    assert!(!queries.is_empty(), "Expected at least one query");
+    if let gqlparser::oc::ast::Query::Statements(statements) = &queries[0]
+    {
+      assert!(!statements.is_empty(), "Expected at least one statement");
+      if let gqlparser::oc::ast::Statement::Match(match_clause) = &statements[0]
+      {
+        assert!(
+          !match_clause.patterns.is_empty(),
+          "Expected patterns in MATCH"
+        );
+        // Count patterns: should have Edge(R), QuantifiedPath(S)
+        let has_edge = match_clause
+          .patterns
+          .iter()
+          .any(|p| matches!(p, gqlparser::oc::ast::Pattern::Edge(_)));
+        let has_quantified_path = match_clause.patterns.iter().any(|p| {
+          matches!(p, gqlparser::oc::ast::Pattern::QuantifiedPath(qp)
+            if qp.variable.is_none()
+            && qp.quantifier == Some(1..2)
+            && qp.group.len() == 1
+            && matches!(&qp.group[0], gqlparser::oc::ast::Pattern::Edge(_)))
+        });
+        assert!(
+          has_edge && has_quantified_path,
+          "Expected chain to contain ordinary Edge and QuantifiedPath pattern"
+        );
+      }
+    }
+  }
+}
+
+#[test]
+fn test_parse_path_variable_quantified_legacy_quantifier()
+{
+  let result = parse("MATCH p = (a)-[:R*1..3]->(b) RETURN p");
+  assert!(
+    result.is_ok(),
+    "Expected parsing path variable with legacy quantifier to succeed, got: {:?}",
+    result.err()
+  );
+  if let Ok(queries) = result
+  {
+    assert!(!queries.is_empty(), "Expected at least one query");
+    if let gqlparser::oc::ast::Query::Statements(statements) = &queries[0]
+    {
+      assert!(!statements.is_empty(), "Expected at least one statement");
+      if let gqlparser::oc::ast::Statement::Match(match_clause) = &statements[0]
+      {
+        assert!(
+          !match_clause.patterns.is_empty(),
+          "Expected patterns in MATCH"
+        );
+        // Find the QuantifiedPath pattern with variable p
+        let has_quantified_path_with_variable = match_clause.patterns.iter().any(|p| {
+          matches!(p, gqlparser::oc::ast::Pattern::QuantifiedPath(qp)
+            if qp.variable.is_some()
+            && qp.variable.as_ref().unwrap().name() == "p"
+            && qp.quantifier == Some(1..3)
+            && qp.group.len() == 1
+            && matches!(&qp.group[0], gqlparser::oc::ast::Pattern::Edge(_)))
+        });
+        assert!(
+          has_quantified_path_with_variable,
+          "Expected QuantifiedPath pattern with variable Some(p) and quantifier Some(1..3)"
+        );
+      }
+    }
+  }
+}
+
+#[test]
+fn test_parse_path_variable_quantified_new_quantifier()
+{
+  let result = parse("MATCH p = (a)-[:R]->{1,3}(b) RETURN p");
+  assert!(
+    result.is_ok(),
+    "Expected parsing path variable with new quantifier to succeed, got: {:?}",
+    result.err()
+  );
+  if let Ok(queries) = result
+  {
+    assert!(!queries.is_empty(), "Expected at least one query");
+    if let gqlparser::oc::ast::Query::Statements(statements) = &queries[0]
+    {
+      assert!(!statements.is_empty(), "Expected at least one statement");
+      if let gqlparser::oc::ast::Statement::Match(match_clause) = &statements[0]
+      {
+        assert!(
+          !match_clause.patterns.is_empty(),
+          "Expected patterns in MATCH"
+        );
+        // Find the QuantifiedPath pattern with variable p
+        let has_quantified_path_with_variable = match_clause.patterns.iter().any(|p| {
+          matches!(p, gqlparser::oc::ast::Pattern::QuantifiedPath(qp)
+            if qp.variable.is_some()
+            && qp.variable.as_ref().unwrap().name() == "p"
+            && qp.quantifier == Some(1..3)
+            && qp.group.len() == 1
+            && matches!(&qp.group[0], gqlparser::oc::ast::Pattern::Edge(_)))
+        });
+        assert!(
+          has_quantified_path_with_variable,
+          "Expected QuantifiedPath pattern with variable Some(p) and quantifier Some(1..3)"
+        );
+      }
+    }
+  }
+}
+
+#[test]
+fn test_parse_quantified_path_source_destination_populated()
+{
+  let result = parse("MATCH (a)-[:R*1..3]->(b) RETURN a");
+  assert!(
+    result.is_ok(),
+    "Expected parsing quantified path to succeed, got: {:?}",
+    result.err()
+  );
+  if let Ok(queries) = result
+  {
+    assert!(!queries.is_empty(), "Expected at least one query");
+    if let gqlparser::oc::ast::Query::Statements(statements) = &queries[0]
+    {
+      assert!(!statements.is_empty(), "Expected at least one statement");
+      if let gqlparser::oc::ast::Statement::Match(match_clause) = &statements[0]
+      {
+        assert!(
+          !match_clause.patterns.is_empty(),
+          "Expected patterns in MATCH"
+        );
+        // Find the QuantifiedPath pattern and verify source/destination are populated
+        let found_qp_with_endpoints = match_clause.patterns.iter().any(|p| {
+          if let gqlparser::oc::ast::Pattern::QuantifiedPath(qp) = p
+          {
+            // Verify that source and destination are populated
+            let qp_source_var = &qp.source.variable;
+            let qp_destination_var = &qp.destination.variable;
+
+            // Get the edge from the group to compare
+            if let Some(gqlparser::oc::ast::Pattern::Edge(edge)) = qp.group.first()
+            {
+              // The source of the quantified path should match the edge's source
+              // The destination of the quantified path should match the edge's destination
+              let source_matches = qp_source_var == &edge.source.variable;
+              let destination_matches = qp_destination_var == &edge.destination.variable;
+              return source_matches && destination_matches;
+            }
+          }
+          false
+        });
+        assert!(
+          found_qp_with_endpoints,
+          "Expected QuantifiedPath with populated source/destination matching edge endpoints"
+        );
+      }
+    }
+  }
+}
+
+#[test]
+fn test_parse_path_variable_quantified_group_binding()
+{
+  let result = parse("MATCH p = (a) ((n)-[r:KNOWS]->(m)){1,5} (b) RETURN p");
+  assert!(
+    result.is_ok(),
+    "Expected parsing path variable with quantified group to succeed, got: {:?}",
+    result.err()
+  );
+  if let Ok(queries) = result
+  {
+    assert!(!queries.is_empty(), "Expected at least one query");
+    if let gqlparser::oc::ast::Query::Statements(statements) = &queries[0]
+    {
+      assert!(!statements.is_empty(), "Expected at least one statement");
+      if let gqlparser::oc::ast::Statement::Match(match_clause) = &statements[0]
+      {
+        assert!(
+          !match_clause.patterns.is_empty(),
+          "Expected patterns in MATCH"
+        );
+        let has_group_path_variable = match_clause.patterns.iter().any(|p| {
+          matches!(p, gqlparser::oc::ast::Pattern::QuantifiedPath(qp)
+            if qp.variable.as_ref().is_some_and(|v| v.name() == "p")
+            && qp.group.len() == 1
+            && matches!(&qp.group[0], gqlparser::oc::ast::Pattern::Edge(_))
+            && qp.source.variable.as_ref().is_some_and(|v| v.name() == "a")
+            && qp.destination.variable.as_ref().is_some_and(|v| v.name() == "b"))
+        });
+        assert!(
+          has_group_path_variable,
+          "Expected QuantifiedPath pattern with variable Some(p), one inner edge, and anchors a/b"
+        );
+      }
+    }
+  }
+}
+
+#[test]
+fn test_parse_group_pattern_without_path_variable()
+{
+  let result = parse("MATCH (a) ((n)-[r:KNOWS]->(m)){1,5} (b) RETURN a");
+  assert!(
+    result.is_ok(),
+    "Expected parsing quantified group to succeed, got: {:?}",
+    result.err()
+  );
+  if let Ok(queries) = result
+  {
+    assert!(!queries.is_empty(), "Expected at least one query");
+    if let gqlparser::oc::ast::Query::Statements(statements) = &queries[0]
+    {
+      assert!(!statements.is_empty(), "Expected at least one statement");
+      if let gqlparser::oc::ast::Statement::Match(match_clause) = &statements[0]
+      {
+        assert!(
+          !match_clause.patterns.is_empty(),
+          "Expected patterns in MATCH"
+        );
+        let has_group = match_clause.patterns.iter().any(|p| {
+          matches!(p, gqlparser::oc::ast::Pattern::QuantifiedPath(qp)
+            if qp.variable.is_none()
+            && qp.group.len() == 1
+            && qp.source.variable.as_ref().is_some_and(|v| v.name() == "a")
+            && qp.destination.variable.as_ref().is_some_and(|v| v.name() == "b")
+            && matches!(&qp.group[0], gqlparser::oc::ast::Pattern::Edge(_)))
+        });
+        assert!(
+          has_group,
+          "Expected QuantifiedPath pattern for quantified group with anchors a/b and one inner edge"
+        );
+      }
+    }
+  }
+}
+
+#[test]
+fn test_parse_group_pattern_with_where_clause()
+{
+  let result = parse("MATCH (a) ((n)-[r:KNOWS]->(m) WHERE n.x > 1){1,5} (b) RETURN a");
+  assert!(
+    result.is_ok(),
+    "Expected parsing quantified group with WHERE to succeed, got: {:?}",
+    result.err()
+  );
+  if let Ok(queries) = result
+  {
+    assert!(!queries.is_empty(), "Expected at least one query");
+    if let gqlparser::oc::ast::Query::Statements(statements) = &queries[0]
+    {
+      assert!(!statements.is_empty(), "Expected at least one statement");
+      if let gqlparser::oc::ast::Statement::Match(match_clause) = &statements[0]
+      {
+        let has_group_where = match_clause.patterns.iter().any(|p| {
+          matches!(p, gqlparser::oc::ast::Pattern::QuantifiedPath(qp)
+            if qp.group_where.is_some())
+        });
+        assert!(
+          has_group_where,
+          "Expected QuantifiedPath pattern with group_where Some(_)"
+        );
+      }
+    }
+  }
+}
+
+#[test]
+fn test_parse_group_pattern_multiple_inner_edges()
+{
+  let result = parse("MATCH (a) ((n)-[:R]->(m)-[:S]->(k)){1,3} (b) RETURN a");
+  assert!(
+    result.is_ok(),
+    "Expected parsing quantified group with multiple inner edges to succeed, got: {:?}",
+    result.err()
+  );
+  if let Ok(queries) = result
+  {
+    assert!(!queries.is_empty(), "Expected at least one query");
+    if let gqlparser::oc::ast::Query::Statements(statements) = &queries[0]
+    {
+      assert!(!statements.is_empty(), "Expected at least one statement");
+      if let gqlparser::oc::ast::Statement::Match(match_clause) = &statements[0]
+      {
+        let has_two_edge_group = match_clause.patterns.iter().any(|p| {
+          matches!(p, gqlparser::oc::ast::Pattern::QuantifiedPath(qp)
+            if qp.group.len() == 2)
+        });
+        assert!(
+          has_two_edge_group,
+          "Expected QuantifiedPath pattern whose inner group contains two edges"
+        );
+      }
+    }
+  }
+}
+
+#[test]
+fn test_parse_group_pattern_chain_continuation()
+{
+  let result = parse("MATCH (a) ((n)-[:R]->(m)){1,3} (b)-[:S]->(c) RETURN a");
+  assert!(
+    result.is_ok(),
+    "Expected parsing quantified group followed by edge continuation to succeed, got: {:?}",
+    result.err()
+  );
+  if let Ok(queries) = result
+  {
+    assert!(!queries.is_empty(), "Expected at least one query");
+    if let gqlparser::oc::ast::Query::Statements(statements) = &queries[0]
+    {
+      assert!(!statements.is_empty(), "Expected at least one statement");
+      if let gqlparser::oc::ast::Statement::Match(match_clause) = &statements[0]
+      {
+        assert_eq!(
+          match_clause.patterns.len(),
+          2,
+          "Expected exactly two top-level patterns: quantified group and following edge"
+        );
+        let quant = match_clause.patterns.first().and_then(|p| match p
+        {
+          gqlparser::oc::ast::Pattern::QuantifiedPath(qp) => Some(qp),
+          _ => None,
+        });
+        let edge = match_clause.patterns.get(1).and_then(|p| match p
+        {
+          gqlparser::oc::ast::Pattern::Edge(e) => Some(e),
+          _ => None,
+        });
+        assert!(
+          quant.is_some(),
+          "Expected first top-level pattern to be QuantifiedPath"
+        );
+        assert!(
+          edge.is_some(),
+          "Expected second top-level pattern to be Edge"
+        );
+        let quant = quant.unwrap();
+        let edge = edge.unwrap();
+        assert_eq!(
+          quant
+            .destination
+            .variable
+            .as_ref()
+            .map(|v| v.name().clone()),
+          Some("b".to_string()),
+          "Expected quantified group destination to be b"
+        );
+        assert_eq!(
+          edge.source.variable.as_ref().map(|v| v.name().clone()),
+          Some("b".to_string()),
+          "Expected following edge source to continue from group destination b"
+        );
+      }
+    }
+  }
+}
+
+#[test]
+fn test_parse_group_pattern_quantifier_variants()
+{
+  for (suffix, expected) in [
+    ("{1,5}", Some(1..5)),
+    ("{3}", Some(3..3)),
+    ("{2,}", Some(2..usize::MAX)),
+    ("{,4}", Some(0..4)),
+    ("+", Some(1..usize::MAX)),
+    ("*", Some(0..usize::MAX)),
+  ]
+  {
+    let query = format!("MATCH (a) ((n)-[:R]->(m)){suffix} (b) RETURN a");
+    let result = parse(&query);
+    assert!(
+      result.is_ok(),
+      "Expected parsing quantified group with quantifier {suffix} to succeed, got: {:?}",
+      result.err()
+    );
+    if let Ok(queries) = result
+      && let gqlparser::oc::ast::Query::Statements(statements) = &queries[0]
+      && let gqlparser::oc::ast::Statement::Match(match_clause) = &statements[0]
+    {
+      let found = match_clause.patterns.iter().any(|p| {
+        matches!(p, gqlparser::oc::ast::Pattern::QuantifiedPath(qp)
+              if qp.quantifier == expected)
+      });
+      assert!(
+        found,
+        "Expected QuantifiedPath pattern with quantifier {:?} for suffix {suffix}",
+        expected
+      );
+    }
+  }
+}
+
+#[test]
+fn test_parse_path_variable_unquantified_edge_regression()
+{
+  let result = parse("MATCH p = (a)-[:R]->(b) RETURN p");
+  assert!(
+    result.is_ok(),
+    "Expected parsing path variable with unquantified edge to succeed, got: {:?}",
+    result.err()
+  );
+  if let Ok(queries) = result
+  {
+    assert!(!queries.is_empty(), "Expected at least one query");
+    if let gqlparser::oc::ast::Query::Statements(statements) = &queries[0]
+    {
+      assert!(!statements.is_empty(), "Expected at least one statement");
+      if let gqlparser::oc::ast::Statement::Match(match_clause) = &statements[0]
+      {
+        assert!(
+          !match_clause.patterns.is_empty(),
+          "Expected patterns in MATCH"
+        );
+        // Find the Path pattern (not QuantifiedPath) with variable p
+        let has_path_pattern = match_clause.patterns.iter().any(|p| {
+          matches!(p, gqlparser::oc::ast::Pattern::Path(path_pattern)
+            if path_pattern.variable.name() == "p")
+        });
+        assert!(
+          has_path_pattern,
+          "Expected Path pattern with variable p (unquantified edges still use PathPattern)"
+        );
+      }
+    }
+  }
+}
+
+#[test]
+fn test_parse_path_variable_mixed_quantified_unquantified_chain()
+{
+  let result = parse("MATCH p = (a)-[:R]->(b)-[:S*1..3]->(c) RETURN p");
+  assert!(
+    result.is_ok(),
+    "Expected parsing mixed quantified/unquantified chain to succeed, got: {:?}",
+    result.err()
+  );
+  // Mixed chains with quantified and unquantified edges are now accepted
+  // and combined into a single PathPattern (quantifiers on individual edges are
+  // preserved as QuantifiedPath nodes internally, but the path variable combines
+  // them). Proper semantic handling of mixed chains is deferred to Milestone 3.
+}
+
+// =============================================================================
+// Path Selector Tests (WI #655)
+// =============================================================================
+
+// Test 1: Every PathSelector variant applied to a quantified pattern
+// (confirms the qp.selector = selector branch)
+
+#[test]
+fn test_parse_selector_all_with_quantified_pattern()
+{
+  let result = parse("MATCH p = ALL (a)-[:R*1..3]->(b) RETURN p");
+  assert!(
+    result.is_ok(),
+    "Expected ALL selector with quantified pattern to succeed, got: {:?}",
+    result.err()
+  );
+  if let Ok(queries) = result
+    && let gqlparser::oc::ast::Query::Statements(statements) = &queries[0]
+    && let gqlparser::oc::ast::Statement::Match(match_clause) = &statements[0]
+  {
+    let has_all_selector = match_clause.patterns.iter().any(|p| {
+      matches!(p, gqlparser::oc::ast::Pattern::QuantifiedPath(qp)
+            if matches!(qp.selector, gqlparser::oc::ast::PathSelector::All))
+    });
+    assert!(
+      has_all_selector,
+      "Expected QuantifiedPath with PathSelector::All"
+    );
+  }
+}
+
+#[test]
+fn test_parse_selector_any_with_quantified_pattern()
+{
+  let result = parse("MATCH p = ANY (a)-[:R*1..3]->(b) RETURN p");
+  assert!(
+    result.is_ok(),
+    "Expected ANY selector with quantified pattern to succeed, got: {:?}",
+    result.err()
+  );
+  if let Ok(queries) = result
+    && let gqlparser::oc::ast::Query::Statements(statements) = &queries[0]
+    && let gqlparser::oc::ast::Statement::Match(match_clause) = &statements[0]
+  {
+    let has_any_selector = match_clause.patterns.iter().any(|p| {
+      matches!(p, gqlparser::oc::ast::Pattern::QuantifiedPath(qp)
+            if matches!(qp.selector, gqlparser::oc::ast::PathSelector::Any))
+    });
+    assert!(
+      has_any_selector,
+      "Expected QuantifiedPath with PathSelector::Any"
+    );
+  }
+}
+
+#[test]
+fn test_parse_selector_all_shortest_with_quantified_pattern()
+{
+  let result = parse("MATCH p = ALL SHORTEST (a)-[:R*1..3]->(b) RETURN p");
+  assert!(
+    result.is_ok(),
+    "Expected ALL SHORTEST selector with quantified pattern to succeed, got: {:?}",
+    result.err()
+  );
+  if let Ok(queries) = result
+    && let gqlparser::oc::ast::Query::Statements(statements) = &queries[0]
+    && let gqlparser::oc::ast::Statement::Match(match_clause) = &statements[0]
+  {
+    let has_all_shortest_selector = match_clause.patterns.iter().any(|p| {
+      matches!(p, gqlparser::oc::ast::Pattern::QuantifiedPath(qp)
+            if matches!(qp.selector, gqlparser::oc::ast::PathSelector::AllShortest))
+    });
+    assert!(
+      has_all_shortest_selector,
+      "Expected QuantifiedPath with PathSelector::AllShortest"
+    );
+  }
+}
+
+#[test]
+fn test_parse_selector_shortest_k_with_quantified_pattern()
+{
+  let result = parse("MATCH p = SHORTEST 2 (a)-[:R*1..3]->(b) RETURN p");
+  assert!(
+    result.is_ok(),
+    "Expected SHORTEST 2 selector with quantified pattern to succeed, got: {:?}",
+    result.err()
+  );
+  if let Ok(queries) = result
+    && let gqlparser::oc::ast::Query::Statements(statements) = &queries[0]
+    && let gqlparser::oc::ast::Statement::Match(match_clause) = &statements[0]
+  {
+    let has_shortest_selector = match_clause.patterns.iter().any(|p| {
+      matches!(p, gqlparser::oc::ast::Pattern::QuantifiedPath(qp)
+            if matches!(qp.selector, gqlparser::oc::ast::PathSelector::Shortest(_)))
+    });
+    assert!(
+      has_shortest_selector,
+      "Expected QuantifiedPath with PathSelector::Shortest(_)"
+    );
+  }
+}
+
+#[test]
+fn test_parse_selector_shortest_groups_with_quantified_pattern()
+{
+  let result = parse("MATCH p = SHORTEST 3 GROUPS (a)-[:R*1..3]->(b) RETURN p");
+  assert!(
+    result.is_ok(),
+    "Expected SHORTEST 3 GROUPS selector with quantified pattern to succeed, got: {:?}",
+    result.err()
+  );
+  if let Ok(queries) = result
+    && let gqlparser::oc::ast::Query::Statements(statements) = &queries[0]
+    && let gqlparser::oc::ast::Statement::Match(match_clause) = &statements[0]
+  {
+    let has_shortest_groups_selector = match_clause.patterns.iter().any(|p| {
+      matches!(p, gqlparser::oc::ast::Pattern::QuantifiedPath(qp)
+            if matches!(qp.selector, gqlparser::oc::ast::PathSelector::ShortestGroups(_)))
+    });
+    assert!(
+      has_shortest_groups_selector,
+      "Expected QuantifiedPath with PathSelector::ShortestGroups(_)"
+    );
+  }
+}
+
+// Test 2: Every PathSelector variant applied to a plain, non-quantified edge
+// (confirms the scoping-wrapper branch, quantifier: None)
+
+#[test]
+fn test_parse_selector_all_with_plain_edge()
+{
+  let result = parse("MATCH ALL (a)-[:R]->(b) RETURN a");
+  assert!(
+    result.is_ok(),
+    "Expected ALL selector with plain edge to succeed, got: {:?}",
+    result.err()
+  );
+  if let Ok(queries) = result
+    && let gqlparser::oc::ast::Query::Statements(statements) = &queries[0]
+    && let gqlparser::oc::ast::Statement::Match(match_clause) = &statements[0]
+  {
+    let has_all_selector = match_clause.patterns.iter().any(|p| {
+      matches!(p, gqlparser::oc::ast::Pattern::QuantifiedPath(qp)
+            if matches!(qp.selector, gqlparser::oc::ast::PathSelector::All)
+            && qp.quantifier.is_none())
+    });
+    assert!(
+      has_all_selector,
+      "Expected QuantifiedPath with PathSelector::All and quantifier: None"
+    );
+  }
+}
+
+#[test]
+fn test_parse_selector_any_with_plain_edge()
+{
+  let result = parse("MATCH ANY (a)-[:R]->(b) RETURN a");
+  assert!(
+    result.is_ok(),
+    "Expected ANY selector with plain edge to succeed, got: {:?}",
+    result.err()
+  );
+  if let Ok(queries) = result
+    && let gqlparser::oc::ast::Query::Statements(statements) = &queries[0]
+    && let gqlparser::oc::ast::Statement::Match(match_clause) = &statements[0]
+  {
+    let has_any_selector = match_clause.patterns.iter().any(|p| {
+      matches!(p, gqlparser::oc::ast::Pattern::QuantifiedPath(qp)
+            if matches!(qp.selector, gqlparser::oc::ast::PathSelector::Any)
+            && qp.quantifier.is_none())
+    });
+    assert!(
+      has_any_selector,
+      "Expected QuantifiedPath with PathSelector::Any and quantifier: None"
+    );
+  }
+}
+
+#[test]
+fn test_parse_selector_all_shortest_with_plain_edge()
+{
+  let result = parse("MATCH ALL SHORTEST (a)-[:R]->(b) RETURN a");
+  assert!(
+    result.is_ok(),
+    "Expected ALL SHORTEST selector with plain edge to succeed, got: {:?}",
+    result.err()
+  );
+  if let Ok(queries) = result
+    && let gqlparser::oc::ast::Query::Statements(statements) = &queries[0]
+    && let gqlparser::oc::ast::Statement::Match(match_clause) = &statements[0]
+  {
+    let has_all_shortest_selector = match_clause.patterns.iter().any(|p| {
+      matches!(p, gqlparser::oc::ast::Pattern::QuantifiedPath(qp)
+            if matches!(qp.selector, gqlparser::oc::ast::PathSelector::AllShortest)
+            && qp.quantifier.is_none())
+    });
+    assert!(
+      has_all_shortest_selector,
+      "Expected QuantifiedPath with PathSelector::AllShortest and quantifier: None"
+    );
+  }
+}
+
+#[test]
+fn test_parse_selector_shortest_k_with_plain_edge()
+{
+  let result = parse("MATCH SHORTEST 1 (a)-[:R]->(b) RETURN a");
+  assert!(
+    result.is_ok(),
+    "Expected SHORTEST 1 selector with plain edge to succeed, got: {:?}",
+    result.err()
+  );
+  if let Ok(queries) = result
+    && let gqlparser::oc::ast::Query::Statements(statements) = &queries[0]
+    && let gqlparser::oc::ast::Statement::Match(match_clause) = &statements[0]
+  {
+    let has_shortest_selector = match_clause.patterns.iter().any(|p| {
+      matches!(p, gqlparser::oc::ast::Pattern::QuantifiedPath(qp)
+            if matches!(qp.selector, gqlparser::oc::ast::PathSelector::Shortest(_))
+            && qp.quantifier.is_none())
+    });
+    assert!(
+      has_shortest_selector,
+      "Expected QuantifiedPath with PathSelector::Shortest(_) and quantifier: None"
+    );
+  }
+}
+
+#[test]
+fn test_parse_selector_shortest_groups_with_plain_edge()
+{
+  let result = parse("MATCH SHORTEST 5 GROUPS (a)-[:R]->(b) RETURN a");
+  assert!(
+    result.is_ok(),
+    "Expected SHORTEST 5 GROUPS selector with plain edge to succeed, got: {:?}",
+    result.err()
+  );
+  if let Ok(queries) = result
+    && let gqlparser::oc::ast::Query::Statements(statements) = &queries[0]
+    && let gqlparser::oc::ast::Statement::Match(match_clause) = &statements[0]
+  {
+    let has_shortest_groups_selector = match_clause.patterns.iter().any(|p| {
+      matches!(p, gqlparser::oc::ast::Pattern::QuantifiedPath(qp)
+            if matches!(qp.selector, gqlparser::oc::ast::PathSelector::ShortestGroups(_))
+            && qp.quantifier.is_none())
+    });
+    assert!(
+      has_shortest_groups_selector,
+      "Expected QuantifiedPath with PathSelector::ShortestGroups(_) and quantifier: None"
+    );
+  }
+}
+
+// Test 3: Error cases - selector with no pattern following or with bare node
+
+#[test]
+fn test_parse_selector_no_pattern_should_error()
+{
+  let result = parse("MATCH SHORTEST 1 RETURN a");
+  assert!(
+    result.is_err(),
+    "Expected SHORTEST 1 with no pattern to error, got: {:?}",
+    result
+  );
+}
+
+#[test]
+fn test_parse_selector_with_bare_node_should_error()
+{
+  let result = parse("MATCH SHORTEST 1 (a) RETURN a");
+  assert!(
+    result.is_err(),
+    "Expected SHORTEST 1 with bare node to error, got: {:?}",
+    result
+  );
+}
+
+// Test 4: Regression - verify selector-free tests still pass
+// (Each test individually verifies that existing functionality is not broken)
+
+#[test]
+fn test_selector_regression_simple_match()
+{
+  let result = parse("MATCH (a) RETURN a");
+  assert!(
+    result.is_ok(),
+    "Regression: Expected simple MATCH to still parse, got: {:?}",
+    result.err()
+  );
+}
+
+#[test]
+fn test_selector_regression_edge_match()
+{
+  let result = parse("MATCH (a)-[:R]->(b) RETURN a");
+  assert!(
+    result.is_ok(),
+    "Regression: Expected edge MATCH to still parse, got: {:?}",
+    result.err()
+  );
+}
+
+#[test]
+fn test_selector_regression_quantified_pattern()
+{
+  let result = parse("MATCH p = (a)-[:R*1..3]->(b) RETURN p");
+  assert!(
+    result.is_ok(),
+    "Regression: Expected quantified pattern to still parse, got: {:?}",
+    result.err()
+  );
+}
+
+#[test]
+fn test_selector_regression_path_variable()
+{
+  let result = parse("MATCH p = (a)-[:R]->(b) RETURN p");
+  assert!(
+    result.is_ok(),
+    "Regression: Expected path variable to still parse, got: {:?}",
+    result.err()
+  );
+}
+
+// WI689 Tests: Empty quantified groups and terminal node tracking
+
+#[test]
+fn test_empty_quantified_group_should_error()
+{
+  let result = parse("MATCH (a) ((n)){1,5} (b) RETURN a");
+  assert!(
+    result.is_err(),
+    "Expected empty quantified group to error, got: {:?}",
+    result
+  );
+}
+
+#[test]
+fn test_quantified_group_with_unnamed_terminal_node()
+{
+  let result = parse("MATCH (a) ((n)-[r]->()) {1,5} (b) RETURN a");
+  assert!(
+    result.is_ok(),
+    "Expected quantified group with unnamed terminal node to parse, got: {:?}",
+    result.err()
+  );
+
+  // Verify that the edge's destination now has a variable assigned
+  let queries = result.unwrap();
+  let oc::ast::Query::Statements(ast) = queries.into_iter().next().unwrap()
+  else
+  {
+    panic!("Expected Statements query");
+  };
+
+  // The AST should contain a QuantifiedPath pattern
+  let found_qp = ast.iter().any(|stmt| {
+    if let oc::ast::Statement::Match(match_stmt) = stmt
+    {
+      match_stmt.patterns.iter().any(|p| {
+        if let oc::ast::Pattern::QuantifiedPath(qp) = p
+        {
+          // The last edge in the group should have a destination variable
+          qp.group
+            .iter()
+            .rev()
+            .find_map(|p| {
+              if let oc::ast::Pattern::Edge(e) = p
+              {
+                e.destination.variable.is_some().then_some(())
+              }
+              else
+              {
+                None
+              }
+            })
+            .is_some()
+        }
+        else
+        {
+          false
+        }
+      })
+    }
+    else
+    {
+      false
+    }
+  });
+
+  assert!(
+    found_qp,
+    "Expected to find a quantified path with a terminal variable"
+  );
+}
+
+#[test]
+fn test_quantified_group_with_named_terminal_node_preserved()
+{
+  let result = parse("MATCH (a) ((n)-[r]->(m)){1,5} (b) RETURN a");
+  assert!(
+    result.is_ok(),
+    "Expected quantified group with named terminal node to parse, got: {:?}",
+    result.err()
+  );
+
+  // Verify that the named variable is preserved
+  let queries = result.unwrap();
+  let oc::ast::Query::Statements(ast) = queries.into_iter().next().unwrap()
+  else
+  {
+    panic!("Expected Statements query");
+  };
+
+  // The AST should contain a QuantifiedPath pattern with the correct variable name
+  let found_qp = ast.iter().any(|stmt| {
+    if let oc::ast::Statement::Match(match_stmt) = stmt
+    {
+      match_stmt.patterns.iter().any(|p| {
+        if let oc::ast::Pattern::QuantifiedPath(qp) = p
+        {
+          // The last edge in the group should have a destination variable named "m"
+          qp.group
+            .iter()
+            .rev()
+            .find_map(|p| {
+              if let oc::ast::Pattern::Edge(e) = p
+              {
+                e.destination
+                  .variable
+                  .as_ref()
+                  .and_then(|v| if v.name() == "m" { Some(()) } else { None })
+              }
+              else
+              {
+                None
+              }
+            })
+            .is_some()
+        }
+        else
+        {
+          false
+        }
+      })
+    }
+    else
+    {
+      false
+    }
+  });
+
+  assert!(
+    found_qp,
+    "Expected to find a quantified path with terminal variable named 'm'"
+  );
+}
+
+#[test]
+fn test_parse_group_single_edge_range()
+{
+  let ast = parse_query("MATCH (a) ((n)-[:R]->(m)){1,3} (b) RETURN a, b");
+  compare_ast(ast, ast::group_single_edge_range())
+}
+
+#[test]
+fn test_parse_group_two_edges_range()
+{
+  let ast = parse_query("MATCH (a) ((n)-[:R1]->(x)-[:R2]->(m)){1,3} (b) RETURN a, b");
+  compare_ast(ast, ast::group_two_edges_range())
+}
+
+#[test]
+fn test_parse_shortest_single_edge_full_return()
+{
+  let ast = parse_query("MATCH p = SHORTEST 1 (a)-[:R]-+(b) RETURN a, b, length(p)");
+  compare_ast(ast, ast::shortest_single_edge_full_return())
+}