gqlite 1.8.1 → 1.8.2

data/ext/gqlparser/src/oc/parser/tests.rs

@@ -421,7 +421,7 @@ fn test_oc_parse_relational_binary_operator()
 #[test]
 fn test_oc_parse_node_pattern_simple()
 {
-  let actual = parse("(n:Person)", node_pattern);
+  let actual = parse("(n:Person)", node_pattern::<AllowUndirected>);
 
   let expected = ast::NodePattern {
     variable: ast::VariableIdentifier {
@@ -431,6 +431,8 @@ fn test_oc_parse_node_pattern_simple()
     .into(),
     labels: ast::LabelExpression::String("Person".to_string()),
     properties: None,
+
+    predicate: None,
   };
   compare_ast(actual, expected);
 }
@@ -438,7 +440,7 @@ fn test_oc_parse_node_pattern_simple()
 #[test]
 fn test_oc_parse_node_pattern_parameters()
 {
-  let node = parse("(n {id: 12, name: 'foo'})", node_pattern);
+  let node = parse("(n {id: 12, name: 'foo'})", node_pattern::<AllowUndirected>);
 
   let expected_node = ast::NodePattern {
     variable: ast::VariableIdentifier {
@@ -461,11 +463,16 @@ fn test_oc_parse_node_pattern_parameters()
         ),
       ],
     })),
+
+    predicate: None,
   };
 
   compare_ast(node, expected_node);
 
-  let node = parse(r#"(n {id: "12", name: "foo"})"#, node_pattern);
+  let node = parse(
+    r#"(n {id: "12", name: "foo"})"#,
+    node_pattern::<AllowUndirected>,
+  );
 
   let expected_node = ast::NodePattern {
     variable: ast::VariableIdentifier {
@@ -488,6 +495,8 @@ fn test_oc_parse_node_pattern_parameters()
         ),
       ],
     })),
+
+    predicate: None,
   };
 
   compare_ast(node, expected_node);
@@ -509,6 +518,7 @@ fn test_oc_parse_edge_patterns()
           .into(),
           labels: ast::LabelExpression::None,
           properties: None,
+          predicate: None,
         },
         variable: ast::VariableIdentifier {
           name: "m".to_string(),
@@ -523,11 +533,13 @@ fn test_oc_parse_edge_patterns()
           .into(),
           labels: ast::LabelExpression::None,
           properties: None,
+          predicate: None,
         },
         directivity: graphcore::EdgeDirectivity::Directed,
         labels: ast::LabelExpression::None,
         properties: None,
-        recursive_range: None,
+
+        predicate: None,
       }
       .into(),
     ],
@@ -562,7 +574,8 @@ fn test_oc_parse_edge_recursive_patterns()
     "(n)-[m*1..2]->(p)",
     patterns::<AllowUndirected>,
     vec![
-      ast::EdgePattern {
+      ast::QuantifiedPathPattern {
+        variable: None,
         source: ast::NodePattern {
           variable: ast::VariableIdentifier {
             name: "n".to_string(),
@@ -571,12 +584,45 @@ fn test_oc_parse_edge_recursive_patterns()
           .into(),
           labels: ast::LabelExpression::None,
           properties: None,
+          predicate: None,
         },
-        variable: ast::VariableIdentifier {
-          name: "m".to_string(),
-          id: 2,
-        }
-        .into(),
+        group: vec![
+          ast::EdgePattern {
+            source: ast::NodePattern {
+              variable: ast::VariableIdentifier {
+                name: "n".to_string(),
+                id: 0,
+              }
+              .into(),
+              labels: ast::LabelExpression::None,
+              properties: None,
+              predicate: None,
+            },
+            variable: ast::VariableIdentifier {
+              name: "m".to_string(),
+              id: 2,
+            }
+            .into(),
+            destination: ast::NodePattern {
+              variable: ast::VariableIdentifier {
+                name: "p".to_string(),
+                id: 1,
+              }
+              .into(),
+              labels: ast::LabelExpression::None,
+              properties: None,
+              predicate: None,
+            },
+            directivity: graphcore::EdgeDirectivity::Directed,
+            labels: ast::LabelExpression::None,
+            properties: None,
+            predicate: None,
+          }
+          .into(),
+        ],
+        group_where: None,
+        path_where: None,
+        quantifier: Some(1..2),
         destination: ast::NodePattern {
           variable: ast::VariableIdentifier {
             name: "p".to_string(),
@@ -585,11 +631,9 @@ fn test_oc_parse_edge_recursive_patterns()
           .into(),
           labels: ast::LabelExpression::None,
           properties: None,
+          predicate: None,
         },
-        directivity: graphcore::EdgeDirectivity::Directed,
-        labels: ast::LabelExpression::None,
-        properties: None,
-        recursive_range: Some(1..2),
+        selector: ast::PathSelector::All,
       }
       .into(),
     ],
@@ -763,7 +807,7 @@ fn test_oc_parse_string_literal()
 #[test]
 fn test_oc_parse_node_pattern_with_parameter_properties()
 {
-  let node = parse("(n $props)", node_pattern);
+  let node = parse("(n $props)", node_pattern::<AllowUndirected>);
 
   let expr = node.properties.expect("properties expected");
 
@@ -789,6 +833,8 @@ fn test_oc_parse_match_statement_without_where()
         .into(),
         labels: ast::LabelExpression::None,
         properties: None,
+
+        predicate: None,
       }
       .into(),
     ],
@@ -815,6 +861,8 @@ fn test_oc_parse_optional_match_statement_without_where()
         .into(),
         labels: ast::LabelExpression::None,
         properties: None,
+
+        predicate: None,
       }
       .into(),
     ],
