uqa-execution 0.5.0

Volcano physical operators with row-batch pipelines
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

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

use super::*;
use uqa_core::{ScoredEntry, Value};

#[test]
fn retrieval_support_spills_without_using_scores_as_truth_values() {
    let control = StorageReadControl::with_limit(64 * 1024);
    let entries = (0..16384)
        .map(|ordinal| ordinal * 3)
        .rev()
        .chain([0, 49149])
        .map(|doc_id| ScoredEntry {
            doc_id,
            score: if doc_id % 2 == 0 { 0.0 } else { -1.0 },
        })
        .collect();
    let rows = retain_support(entries, &control).unwrap();
    assert!(matches!(rows, DocumentSupport::Spilled { .. }));
    for id in [0, 3, 6144, 12285, 49149] {
        assert!(contains(&rows, id, &control).unwrap());
    }
    for id in [1, 2, 49152, u64::MAX] {
        assert!(!contains(&rows, id, &control).unwrap());
    }
    drop(rows);
    assert_eq!(control.memory().used(), 0);
}

#[test]
fn retrieval_leaves_share_one_allowance_and_release_their_resident_and_spilled_storage() {
    let control = StorageReadControl::with_limit(64 * 1024);
    let rows = (0..3)
        .map(|_| {
            retain_support(
                (0..4096)
                    .map(|doc_id| ScoredEntry { doc_id, score: 0.0 })
                    .collect(),
                &control,
            )
            .unwrap()
        })
        .collect::<Vec<_>>();
    assert!(matches!(rows[0], DocumentSupport::Resident(_)));
    assert!(matches!(rows[1], DocumentSupport::Spilled { .. }));
    for support in &rows {
        assert!(contains(support, 2048, &control).unwrap());
        assert!(!contains(support, 4096, &control).unwrap());
    }
    assert!(control.memory().used() <= 64 * 1024);
    drop(rows);
    assert_eq!(control.memory().used(), 0);
}

#[test]
fn cancelled_support_retention_releases_its_workspace() {
    let control = StorageReadControl::with_limit(64 * 1024);
    control.cancellation().cancel();
    let error = match retain_support(
        vec![ScoredEntry {
            doc_id: 1,
            score: 0.0,
        }],
        &control,
    ) {
        Ok(_) => panic!("cancelled retention succeeded"),
        Err(error) => error,
    };
    assert_eq!(error.sqlstate(), Some("57014"));
    assert_eq!(control.memory().used(), 0);
}

#[test]
fn retrieval_qualification_keeps_lazy_boolean_evaluation_and_field_arguments() {
    let calls = std::cell::Cell::new(0);
    let expression = ScalarExpr::Func {
        order_syntax: uqa_sql::ast::FunctionOrderSyntax::Ordinary,
        name: "text_match".into(),
        binding: None,
        args: vec![
            ScalarExpr::Column("body".into()),
            ScalarExpr::Literal(Value::Str("alpha".into())),
        ],
        distinct: false,
        order_by: Vec::new(),
        filter: None,
    };
    let retrieval = |name: &str, args: &[ScalarExpr]| {
        assert_eq!(name, "text_match");
        assert_eq!(args[0], ScalarExpr::Column("body".into()));
        calls.set(calls.get() + 1);
        Ok(true)
    };
    let context = crate::ScalarEvalContext::new(None, &[]).with_retrieval_predicate(&retrieval);
    for (predicate, expected) in [
        (
            ScalarExpr::And(vec![
                ScalarExpr::Literal(Value::Bool(false)),
                expression.clone(),
            ]),
            false,
        ),
        (
            ScalarExpr::Or(vec![
                ScalarExpr::Literal(Value::Bool(true)),
                expression.clone(),
            ]),
            true,
        ),
    ] {
        assert_eq!(
            crate::eval_scalar(&predicate, &context).unwrap(),
            Value::Bool(expected)
        );
        assert_eq!(calls.get(), 0);
    }
    assert_eq!(
        crate::eval_scalar(&expression, &context).unwrap(),
        Value::Bool(true)
    );
    assert_eq!(calls.get(), 1);
}