mirror of
https://github.com/ModernRelay/omnigraph.git
synced 2026-06-15 01:55:13 +02:00
94849a50b4
typecheck.rs, schema/parser.rs, and query/parser.rs each had ~1000-line inline `mod tests` blocks that overshadowed the production code in the file. Move each to a sibling `*_tests.rs` using `#[path = "..."] mod tests;`. - typecheck.rs: 2865 → 1708 lines; typecheck_tests.rs: 1156 lines - schema/parser.rs: 1950 → 994 lines; parser_tests.rs: 955 lines - query/parser.rs: 1737 → 803 lines; parser_tests.rs: 933 lines No visibility change — the sibling module still has `use super::*` access to crate-privates. No semantic edits beyond de-indenting by 4 spaces (mechanical). All 229 compiler tests green, identical count to before. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
933 lines
23 KiB
Rust
933 lines
23 KiB
Rust
use super::*;
|
|
|
|
#[test]
|
|
fn test_parse_basic_query() {
|
|
let input = r#"
|
|
query get_person($name: String) {
|
|
match {
|
|
$p: Person { name: $name }
|
|
}
|
|
return { $p.name, $p.age }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
assert_eq!(qf.queries.len(), 1);
|
|
let q = &qf.queries[0];
|
|
assert_eq!(q.name, "get_person");
|
|
assert_eq!(q.params.len(), 1);
|
|
assert_eq!(q.params[0].name, "name");
|
|
assert_eq!(q.match_clause.len(), 1);
|
|
assert_eq!(q.return_clause.len(), 2);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_query_metadata_annotations() {
|
|
let input = r#"
|
|
query semantic_search($q: String)
|
|
@description("Find semantically similar documents.")
|
|
@instruction("Use for conceptual search; prefer keyword_search for exact terms.")
|
|
{
|
|
match {
|
|
$d: Doc
|
|
}
|
|
return { $d.slug }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
assert_eq!(
|
|
q.description.as_deref(),
|
|
Some("Find semantically similar documents.")
|
|
);
|
|
assert_eq!(
|
|
q.instruction.as_deref(),
|
|
Some("Use for conceptual search; prefer keyword_search for exact terms.")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_duplicate_query_description_is_rejected() {
|
|
let input = r#"
|
|
query q()
|
|
@description("one")
|
|
@description("two")
|
|
{
|
|
match {
|
|
$p: Person
|
|
}
|
|
return { $p.name }
|
|
}
|
|
"#;
|
|
let err = parse_query(input).unwrap_err();
|
|
assert!(err.to_string().contains("duplicate @description"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_no_params() {
|
|
let input = r#"
|
|
query adults() {
|
|
match {
|
|
$p: Person
|
|
$p.age > 30
|
|
}
|
|
return { $p.name, $p.age }
|
|
order { $p.age desc }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
assert_eq!(q.name, "adults");
|
|
assert!(q.params.is_empty());
|
|
assert_eq!(q.match_clause.len(), 2);
|
|
assert_eq!(q.order_clause.len(), 1);
|
|
assert!(q.order_clause[0].descending);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_traversal() {
|
|
let input = r#"
|
|
query friends_of($name: String) {
|
|
match {
|
|
$p: Person { name: $name }
|
|
$p knows $f
|
|
}
|
|
return { $f.name, $f.age }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
assert_eq!(q.match_clause.len(), 2);
|
|
match &q.match_clause[1] {
|
|
Clause::Traversal(t) => {
|
|
assert_eq!(t.src, "p");
|
|
assert_eq!(t.edge_name, "knows");
|
|
assert_eq!(t.dst, "f");
|
|
assert_eq!(t.min_hops, 1);
|
|
assert_eq!(t.max_hops, Some(1));
|
|
}
|
|
_ => panic!("expected Traversal"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_negation() {
|
|
let input = r#"
|
|
query unemployed() {
|
|
match {
|
|
$p: Person
|
|
not { $p worksAt $_ }
|
|
}
|
|
return { $p.name }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
assert_eq!(q.match_clause.len(), 2);
|
|
match &q.match_clause[1] {
|
|
Clause::Negation(clauses) => {
|
|
assert_eq!(clauses.len(), 1);
|
|
match &clauses[0] {
|
|
Clause::Traversal(t) => {
|
|
assert_eq!(t.src, "p");
|
|
assert_eq!(t.edge_name, "worksAt");
|
|
assert_eq!(t.dst, "_");
|
|
assert_eq!(t.min_hops, 1);
|
|
assert_eq!(t.max_hops, Some(1));
|
|
}
|
|
_ => panic!("expected Traversal inside negation"),
|
|
}
|
|
}
|
|
_ => panic!("expected Negation"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_aggregation() {
|
|
let input = r#"
|
|
query friend_counts() {
|
|
match {
|
|
$p: Person
|
|
$p knows $f
|
|
}
|
|
return {
|
|
$p.name
|
|
count($f) as friends
|
|
}
|
|
order { friends desc }
|
|
limit 20
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
assert_eq!(q.return_clause.len(), 2);
|
|
match &q.return_clause[1].expr {
|
|
Expr::Aggregate { func, .. } => {
|
|
assert_eq!(*func, AggFunc::Count);
|
|
}
|
|
_ => panic!("expected Aggregate"),
|
|
}
|
|
assert_eq!(q.return_clause[1].alias.as_deref(), Some("friends"));
|
|
assert_eq!(q.limit, Some(20));
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_two_hop() {
|
|
let input = r#"
|
|
query friends_of_friends($name: String) {
|
|
match {
|
|
$p: Person { name: $name }
|
|
$p knows $mid
|
|
$mid knows $fof
|
|
}
|
|
return { $fof.name }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
assert_eq!(q.match_clause.len(), 3);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_reverse_traversal() {
|
|
let input = r#"
|
|
query employees_of($company: String) {
|
|
match {
|
|
$c: Company { name: $company }
|
|
$p worksAt $c
|
|
}
|
|
return { $p.name }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
assert_eq!(q.match_clause.len(), 2);
|
|
match &q.match_clause[1] {
|
|
Clause::Traversal(t) => {
|
|
assert_eq!(t.src, "p");
|
|
assert_eq!(t.edge_name, "worksAt");
|
|
assert_eq!(t.dst, "c");
|
|
assert_eq!(t.min_hops, 1);
|
|
assert_eq!(t.max_hops, Some(1));
|
|
}
|
|
_ => panic!("expected Traversal"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_bounded_traversal() {
|
|
let input = r#"
|
|
query q() {
|
|
match {
|
|
$a: Person
|
|
$a knows{1,3} $b
|
|
}
|
|
return { $b.name }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
match &q.match_clause[1] {
|
|
Clause::Traversal(t) => {
|
|
assert_eq!(t.min_hops, 1);
|
|
assert_eq!(t.max_hops, Some(3));
|
|
}
|
|
_ => panic!("expected Traversal"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_unbounded_traversal() {
|
|
let input = r#"
|
|
query q() {
|
|
match {
|
|
$a: Person
|
|
$a knows{1,} $b
|
|
}
|
|
return { $b.name }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
match &q.match_clause[1] {
|
|
Clause::Traversal(t) => {
|
|
assert_eq!(t.min_hops, 1);
|
|
assert_eq!(t.max_hops, None);
|
|
}
|
|
_ => panic!("expected Traversal"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_multi_query_file() {
|
|
let input = r#"
|
|
query q1() {
|
|
match { $p: Person }
|
|
return { $p.name }
|
|
}
|
|
query q2() {
|
|
match { $c: Company }
|
|
return { $c.name }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
assert_eq!(qf.queries.len(), 2);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_complex_negation() {
|
|
let input = r#"
|
|
query knows_alice_not_bob() {
|
|
match {
|
|
$a: Person { name: "Alice" }
|
|
$b: Person { name: "Bob" }
|
|
$p: Person
|
|
$p knows $a
|
|
not { $p knows $b }
|
|
}
|
|
return { $p.name }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
assert_eq!(q.match_clause.len(), 5);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_filter_string() {
|
|
let input = r#"
|
|
query test() {
|
|
match {
|
|
$p: Person
|
|
$p.name != "Bob"
|
|
}
|
|
return { $p.name }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
match &q.match_clause[1] {
|
|
Clause::Filter(f) => {
|
|
assert_eq!(f.op, CompOp::Ne);
|
|
}
|
|
_ => panic!("expected Filter"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_filter_string_decodes_escapes() {
|
|
let input = r#"
|
|
query test() {
|
|
match {
|
|
$p: Person
|
|
$p.name = "Bob\n\"Builder\"\t\\"
|
|
}
|
|
return { $p.name }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
match &q.match_clause[1] {
|
|
Clause::Filter(f) => match &f.right {
|
|
Expr::Literal(Literal::String(value)) => {
|
|
assert_eq!(value, "Bob\n\"Builder\"\t\\");
|
|
}
|
|
other => panic!("expected string literal, got {:?}", other),
|
|
},
|
|
_ => panic!("expected Filter"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_string_literal_rejects_unknown_escape() {
|
|
let input = r#"
|
|
query test() {
|
|
match {
|
|
$p: Person
|
|
$p.name = "Bob\q"
|
|
}
|
|
return { $p.name }
|
|
}
|
|
"#;
|
|
let err = parse_query(input).unwrap_err();
|
|
assert!(err.to_string().contains("unsupported escape sequence"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_bool_literals() {
|
|
let input = r#"
|
|
query flags() {
|
|
match {
|
|
$p: Person
|
|
$p.active = true
|
|
$p.active != false
|
|
}
|
|
return { $p.name }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
match &q.match_clause[1] {
|
|
Clause::Filter(f) => match &f.right {
|
|
Expr::Literal(Literal::Bool(value)) => assert!(*value),
|
|
other => panic!("expected bool literal, got {:?}", other),
|
|
},
|
|
_ => panic!("expected Filter"),
|
|
}
|
|
match &q.match_clause[2] {
|
|
Clause::Filter(f) => match &f.right {
|
|
Expr::Literal(Literal::Bool(value)) => assert!(!*value),
|
|
other => panic!("expected bool literal, got {:?}", other),
|
|
},
|
|
_ => panic!("expected Filter"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_contains_filter() {
|
|
let input = r#"
|
|
query tagged($tag: String) {
|
|
match {
|
|
$p: Person
|
|
$p.tags contains $tag
|
|
}
|
|
return { $p.name }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
match &q.match_clause[1] {
|
|
Clause::Filter(f) => {
|
|
assert_eq!(f.op, CompOp::Contains);
|
|
assert!(matches!(
|
|
&f.left,
|
|
Expr::PropAccess { variable, property } if variable == "p" && property == "tags"
|
|
));
|
|
assert!(matches!(&f.right, Expr::Variable(v) if v == "tag"));
|
|
}
|
|
_ => panic!("expected Filter"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_contains_is_rejected_in_mutation_predicate() {
|
|
let input = r#"
|
|
query drop_person($tag: String) {
|
|
delete Person where tags contains $tag
|
|
}
|
|
"#;
|
|
assert!(parse_query(input).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_triangle() {
|
|
let input = r#"
|
|
query triangles($name: String) {
|
|
match {
|
|
$a: Person { name: $name }
|
|
$a knows $b
|
|
$b knows $c
|
|
$c knows $a
|
|
}
|
|
return { $b.name, $c.name }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
assert_eq!(q.match_clause.len(), 4);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_avg_aggregation() {
|
|
let input = r#"
|
|
query avg_age_by_company() {
|
|
match {
|
|
$p: Person
|
|
$p worksAt $c
|
|
}
|
|
return {
|
|
$c.name
|
|
avg($p.age) as avg_age
|
|
count($p) as headcount
|
|
}
|
|
order { headcount desc }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
assert_eq!(q.return_clause.len(), 3);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_insert_mutation() {
|
|
let input = r#"
|
|
query add_person($name: String, $age: I32) {
|
|
insert Person {
|
|
name: $name
|
|
age: $age
|
|
}
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
match q.mutations.first().expect("expected mutation") {
|
|
Mutation::Insert(ins) => {
|
|
assert_eq!(ins.type_name, "Person");
|
|
assert_eq!(ins.assignments.len(), 2);
|
|
}
|
|
_ => panic!("expected Insert mutation"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_update_mutation() {
|
|
let input = r#"
|
|
query set_age($name: String, $age: I32) {
|
|
update Person set {
|
|
age: $age
|
|
} where name = $name
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
match q.mutations.first().expect("expected mutation") {
|
|
Mutation::Update(upd) => {
|
|
assert_eq!(upd.type_name, "Person");
|
|
assert_eq!(upd.assignments.len(), 1);
|
|
assert_eq!(upd.predicate.property, "name");
|
|
assert_eq!(upd.predicate.op, CompOp::Eq);
|
|
}
|
|
_ => panic!("expected Update mutation"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_delete_mutation() {
|
|
let input = r#"
|
|
query drop_person($name: String) {
|
|
delete Person where name = $name
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
match q.mutations.first().expect("expected mutation") {
|
|
Mutation::Delete(del) => {
|
|
assert_eq!(del.type_name, "Person");
|
|
assert_eq!(del.predicate.property, "name");
|
|
assert_eq!(del.predicate.op, CompOp::Eq);
|
|
}
|
|
_ => panic!("expected Delete mutation"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_date_and_datetime_literals() {
|
|
let input = r#"
|
|
query dated() {
|
|
match {
|
|
$e: Event
|
|
$e.on = date("2026-02-14")
|
|
$e.at >= datetime("2026-02-14T10:00:00Z")
|
|
}
|
|
return { $e.id }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
match &q.match_clause[1] {
|
|
Clause::Filter(f) => match &f.right {
|
|
Expr::Literal(Literal::Date(v)) => assert_eq!(v, "2026-02-14"),
|
|
other => panic!("expected date literal, got {:?}", other),
|
|
},
|
|
_ => panic!("expected Filter"),
|
|
}
|
|
match &q.match_clause[2] {
|
|
Clause::Filter(f) => match &f.right {
|
|
Expr::Literal(Literal::DateTime(v)) => assert_eq!(v, "2026-02-14T10:00:00Z"),
|
|
other => panic!("expected datetime literal, got {:?}", other),
|
|
},
|
|
_ => panic!("expected Filter"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_now_expression_and_mutation_value() {
|
|
let input = r#"
|
|
query clock() {
|
|
match {
|
|
$e: Event
|
|
$e.at <= now()
|
|
}
|
|
return { now() as ts }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
match &q.match_clause[1] {
|
|
Clause::Filter(f) => assert!(matches!(f.right, Expr::Now)),
|
|
_ => panic!("expected Filter"),
|
|
}
|
|
assert!(matches!(q.return_clause[0].expr, Expr::Now));
|
|
|
|
let mutation = parse_query(
|
|
r#"
|
|
query stamp() {
|
|
update Event set { updated_at: now() } where created_at <= now()
|
|
}
|
|
"#,
|
|
)
|
|
.unwrap();
|
|
match mutation.queries[0].mutations.first().unwrap() {
|
|
Mutation::Update(update) => {
|
|
assert!(matches!(update.assignments[0].value, MatchValue::Now));
|
|
assert!(matches!(update.predicate.value, MatchValue::Now));
|
|
}
|
|
_ => panic!("expected update mutation"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_multi_mutation() {
|
|
let input = r#"
|
|
query add_and_link($name: String, $age: I32, $friend: String) {
|
|
insert Person { name: $name, age: $age }
|
|
insert Knows { from: $name, to: $friend }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
assert_eq!(q.mutations.len(), 2);
|
|
assert!(matches!(&q.mutations[0], Mutation::Insert(ins) if ins.type_name == "Person"));
|
|
assert!(matches!(&q.mutations[1], Mutation::Insert(ins) if ins.type_name == "Knows"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_multi_mutation_mixed_ops() {
|
|
let input = r#"
|
|
query create_and_clean($name: String, $age: I32, $old: String) {
|
|
insert Person { name: $name, age: $age }
|
|
delete Person where name = $old
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
assert_eq!(q.mutations.len(), 2);
|
|
assert!(matches!(&q.mutations[0], Mutation::Insert(_)));
|
|
assert!(matches!(&q.mutations[1], Mutation::Delete(_)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_single_mutation_backward_compat() {
|
|
let input = r#"
|
|
query add($name: String, $age: I32) {
|
|
insert Person { name: $name, age: $age }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
assert_eq!(qf.queries[0].mutations.len(), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_list_literal() {
|
|
let input = r#"
|
|
query listy() {
|
|
match { $p: Person { tags: ["rust", "db"] } }
|
|
return { $p.tags }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
match &q.match_clause[0] {
|
|
Clause::Binding(b) => match &b.prop_matches[0].value {
|
|
MatchValue::Literal(Literal::List(items)) => {
|
|
assert_eq!(items.len(), 2);
|
|
}
|
|
other => panic!("expected list literal, got {:?}", other),
|
|
},
|
|
_ => panic!("expected Binding"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_nearest_ordering_and_vector_param_type() {
|
|
let input = r#"
|
|
query similar($q: Vector(3)) {
|
|
match { $d: Doc }
|
|
return { $d.id }
|
|
order { nearest($d.embedding, $q) }
|
|
limit 5
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
assert_eq!(q.params[0].type_name, "Vector(3)");
|
|
assert_eq!(q.order_clause.len(), 1);
|
|
assert!(!q.order_clause[0].descending);
|
|
match &q.order_clause[0].expr {
|
|
Expr::Nearest {
|
|
variable,
|
|
property,
|
|
query,
|
|
} => {
|
|
assert_eq!(variable, "d");
|
|
assert_eq!(property, "embedding");
|
|
assert!(matches!(query.as_ref(), Expr::Variable(v) if v == "q"));
|
|
}
|
|
other => panic!("expected nearest ordering, got {:?}", other),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_nearest_with_spaced_vector_param_type() {
|
|
let input = r#"
|
|
query similar($q: Vector( 3 ) ?) {
|
|
match { $d: Doc }
|
|
return { $d.id }
|
|
order { nearest($d.embedding, $q) }
|
|
limit 5
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
assert_eq!(q.params[0].type_name, "Vector(3)");
|
|
assert!(q.params[0].nullable);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_list_and_datetime_param_types() {
|
|
let input = r#"
|
|
query tasks($tags: [String], $days: [Date]?, $due_at: DateTime) {
|
|
match { $t: Task }
|
|
return { $t.slug }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
assert_eq!(q.params[0].type_name, "[String]");
|
|
assert!(!q.params[0].nullable);
|
|
assert_eq!(q.params[1].type_name, "[Date]");
|
|
assert!(q.params[1].nullable);
|
|
assert_eq!(q.params[2].type_name, "DateTime");
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_nearest_rejects_direction_modifier() {
|
|
let input = r#"
|
|
query similar($q: Vector(3)) {
|
|
match { $d: Doc }
|
|
return { $d.id }
|
|
order { nearest($d.embedding, $q) desc }
|
|
limit 5
|
|
}
|
|
"#;
|
|
assert!(parse_query(input).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_nearest_expression_in_return_projection() {
|
|
let input = r#"
|
|
query similar($q: Vector(3)) {
|
|
match { $d: Doc }
|
|
return { $d.id, nearest($d.embedding, $q) as score }
|
|
order { nearest($d.embedding, $q) }
|
|
limit 5
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
assert_eq!(q.return_clause.len(), 2);
|
|
match &q.return_clause[1].expr {
|
|
Expr::Nearest {
|
|
variable,
|
|
property,
|
|
query,
|
|
} => {
|
|
assert_eq!(variable, "d");
|
|
assert_eq!(property, "embedding");
|
|
assert!(matches!(query.as_ref(), Expr::Variable(v) if v == "q"));
|
|
}
|
|
other => panic!(
|
|
"expected nearest expression in return projection, got {:?}",
|
|
other
|
|
),
|
|
}
|
|
assert_eq!(q.return_clause[1].alias.as_deref(), Some("score"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_search_clause_sugar() {
|
|
let input = r#"
|
|
query q($q: String) {
|
|
match {
|
|
$s: Signal
|
|
search($s.summary, $q)
|
|
}
|
|
return { $s.slug }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
assert_eq!(q.match_clause.len(), 2);
|
|
match &q.match_clause[1] {
|
|
Clause::Filter(Filter { left, op, right }) => {
|
|
assert_eq!(*op, CompOp::Eq);
|
|
assert!(matches!(right, Expr::Literal(Literal::Bool(true))));
|
|
match left {
|
|
Expr::Search { field, query } => {
|
|
assert!(matches!(
|
|
field.as_ref(),
|
|
Expr::PropAccess { variable, property } if variable == "s" && property == "summary"
|
|
));
|
|
assert!(matches!(query.as_ref(), Expr::Variable(v) if v == "q"));
|
|
}
|
|
other => panic!("expected search expression, got {:?}", other),
|
|
}
|
|
}
|
|
other => panic!("expected filter clause, got {:?}", other),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_fuzzy_clause_with_max_edits() {
|
|
let input = r#"
|
|
query q($q: String) {
|
|
match {
|
|
$s: Signal
|
|
fuzzy($s.summary, $q, 2)
|
|
}
|
|
return { $s.slug }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
assert_eq!(q.match_clause.len(), 2);
|
|
match &q.match_clause[1] {
|
|
Clause::Filter(Filter { left, op, right }) => {
|
|
assert_eq!(*op, CompOp::Eq);
|
|
assert!(matches!(right, Expr::Literal(Literal::Bool(true))));
|
|
match left {
|
|
Expr::Fuzzy {
|
|
field,
|
|
query,
|
|
max_edits,
|
|
} => {
|
|
assert!(matches!(
|
|
field.as_ref(),
|
|
Expr::PropAccess { variable, property } if variable == "s" && property == "summary"
|
|
));
|
|
assert!(matches!(query.as_ref(), Expr::Variable(v) if v == "q"));
|
|
assert!(matches!(
|
|
max_edits.as_deref(),
|
|
Some(Expr::Literal(Literal::Integer(2)))
|
|
));
|
|
}
|
|
other => panic!("expected fuzzy expression, got {:?}", other),
|
|
}
|
|
}
|
|
other => panic!("expected filter clause, got {:?}", other),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_match_text_clause_sugar() {
|
|
let input = r#"
|
|
query q($q: String) {
|
|
match {
|
|
$s: Signal
|
|
match_text($s.summary, $q)
|
|
}
|
|
return { $s.slug }
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
assert_eq!(q.match_clause.len(), 2);
|
|
match &q.match_clause[1] {
|
|
Clause::Filter(Filter { left, op, right }) => {
|
|
assert_eq!(*op, CompOp::Eq);
|
|
assert!(matches!(right, Expr::Literal(Literal::Bool(true))));
|
|
match left {
|
|
Expr::MatchText { field, query } => {
|
|
assert!(matches!(
|
|
field.as_ref(),
|
|
Expr::PropAccess { variable, property } if variable == "s" && property == "summary"
|
|
));
|
|
assert!(matches!(query.as_ref(), Expr::Variable(v) if v == "q"));
|
|
}
|
|
other => panic!("expected match_text expression, got {:?}", other),
|
|
}
|
|
}
|
|
other => panic!("expected filter clause, got {:?}", other),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_bm25_expression_in_order() {
|
|
let input = r#"
|
|
query q($q: String) {
|
|
match { $s: Signal }
|
|
return { $s.slug, bm25($s.summary, $q) as score }
|
|
order { bm25($s.summary, $q) desc }
|
|
limit 5
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
assert_eq!(q.return_clause.len(), 2);
|
|
match &q.return_clause[1].expr {
|
|
Expr::Bm25 { field, query } => {
|
|
assert!(matches!(
|
|
field.as_ref(),
|
|
Expr::PropAccess { variable, property } if variable == "s" && property == "summary"
|
|
));
|
|
assert!(matches!(query.as_ref(), Expr::Variable(v) if v == "q"));
|
|
}
|
|
other => panic!("expected bm25 expression, got {:?}", other),
|
|
}
|
|
assert_eq!(q.order_clause.len(), 1);
|
|
assert!(q.order_clause[0].descending);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_rrf_ordering_with_nearest_and_bm25() {
|
|
let input = r#"
|
|
query q($vq: Vector(3), $tq: String) {
|
|
match { $s: Signal }
|
|
return { $s.slug }
|
|
order { rrf(nearest($s.embedding, $vq), bm25($s.summary, $tq), 60) desc }
|
|
limit 5
|
|
}
|
|
"#;
|
|
let qf = parse_query(input).unwrap();
|
|
let q = &qf.queries[0];
|
|
assert_eq!(q.order_clause.len(), 1);
|
|
assert!(q.order_clause[0].descending);
|
|
match &q.order_clause[0].expr {
|
|
Expr::Rrf {
|
|
primary,
|
|
secondary,
|
|
k,
|
|
} => {
|
|
assert!(matches!(primary.as_ref(), Expr::Nearest { .. }));
|
|
assert!(matches!(secondary.as_ref(), Expr::Bm25 { .. }));
|
|
assert!(matches!(
|
|
k.as_deref(),
|
|
Some(Expr::Literal(Literal::Integer(60)))
|
|
));
|
|
}
|
|
other => panic!("expected rrf expression, got {:?}", other),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_error_diagnostic_has_span() {
|
|
let input = r#"
|
|
query q() {
|
|
match {
|
|
$p: Person
|
|
}
|
|
return { $p.name
|
|
}
|
|
"#;
|
|
let err = parse_query_diagnostic(input).unwrap_err();
|
|
assert!(err.span.is_some());
|
|
}
|