gqlite 1.8.0 → 1.8.2

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

@@ -101,6 +101,17 @@ where
   assert_eq!(unwrap_nom(input.clone(), parser.parse(input)), exp);
 }
 
+fn parse_string<P>(s: &str, mut parser: P, exp: impl Into<String>)
+where
+  for<'a> P: nom::Parser<Input<'a>, Output = String, Error = Error>,
+{
+  let exp = exp.into();
+  let ctx = Context::new(s);
+  let tokens = lexer::tokenize(s).expect("tokenization failed");
+  let input = Input(&tokens, &ctx);
+  assert_eq!(unwrap_nom(input.clone(), parser.parse(input)), exp);
+}
+
 #[test]
 fn test_oc_parse_context_variable_identity()
 {
@@ -131,19 +142,19 @@ fn test_oc_parse_parameter_name()
 #[test]
 fn test_oc_parse_string_literal_double_quote()
 {
-  parse_str(r#""hello world""#, string_literal, "hello world");
+  parse_string(r#""hello world""#, string_literal, "hello world");
 }
 
 #[test]
 fn test_oc_parse_string_literal_single_quote()
 {
-  parse_str("'hello world'", string_literal, "hello world");
-  parse_str("', as#?lßdj '", string_literal, ", as#?lßdj ");
+  parse_string("'hello world'", string_literal, "hello world");
+  parse_string("', as#?lßdj '", string_literal, ", as#?lßdj ");
 }
 #[test]
 fn test_oc_parse_string_literal_backtick()
 {
-  parse_str("`hello`", string_literal, "hello");
+  parse_string("`hello`", string_literal, "hello");
 }
 
 #[test]
@@ -307,6 +318,7 @@ fn test_oc_parse_function_call()
         ast::Expression::Value(ast::Value { value: 1.into() }),
         ast::Expression::Value(ast::Value { value: 2.into() }),
       ],
+      distinct: false,
     },
   );
 }
@@ -320,6 +332,7 @@ fn test_oc_parse_function_call_all()
     ast::FunctionCall {
       name: "func".to_string(),
       arguments: vec![ast::Expression::Value(ast::Value { value: 0.into() })],
+      distinct: false,
     },
   );
 }
@@ -384,6 +397,7 @@ fn test_oc_parse_relational_binary_operator()
           }
           .into(),
         ],
+        distinct: false,
       }
       .into(),
       right: ast::FunctionCall {
@@ -397,6 +411,7 @@ fn test_oc_parse_relational_binary_operator()
           }
           .into(),
         ],
+        distinct: false,
       }
       .into(),
     },
@@ -406,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 {
@@ -416,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);
 }
@@ -423,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 {
@@ -446,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 {
@@ -473,6 +495,8 @@ fn test_oc_parse_node_pattern_parameters()
         ),
       ],
     })),
+
+    predicate: None,
   };
 
   compare_ast(node, expected_node);
@@ -494,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(),
@@ -508,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(),
     ],
@@ -547,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(),
@@ -556,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(),
@@ -570,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(),
     ],
@@ -748,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");
 
@@ -774,6 +833,8 @@ fn test_oc_parse_match_statement_without_where()
         .into(),
         labels: ast::LabelExpression::None,
         properties: None,
+
+        predicate: None,
       }
       .into(),
     ],
@@ -800,6 +861,8 @@ fn test_oc_parse_optional_match_statement_without_where()
         .into(),
         labels: ast::LabelExpression::None,
         properties: None,
+
+        predicate: None,
       }
       .into(),
     ],
@@ -823,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 {
@@ -831,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 {
@@ -847,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(),
     ],
@@ -890,6 +959,8 @@ fn test_oc_parse_merge_basic_pattern()
             }),
           )],
         })),
+
+        predicate: None,
       }
       .into(),
     ],
@@ -914,6 +985,8 @@ fn test_oc_parse_merge_with_on_create_set()
         }),
         labels: ast::LabelExpression::String("Person".to_string()),
         properties: None,
+
+        predicate: None,
       }
       .into(),
     ],
@@ -945,6 +1018,8 @@ fn test_oc_parse_merge_with_on_match_set()
         }),
         labels: ast::LabelExpression::String("Person".to_string()),
         properties: None,
+
+        predicate: None,
       }
       .into(),
     ],
@@ -979,6 +1054,8 @@ fn test_oc_parse_merge_with_both_on_clauses()
         }),
         labels: ast::LabelExpression::String("Person".to_string()),
         properties: None,
+
+        predicate: None,
       }
       .into(),
     ],