@@ -838,6 +886,7 @@ fn test_oc_parse_match_statement_double_edge()
           variable: None,
           labels: ast::LabelExpression::None,
           properties: None,
+          predicate: None,
         },
         destination: ast::NodePattern {
           variable: Some(ast::VariableIdentifier {
@@ -846,12 +895,14 @@ fn test_oc_parse_match_statement_double_edge()
           }),
           labels: ast::LabelExpression::None,
           properties: None,
+          predicate: None,
         },
         variable: None,
         directivity: graphcore::EdgeDirectivity::Directed,
         labels: ast::LabelExpression::None,
         properties: None,
-        recursive_range: None,
+
+        predicate: None,
       }
       .into(),
       ast::EdgePattern {
@@ -862,17 +913,20 @@ fn test_oc_parse_match_statement_double_edge()
           }),
           labels: ast::LabelExpression::None,
           properties: None,
+          predicate: None,
         },
         destination: ast::NodePattern {
           variable: None,
           labels: ast::LabelExpression::None,
           properties: None,
+          predicate: None,
         },
         variable: None,
         directivity: graphcore::EdgeDirectivity::Directed,
         labels: ast::LabelExpression::None,
         properties: None,
-        recursive_range: None,
+
+        predicate: None,
       }
       .into(),
     ],
@@ -905,6 +959,8 @@ fn test_oc_parse_merge_basic_pattern()
             }),
           )],
         })),
+
+        predicate: None,
       }
       .into(),
     ],
@@ -929,6 +985,8 @@ fn test_oc_parse_merge_with_on_create_set()
         }),
         labels: ast::LabelExpression::String("Person".to_string()),
         properties: None,
+
+        predicate: None,
       }
       .into(),
     ],
@@ -960,6 +1018,8 @@ fn test_oc_parse_merge_with_on_match_set()
         }),
         labels: ast::LabelExpression::String("Person".to_string()),
         properties: None,
+
+        predicate: None,
       }
       .into(),
     ],
@@ -994,6 +1054,8 @@ fn test_oc_parse_merge_with_both_on_clauses()
         }),
         labels: ast::LabelExpression::String("Person".to_string()),
         properties: None,
+
+        predicate: None,
       }
       .into(),
     ],
@@ -1035,6 +1097,8 @@ fn test_oc_parse_merge_with_both_on_clauses_reversed()
         }),
         labels: ast::LabelExpression::String("Person".to_string()),
         properties: None,
+
+        predicate: None,
       }
       .into(),
     ],
@@ -1074,6 +1138,7 @@ fn test_oc_parse_merge_with_edge_pattern()
           }),
           labels: ast::LabelExpression::None,
           properties: None,
+          predicate: None,
         },
         destination: ast::NodePattern {
           variable: Some(ast::VariableIdentifier {
@@ -1082,12 +1147,14 @@ fn test_oc_parse_merge_with_edge_pattern()
           }),
           labels: ast::LabelExpression::None,
           properties: None,
+          predicate: None,
         },
         variable: None,
         labels: ast::LabelExpression::String("KNOWS".to_string()),
         properties: None,
         directivity: graphcore::EdgeDirectivity::Directed,
