uqa-sql 0.5.4

PostgreSQL-compatible SQL compiler built on libpg_query
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
61

//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

//! Empty range containment follows the same point-set inclusion as multiranges.

use super::*;
use uqa_core::{memory::MemoryBudget, CancellationToken};

#[test]
fn ordinary_and_controlled_empty_containment_match_postgresql() {
    let reference: serde_json::Value = serde_json::from_str(include_str!("empty.json")).unwrap();
    let cases = reference["cases"].as_array().unwrap();
    assert_eq!(cases.len(), 66);
    let memory = MemoryBudget::new(4096);
    let token = CancellationToken::new();
    let control = ProductionControl::new(&memory, &token, &token);
    for case in cases.iter().filter(|case| case.get("op").is_some()) {
        let operation = if case["op"] == "@>" {
            RangeFunctionOperation::Contains
        } else {
            RangeFunctionOperation::ContainedBy
        };
        let subtype = if case["kind"] == "date" {
            RangeSubtype::Date
        } else {
            RangeSubtype::Integer
        };
        let left = case["left"].as_str().unwrap();
        let args = [
            Value::Str(left.into()),
            Value::Str(case["right"].as_str().unwrap().into()),
        ];
        let multirange = left.starts_with('{');
        let expected = Value::Bool(case["results"][0]["rows"][0][0] == "t");
        assert_eq!(
            eval_dispatched_range_function(operation, subtype, multirange, &args).unwrap(),
            expected,
            "{case}"
        );
        let value = eval_dispatched_range_function_with_control(
            operation, subtype, multirange, &args, &control,
        )
        .unwrap();
        assert_eq!(*value, expected, "{case}");
        drop(value);
        assert_eq!(memory.used(), 0);
    }
    token.cancel();
    assert!(eval_dispatched_range_function_with_control(
        RangeFunctionOperation::Contains,
        RangeSubtype::Integer,
        true,
        &[Value::Str("{}".into()), Value::Str("empty".into())],
        &control
    )
    .is_err());
    assert_eq!(memory.used(), 0);
}