@@ -1020,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(),
     ],
@@ -1059,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 {
@@ -1067,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(),
     ],
@@ -1099,6 +1181,8 @@ fn test_oc_parse_merge_statement()
           .into(),
           labels: ast::LabelExpression::None,
           properties: None,
+
+          predicate: None,
         }
         .into(),
       ],
@@ -1113,6 +1197,8 @@ fn test_oc_parse_merge_statement()
           variable: None,
           labels: ast::LabelExpression::None,
           properties: None,
+
+          predicate: None,
         }
         .into(),
       ],
@@ -1127,6 +1213,8 @@ fn test_oc_parse_merge_statement()
           variable: None,
           labels: ast::LabelExpression::String("A".to_string()),
           properties: None,
+
+          predicate: None,
         }
         .into(),
       ],
@@ -1144,6 +1232,8 @@ fn test_oc_parse_merge_statement()
             ast::LabelExpression::String("B".to_string()),
           ]),
           properties: None,
+
+          predicate: None,
         }
         .into(),
       ],
@@ -1164,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(),
       ],
@@ -1193,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 {
@@ -1201,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(),
       ],
@@ -1261,6 +1357,35 @@ fn test_oc_parse_return_n()
   compare_ast(vec![stmt], vec![exppected_stmt]);
 }
 
+#[test]
+fn test_oc_parse_return_distinct_n()
+{
+  let stmt = parse("RETURN DISTINCT n", return_statement);
+
+  let exppected_stmt = ast::Statement::Return(ast::Return {
+    all: false,
+    expressions: vec![ast::NamedExpression {
+      identifier: ast::VariableIdentifier {
+        name: "n".to_string(),
+        id: 0,
+      },
+      expression: ast::Variable {
+        identifier: ast::VariableIdentifier {
+          name: "n".to_string(),
+          id: 0,
+        },
+      }
+      .into(),
+    }],
+    where_expression: None,
+    modifiers: ast::Modifiers {
+      distinct: true,
+      ..Default::default()
+    },
+  });
+  compare_ast(vec![stmt], vec![exppected_stmt]);
+}
+
 #[test]
 fn test_oc_parse_return_n_m()
 {
@@ -1411,9 +1536,8 @@ fn test_oc_parse_return_n_modifiers()
       }],
       where_expression: None,
       modifiers: ast::Modifiers {
-        order_by: None,
         limit: Some(ast::Expression::Value(ast::Value { value: (-1).into() })),
-        skip: None,
+        ..Default::default()
       },
     }),
   );
@@ -1529,6 +1653,7 @@ fn test_oc_parse_modifiers()
       }),
       limit: Some(ast::Expression::Value(ast::Value { value: 4.into() })),
       skip: Some(ast::Expression::Value(ast::Value { value: 2.into() })),
+      ..Default::default()
     },
   );
   compare_parse_to_ast(
@@ -1569,15 +1694,15 @@ fn test_oc_parse_modifiers()
       }),
       limit: Some(ast::Expression::Value(ast::Value { value: 4.into() })),
       skip: None,
+      ..Default::default()
     },
   );
   compare_parse_to_ast(
     "LIMIT -1",
     modifiers,
     ast::Modifiers {
-      order_by: None,
       limit: Some(ast::Expression::Value(ast::Value { value: (-1).into() })),
-      skip: None,
+      ..Default::default()
     },
   );
 }
@@ -1638,7 +1763,7 @@ fn test_oc_parse_with_modifiers()
           ],
         }),
         limit: Some(ast::Expression::Value(ast::Value { value: 4.into() })),
-        skip: None,
+        ..Default::default()
       },
     },
   );
@@ -1682,6 +1807,8 @@ fn test_oc_parse_queries_multiple_statements()
           .into(),
           labels: ast::LabelExpression::None,
           properties: None,
+
+          predicate: None,
         }
         .into(),
       ],
@@ -1721,6 +1848,8 @@ fn test_oc_parse_queries_multiple_queries()
             .into(),
             labels: ast::LabelExpression::None,
             properties: None,
+
+            predicate: None,
           }
           .into(),
         ],
@@ -1763,6 +1892,8 @@ fn test_oc_parse_query_union_basic()
                 .into(),
                 labels: ast::LabelExpression::None,
                 properties: None,
+
+                predicate: None,
               }
               .into(),
             ],
@@ -1783,6 +1914,8 @@ fn test_oc_parse_query_union_basic()
                 .into(),
                 labels: ast::LabelExpression::None,
                 properties: None,
+
+                predicate: None,
               }
               .into(),
             ],
