selene-db-gql 1.3.0

ISO/IEC 39075:2024 GQL parser, planner, optimizer, and executor for selene-db.
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

//! BRIEF-118 analyzer recursion bound coverage.

use selene_gql::{
    AnalysisError, BinaryOp, EmptyProcedureRegistry, Literal, PipelineStatement, QueryPipeline,
    ReturnClause, ReturnItem, SourceSpan, Statement, ValueExpr, analyze,
};

fn addition_statement(terms: usize) -> Statement {
    let span = SourceSpan::new(0, 1);
    let mut expr = ValueExpr::Literal(Literal::Integer(1, span));
    for _ in 1..terms {
        expr = ValueExpr::BinaryOp {
            op: BinaryOp::Add,
            lhs: Box::new(expr),
            rhs: Box::new(ValueExpr::Literal(Literal::Integer(1, span))),
            span,
        };
    }
    Statement::Query(QueryPipeline {
        statements: vec![PipelineStatement::Return(ReturnClause {
            distinct: false,
            star: false,
            items: vec![ReturnItem {
                expr,
                alias: None,
                span,
            }],
            group_by: None,
            having: None,
            span,
        })],
        span,
    })
}

#[test]
fn analyzer_rejects_deep_expression_without_stack_overflow() {
    let statement = addition_statement(1000);
    let error = match analyze(statement, &EmptyProcedureRegistry, None) {
        Ok(_) => panic!("deep expression should exceed analyzer depth"),
        Err(error) => error,
    };

    assert!(matches!(
        error,
        AnalysisError::RecursionLimitExceeded { depth: 257 }
    ));
    assert_eq!(error.gqlstatus().as_str(), "5GQL1");
}

#[test]
fn analyzer_accepts_reasonable_expression_depth() {
    let statement = addition_statement(100);

    analyze(statement, &EmptyProcedureRegistry, None).expect("100-term expression analyzes");
}