-        recursive_range: None,
+
+        predicate: None,
       }
       .into(),
     ],
@@ -1114,6 +1181,8 @@ fn test_oc_parse_merge_statement()
           .into(),
           labels: ast::LabelExpression::None,
           properties: None,
+
+          predicate: None,
         }
         .into(),
       ],
@@ -1128,6 +1197,8 @@ fn test_oc_parse_merge_statement()
           variable: None,
           labels: ast::LabelExpression::None,
           properties: None,
+
+          predicate: None,
         }
         .into(),
       ],
@@ -1142,6 +1213,8 @@ fn test_oc_parse_merge_statement()
           variable: None,
           labels: ast::LabelExpression::String("A".to_string()),
           properties: None,
+
+          predicate: None,
         }
         .into(),
       ],
@@ -1159,6 +1232,8 @@ fn test_oc_parse_merge_statement()
             ast::LabelExpression::String("B".to_string()),
           ]),
           properties: None,
+
+          predicate: None,
         }
         .into(),
       ],
@@ -1179,17 +1254,20 @@ fn test_oc_parse_create_edge_statements()
             variable: None,
             labels: ast::LabelExpression::None,
             properties: None,
+            predicate: None,
           },
           destination: ast::NodePattern {
             variable: None,
             labels: ast::LabelExpression::None,
             properties: None,
+            predicate: None,
           },
           variable: None,
           directivity: graphcore::EdgeDirectivity::Directed,
           labels: ast::LabelExpression::String("R".to_string()),
           properties: None,
-          recursive_range: None,
+
+          predicate: None,
         }
         .into(),
       ],
@@ -1208,6 +1286,7 @@ fn test_oc_parse_create_edge_statements()
             }),
             labels: ast::LabelExpression::None,
             properties: None,
+            predicate: None,
           },
           destination: ast::NodePattern {
             variable: Some(ast::VariableIdentifier {
@@ -1216,12 +1295,14 @@ fn test_oc_parse_create_edge_statements()
             }),
             labels: ast::LabelExpression::None,
             properties: None,
+            predicate: None,
           },
           variable: None,
           directivity: graphcore::EdgeDirectivity::Directed,
           labels: ast::LabelExpression::String("FOO".to_string()),
           properties: None,
-          recursive_range: None,
+
+          predicate: None,
         }
         .into(),
       ],
@@ -1726,6 +1807,8 @@ fn test_oc_parse_queries_multiple_statements()
           .into(),
           labels: ast::LabelExpression::None,
           properties: None,
+
+          predicate: None,
         }
         .into(),
       ],
@@ -1765,6 +1848,8 @@ fn test_oc_parse_queries_multiple_queries()
             .into(),
             labels: ast::LabelExpression::None,
             properties: None,
+
+            predicate: None,
           }
           .into(),
         ],
@@ -1807,6 +1892,8 @@ fn test_oc_parse_query_union_basic()
                 .into(),
                 labels: ast::LabelExpression::None,
                 properties: None,
+
+                predicate: None,
               }
               .into(),
             ],
@@ -1827,6 +1914,8 @@ fn test_oc_parse_query_union_basic()
                 .into(),
                 labels: ast::LabelExpression::None,
                 properties: None,
+
+                predicate: None,
               }
               .into(),
             ],
@@ -1861,6 +1950,8 @@ fn test_oc_parse_query_union_all_basic()
                 .into(),
                 labels: ast::LabelExpression::None,
                 properties: None,
+
+                predicate: None,
               }
               .into(),
             ],
@@ -1881,6 +1972,8 @@ fn test_oc_parse_query_union_all_basic()
                 .into(),
                 labels: ast::LabelExpression::None,
                 properties: None,
+
+                predicate: None,
               }
               .into(),
             ],
@@ -1915,6 +2008,8 @@ fn test_oc_parse_query_chained_union_basic()
                 .into(),
                 labels: ast::LabelExpression::None,
                 properties: None,
+
+                predicate: None,
               }
               .into(),
             ],
@@ -1935,6 +2030,8 @@ fn test_oc_parse_query_chained_union_basic()
                 .into(),
                 labels: ast::LabelExpression::None,
                 properties: None,
+
+                predicate: None,
               }
               .into(),
             ],