@@ -1817,6 +1950,8 @@ fn test_oc_parse_query_union_all_basic()
                 .into(),
                 labels: ast::LabelExpression::None,
                 properties: None,
+
+                predicate: None,
               }
               .into(),
             ],
@@ -1837,6 +1972,8 @@ fn test_oc_parse_query_union_all_basic()
                 .into(),
                 labels: ast::LabelExpression::None,
                 properties: None,
+
+                predicate: None,
               }
               .into(),
             ],
@@ -1871,6 +2008,8 @@ fn test_oc_parse_query_chained_union_basic()
                 .into(),
                 labels: ast::LabelExpression::None,
                 properties: None,
+
+                predicate: None,
               }
               .into(),
             ],
@@ -1891,6 +2030,8 @@ fn test_oc_parse_query_chained_union_basic()
                 .into(),
                 labels: ast::LabelExpression::None,
                 properties: None,
+
+                predicate: None,
               }
               .into(),
             ],
@@ -1911,6 +2052,8 @@ fn test_oc_parse_query_chained_union_basic()
                 .into(),
                 labels: ast::LabelExpression::None,
                 properties: None,
+
+                predicate: None,
               }
               .into(),
             ],
@@ -1943,6 +2086,8 @@ fn test_oc_parse_query_plain()
             .into(),
             labels: ast::LabelExpression::None,
             properties: None,
+
+            predicate: None,
           }
           .into(),
         ],
@@ -2107,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()
 {
@@ -2127,6 +2285,72 @@ fn test_oc_parse_match_with_search_basic()
   }
 }
 
+#[test]
+fn test_oc_parse_starts_with()
+{
+  compare_parse_to_ast(
+    "s STARTS WITH 'hello'",
+    expression,
+    ast::StartsWith {
+      left: ast::Variable {
+        identifier: ast::VariableIdentifier {
+          name: "s".to_string(),
+          id: 0,
+        },
+      }
+      .into(),
+      right: ast::Value {
+        value: "hello".into(),
+      }
+      .into(),
+    },
+  );
+}
+
+#[test]
+fn test_oc_parse_ends_with()
+{
+  compare_parse_to_ast(
+    "s ENDS WITH 'world'",
+    expression,
+    ast::EndsWith {
+      left: ast::Variable {
+        identifier: ast::VariableIdentifier {
+          name: "s".to_string(),
+          id: 0,
+        },
+      }
+      .into(),
+      right: ast::Value {
+        value: "world".into(),
+      }
+      .into(),
+    },
+  );
+}
+
+#[test]
+fn test_oc_parse_contains()
+{
+  compare_parse_to_ast(
+    "s CONTAINS 'test'",
+    expression,
+    ast::Contains {
+      left: ast::Variable {
+        identifier: ast::VariableIdentifier {
+          name: "s".to_string(),
+          id: 0,
+        },
+      }
+      .into(),
+      right: ast::Value {
+        value: "test".into(),
+      }
+      .into(),
+    },
+  );
+}
+
 #[test]
 fn test_oc_parse_match_with_search_and_score()
 {
@@ -2282,3 +2506,485 @@ fn test_oc_parse_create_vector_index_if_not_exists()
     },
   );
 }
