uni-query 1.1.0

OpenCypher query parser, planner, and vectorized executor for Uni
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

// SPDX-License-Identifier: Apache-2.0
// Copyright 2024-2026 Dragonscale Team

use uni_cypher::ast::{BinaryOp, Clause, CypherLiteral, Expr, Query, ReturnItem};

fn parse_return_expr(input: &str) -> Expr {
    let query = uni_cypher::parse(input).unwrap();

    let Query::Single(stmt) = query else {
        panic!("Expected single query");
    };

    let return_clause = stmt
        .clauses
        .iter()
        .find_map(|c| {
            if let Clause::Return(r) = c {
                Some(r)
            } else {
                None
            }
        })
        .expect("Expected return clause");

    match &return_clause.items[0] {
        ReturnItem::Expr { expr, .. } => expr.clone(),
        ReturnItem::All => panic!("Expected expression, got RETURN *"),
    }
}

#[test]
fn test_parse_reduce() {
    let expr = parse_return_expr("RETURN reduce(total = 0, x IN [1, 2, 3] | total + x)");

    let Expr::Reduce {
        accumulator,
        init,
        variable,
        list,
        expr,
    } = expr
    else {
        panic!("Expected Expr::Reduce");
    };

    assert_eq!(accumulator, "total");
    assert_eq!(*init, Expr::Literal(CypherLiteral::Integer(0)));
    assert_eq!(variable, "x");

    let Expr::List(items) = *list else {
        panic!("Expected list literal");
    };
    assert_eq!(items.len(), 3);

    let Expr::BinaryOp { left, op, .. } = *expr else {
        panic!("Expected BinaryOp expression");
    };
    assert_eq!(*left, Expr::Variable("total".to_string()));
    assert_eq!(op, BinaryOp::Add);
}