uqa-execution 0.4.5

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

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

//! SQL comparisons for keys whose operators cannot be represented by an infallible B-tree comparator.

use uqa_core::{memory::ProductionControl, Predicate, Value};
use uqa_sql::{expr::value_comparison_can_fail, SQLError};

pub(super) fn needs_sql_comparison(predicate: &Predicate, stored_can_fail: bool) -> bool {
    match predicate {
        Predicate::IsNull | Predicate::IsNotNull => false,
        Predicate::Equals(value)
        | Predicate::NotEquals(value)
        | Predicate::GreaterThan(value)
        | Predicate::GreaterThanOrEqual(value)
        | Predicate::LessThan(value)
        | Predicate::LessThanOrEqual(value) => stored_can_fail || value_comparison_can_fail(value),
        Predicate::Between { low, high } => {
            stored_can_fail || value_comparison_can_fail(low) || value_comparison_can_fail(high)
        }
        Predicate::InSet(values) => {
            !values.is_empty() && (stored_can_fail || values.iter().any(value_comparison_can_fail))
        }
    }
}

pub(super) fn matches(value: &Value, predicate: &Predicate) -> Result<bool, SQLError> {
    let compare = |other: &Value| {
        uqa_sql::expr::compare_typed_values_with_control(
            value,
            other,
            &ProductionControl::uncontrolled(),
        )
    };
    if matches!(value, Value::Null) {
        return Ok(matches!(predicate, Predicate::IsNull));
    }
    Ok(match predicate {
        Predicate::Equals(other) => !matches!(other, Value::Null) && compare(other)?.is_eq(),
        Predicate::NotEquals(other) => !matches!(other, Value::Null) && !compare(other)?.is_eq(),
        Predicate::GreaterThan(other) => !matches!(other, Value::Null) && compare(other)?.is_gt(),
        Predicate::GreaterThanOrEqual(other) => {
            !matches!(other, Value::Null) && !compare(other)?.is_lt()
        }
        Predicate::LessThan(other) => !matches!(other, Value::Null) && compare(other)?.is_lt(),
        Predicate::LessThanOrEqual(other) => {
            !matches!(other, Value::Null) && !compare(other)?.is_gt()
        }
        Predicate::Between { low, high } => {
            !matches!(low, Value::Null)
                && !compare(low)?.is_lt()
                && !matches!(high, Value::Null)
                && !compare(high)?.is_gt()
        }
        Predicate::InSet(values) => {
            for other in values {
                if !matches!(other, Value::Null) && compare(other)?.is_eq() {
                    return Ok(true);
                }
            }
            false
        }
        Predicate::IsNull => false,
        Predicate::IsNotNull => true,
    })
}