+
+#[test]
+fn test_oc_parse_not_wraps_full_comparison()
+{
+  compare_parse_to_ast(
+    r#"NOT n.name = "Alice""#,
+    expression,
+    ast::LogicalNegation {
+      value: ast::RelationalEqual {
+        left: ast::MemberAccess {
+          left: ast::Variable {
+            identifier: ast::VariableIdentifier {
+              name: "n".to_string(),
+              id: 0,
+            },
+          }
+          .into(),
+          path: vec!["name".to_string()],
+        }
+        .into(),
+        right: ast::Value {
+          value: "Alice".into(),
+        }
+        .into(),
+      }
+      .into(),
+    },
+  );
+}
+
+#[test]
+fn test_oc_parse_not_and_precedence()
+{
+  compare_parse_to_ast(
+    "NOT a = 1 AND c = 2",
+    expression,
+    ast::LogicalAnd {
+      left: ast::LogicalNegation {
+        value: ast::RelationalEqual {
+          left: ast::Variable {
+            identifier: ast::VariableIdentifier {
+              name: "a".to_string(),
+              id: 0,
+            },
+          }
+          .into(),
+          right: ast::Value { value: 1i64.into() }.into(),
+        }
+        .into(),
+      }
+      .into(),
+      right: ast::RelationalEqual {
+        left: ast::Variable {
+          identifier: ast::VariableIdentifier {
+            name: "c".to_string(),
+            id: 1,
+          },
+        }
+        .into(),
+        right: ast::Value { value: 2i64.into() }.into(),
+      }
+      .into(),
+    },
+  );
+}
+
+#[test]
+fn test_oc_parse_double_not()
+{
+  compare_parse_to_ast(
+    "NOT NOT a = 1",
+    expression,
+    ast::LogicalNegation {
+      value: ast::LogicalNegation {
+        value: ast::RelationalEqual {
+          left: ast::Variable {
+            identifier: ast::VariableIdentifier {
+              name: "a".to_string(),
+              id: 0,
+            },
+          }
+          .into(),
+          right: ast::Value { value: 1i64.into() }.into(),
+        }
+        .into(),
+      }
+      .into(),
+    },
+  );
+}
+
+#[test]
+fn test_oc_parse_not_true_still_works()
+{
+  compare_parse_to_ast(
+    "NOT true",
+    expression,
+    ast::LogicalNegation {
+      value: ast::Value { value: true.into() }.into(),
+    },
+  );
+}
+
+#[test]
+fn test_oc_parse_is_not_null_unaffected()
+{
+  compare_parse_to_ast(
+    "n.age IS NOT NULL",
+    expression,
+    ast::IsNotNull {
+      value: ast::MemberAccess {
+        left: ast::Variable {
+          identifier: ast::VariableIdentifier {
+            name: "n".to_string(),
+            id: 0,
+          },
+        }
+        .into(),
+        path: vec!["age".to_string()],
+      }
+      .into(),
+    },
+  );
+}
+
+#[test]
+fn test_oc_parse_not_in_still_works()
+{
+  compare_parse_to_ast(
+    "x NOT IN [1, 2]",
+    expression,
+    ast::LogicalNegation {
+      value: ast::RelationalIn {
+        left: ast::Variable {
+          identifier: ast::VariableIdentifier {
+            name: "x".to_string(),
+            id: 0,
+          },
+        }
+        .into(),
+        right: ast::Array {
+          array: vec![
+            ast::Value { value: 1i64.into() }.into(),
+            ast::Value { value: 2i64.into() }.into(),
+          ],
+        }
+        .into(),
+      }
+      .into(),
+    },
+  );
+}
+
+#[test]
+fn test_oc_parse_count_distinct()
+{
+  compare_parse_to_ast(
+    "count(DISTINCT x)",
+    expression,
+    ast::FunctionCall {
+      name: "count".to_string(),
+      arguments: vec![
+        ast::Variable {
+          identifier: ast::VariableIdentifier {
+            name: "x".to_string(),
+            id: 0,
+          },
+        }
+        .into(),
+      ],
+      distinct: true,
+    },
+  );
+}
+
+#[test]
+fn test_oc_parse_count_without_distinct_defaults_false()
+{
+  compare_parse_to_ast(
+    "count(x)",
+    expression,
+    ast::FunctionCall {
+      name: "count".to_string(),
+      arguments: vec![
+        ast::Variable {
+          identifier: ast::VariableIdentifier {
+            name: "x".to_string(),
+            id: 0,
+          },
+        }
+        .into(),
+      ],
+      distinct: false,
+    },
+  );
+}
+
+#[test]
+fn test_oc_parse_sum_distinct()
+{
+  compare_parse_to_ast(
+    "sum(DISTINCT n.age)",
+    expression,
+    ast::FunctionCall {
+      name: "sum".to_string(),
+      arguments: vec![
+        ast::MemberAccess {
+          left: ast::Variable {
+            identifier: ast::VariableIdentifier {
+              name: "n".to_string(),
+              id: 0,
+            },
+          }
+          .into(),
+          path: vec!["age".to_string()],
+        }
+        .into(),
+      ],
+      distinct: true,
+    },
+  );
+}
+
+#[test]
+fn test_oc_parse_function_call_distinct_with_multiple_args()
+{
+  compare_parse_to_ast(
+    "some_func(DISTINCT a, b)",
+    expression,
+    ast::FunctionCall {
+      name: "some_func".to_string(),
+      arguments: vec![
+        ast::Variable {
+          identifier: ast::VariableIdentifier {
+            name: "a".to_string(),
+            id: 0,
+          },
+        }
+        .into(),
+        ast::Variable {
+          identifier: ast::VariableIdentifier {
+            name: "b".to_string(),
+            id: 1,
+          },
+        }
+        .into(),
+      ],
+      distinct: true,
+    },
+  );
+}
+
+// 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]);
+  }
+}