@@ -1955,6 +2052,8 @@ fn test_oc_parse_query_chained_union_basic()
                 .into(),
                 labels: ast::LabelExpression::None,
                 properties: None,
+
+                predicate: None,
               }
               .into(),
             ],
@@ -1987,6 +2086,8 @@ fn test_oc_parse_query_plain()
             .into(),
             labels: ast::LabelExpression::None,
             properties: None,
+
+            predicate: None,
           }
           .into(),
         ],
@@ -2151,6 +2252,19 @@ fn test_oc_call_internal_stats()
   );
 }
 
+#[test]
+fn test_oc_call_db_list_graphs()
+{
+  compare_parse_to_ast(
+    "CALL gqlite.db.list_graphs()",
+    call_statement,
+    ast::Call {
+      name: "gqlite.db.list_graphs".to_string(),
+      arguments: vec![],
+    },
+  );
+}
+
 #[test]
 fn test_oc_parse_match_with_search_basic()
 {
@@ -2643,3 +2757,234 @@ fn test_oc_parse_function_call_distinct_with_multiple_args()
     },
   );
 }
+
+// Tests for work item #569: node_pattern predicate parsing
+
+#[test]
+fn test_oc_parse_node_pattern_with_predicate_and_label()
+{
+  // Test parsing (n:Station WHERE n.name = 'X')
+  let actual = parse(
+    "(n:Station WHERE n.name = 'X')",
+    node_pattern::<AllowUndirected>,
+  );
+
+  // Verify predicate is present
+  assert!(actual.predicate.is_some(), "expected predicate to be Some");
+
+  // Verify label is correct
+  assert!(matches!(actual.labels, ast::LabelExpression::String(ref s) if s == "Station"));
+}
+
+#[test]
+fn test_oc_parse_node_pattern_with_predicate_no_label()
+{
+  // Test parsing (n WHERE n.name = 'X')
+  let actual = parse("(n WHERE n.name = 'X')", node_pattern::<AllowUndirected>);
+
+  // Verify predicate is present
+  assert!(actual.predicate.is_some(), "expected predicate to be Some");
+
+  // Verify label is None
+  assert!(matches!(actual.labels, ast::LabelExpression::None));
+}
+
+#[test]
+fn test_oc_parse_node_pattern_with_predicate_and_properties()
+{
+  // Test parsing (n:Station {zone: 2} WHERE n.name STARTS WITH 'D')
+  let actual = parse(
+    "(n:Station {zone: 2} WHERE n.name STARTS WITH 'D')",
+    node_pattern::<AllowUndirected>,
+  );
+
+  // Verify both properties and predicate are present
+  assert!(
+    actual.properties.is_some(),
+    "expected properties to be Some"
+  );
+  assert!(actual.predicate.is_some(), "expected predicate to be Some");
+
+  // Verify label is correct
+  assert!(matches!(actual.labels, ast::LabelExpression::String(ref s) if s == "Station"));
+}
+
+#[test]
+fn test_oc_parse_node_pattern_without_predicate_regression()
+{
+  // Regression test: ensure predicate remains None when not specified
+  let actual = parse("(n)", node_pattern::<AllowUndirected>);
+
+  // Verify predicate is None
+  assert!(actual.predicate.is_none(), "expected predicate to be None");
+}
+
+#[test]
+fn test_oc_parse_create_with_predicate_rejected()
+{
+  // Test: CREATE patterns with WHERE predicates should be rejected
+  // This is parsed with DisallowUndirected context (used for CREATE)
+  parse_fail(
+    "(n:Station WHERE n.name = 'X')",
+    node_pattern::<DisallowUndirected>,
+    |error_kind| *error_kind == ErrorKind::CreatingWithPredicate,
+  );
+}
+
+#[test]
+fn test_oc_parse_group_pattern_simple()
+{
+  // Test parsing ((n)-[r:KNOWS]->(m)){1,5}(b)
+  let actual = parse(
+    "((n)-[r:KNOWS]->(m)){1,5}(b)",
+    group_pattern::<AllowUndirected>,
+  );
+
+  // Verify group contains exactly one pattern (the edge)
+  assert_eq!(
+    actual.group.len(),
+    1,
+    "Expected one pattern in group, got {}",
+    actual.group.len()
+  );
+
+  // Verify the group contains an Edge pattern
+  assert!(
+    matches!(&actual.group[0], ast::Pattern::Edge(_)),
+    "Expected Edge pattern in group"
+  );
+
+  // Verify quantifier is 1..5
+  assert_eq!(
+    actual.quantifier,
+    1..5,
+    "Expected quantifier 1..5, got {:?}",
+    actual.quantifier
+  );
+
+  // Verify destination_node is bound to variable 'b'
+  assert!(
+    actual.destination_node.variable.is_some(),
+    "Expected destination_node to have a variable"
+  );
+  if let Some(var) = &actual.destination_node.variable
+  {
+    assert_eq!(
+      var.name(),
+      "b",
+      "Expected destination_node variable to be 'b', got '{}'",
+      var.name()
+    );
+  }
+}
+
+#[test]
+fn test_oc_parse_selector_scoped_pattern_basic()
+{
+  // Test parsing selector-scoped pattern: ((n)-[r]->(m) WHERE n.x > 1)
+  let actual = parse(
+    "((n)-[r]->(m) WHERE n.x > 1)",
+    selector_scoped_pattern::<AllowUndirected>,
+  );
+
+  // Verify it returns a single QuantifiedPathPattern
+  assert_eq!(
+    actual.len(),
+    1,
+    "Expected one pattern, got {}",
+    actual.len()
+  );
+
+  if let ast::Pattern::QuantifiedPath(qp) = &actual[0]
+  {
+    // Verify quantifier is None (key difference from group pattern)
+    assert_eq!(
+      qp.quantifier, None,
+      "Expected quantifier to be None for selector-scoped pattern, got {:?}",
+      qp.quantifier
+    );
+
+    // Verify group_where is set
+    assert!(qp.group_where.is_some(), "Expected group_where to be set");
+
+    // Verify variable is None (not set in selector_scoped_pattern itself)
+    assert_eq!(
+      qp.variable, None,
+      "Expected variable to be None before patterns() closure applies it"
+    );
+
+    // Verify group contains the pattern(s)
+    assert!(!qp.group.is_empty(), "Expected group to contain patterns");
+  }
+  else
+  {
+    panic!("Expected QuantifiedPathPattern, got {:?}", actual[0]);
+  }
+}
+
+#[test]
+fn test_oc_parse_selector_scoped_pattern_with_variable()
+{
+  // Test parsing selector-scoped pattern with variable: (p = (n)-[r]->(m))
+  // This tests just the selector_scoped_pattern directly
+  let actual = parse(
+    "(p = (n)-[r]->(m))",
+    selector_scoped_pattern::<AllowUndirected>,
+  );
+
+  // Verify it returns a single QuantifiedPathPattern
+  assert_eq!(
+    actual.len(),
+    1,
+    "Expected one pattern, got {}",
+    actual.len()
+  );
+
+  if let ast::Pattern::QuantifiedPath(qp) = &actual[0]
+  {
+    // Verify variable is set from the p = binding inside the scoped pattern
+    assert!(qp.variable.is_some(), "Expected variable to be set");
+    if let Some(var) = &qp.variable
+    {
+      assert_eq!(
+        var.name(),
+        "p",
+        "Expected variable 'p', got '{}'",
+        var.name()
+      );
+    }
+
+    // Verify quantifier is None (key difference from regular group patterns)
+    assert_eq!(
+      qp.quantifier, None,
+      "Expected quantifier to be None for selector-scoped pattern"
+    );
+  }
+  else
+  {
+    panic!("Expected QuantifiedPathPattern, got {:?}", actual[0]);
+  }
+}
+
+#[test]
+fn test_oc_parse_selector_scoped_pattern_no_where()
+{
+  // Test parsing selector-scoped pattern without WHERE: ((n)-[r]->(m))
+  let actual = parse("((n)-[r]->(m))", selector_scoped_pattern::<AllowUndirected>);
+
+  if let ast::Pattern::QuantifiedPath(qp) = &actual[0]
+  {
+    // Verify quantifier is None
+    assert_eq!(qp.quantifier, None, "Expected quantifier to be None");
+
+    // Verify group_where is None when no WHERE clause
+    assert_eq!(
+      qp.group_where, None,
+      "Expected group_where to be None when no WHERE clause"
+    );
+  }
+  else
+  {
+    panic!("Expected QuantifiedPathPattern, got {:?}", actual[0]);
+  }
+}