hamelin_eval 0.11.1

Expression evaluation for Hamelin query language
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
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

//! Eval implementations for unary operators

use hamelin_lib::func::defs::{
    UnaryMinus, UnaryPlus, UnaryRangePostfix, UnaryRangePrefix, UnaryRangePrefixInclusive,
};

use crate::registry::EvalRegistry;
use crate::value::{DecimalValue, RangeValue, Value};

/// Register all unary operator eval implementations.
pub fn register(registry: &mut EvalRegistry) {
    // UnaryMinus: -x negates numeric, interval, and rows values
    registry.register_eval::<UnaryMinus>(|mut bindings| {
        let x = bindings.take()?;
        match x {
            Value::Int(i) => i
                .checked_neg()
                .map(Value::Int)
                .ok_or_else(|| anyhow::anyhow!("integer overflow: cannot negate {}", i)),
            Value::Double(d) => Ok(Value::Double(-d)),
            Value::Rows(r) => r
                .checked_neg()
                .map(Value::Rows)
                .ok_or_else(|| anyhow::anyhow!("integer overflow: cannot negate {} rows", r)),
            Value::Decimal(d) => d
                .unscaled
                .checked_neg()
                .map(|unscaled| Value::Decimal(DecimalValue::new(unscaled, d.scale)))
                .ok_or_else(|| anyhow::anyhow!("decimal overflow: cannot negate {:?}", d)),
            Value::Interval(i) => i
                .checked_mul(-1)
                .map(Value::Interval)
                .ok_or_else(|| anyhow::anyhow!("interval overflow: cannot negate {:?}", i)),
            Value::CalendarInterval(months) => months
                .checked_neg()
                .map(Value::CalendarInterval)
                .ok_or_else(|| {
                    anyhow::anyhow!(
                        "calendar interval overflow: cannot negate {} months",
                        months
                    )
                }),
            Value::Null => Ok(Value::Null),
            _ => anyhow::bail!("UnaryMinus not supported for {:?}", x),
        }
    });

    // UnaryPlus: +x is identity for numeric, interval, and rows values
    registry.register_eval::<UnaryPlus>(|mut bindings| {
        let x = bindings.take()?;
        match x {
            Value::Int(_)
            | Value::Double(_)
            | Value::Rows(_)
            | Value::Decimal(_)
            | Value::Interval(_)
            | Value::CalendarInterval(_)
            | Value::Null => Ok(x),
            _ => anyhow::bail!("UnaryPlus not supported for {:?}", x),
        }
    });

    // UnaryRangePrefix: ..x creates a range with upper bound only
    registry.register_eval::<UnaryRangePrefix>(|mut bindings| {
        let x = bindings.take()?;
        Ok(Value::Range(Box::new(RangeValue {
            lower: None,
            upper: Some(x),
        })))
    });

    // UnaryRangePostfix: x.. creates a range with lower bound only
    registry.register_eval::<UnaryRangePostfix>(|mut bindings| {
        let x = bindings.take()?;
        Ok(Value::Range(Box::new(RangeValue {
            lower: Some(x),
            upper: None,
        })))
    });

    // UnaryRangePrefixInclusive: ..=x creates an inclusive range with upper bound only
    registry.register_eval::<UnaryRangePrefixInclusive>(|mut bindings| {
        let x = bindings.take()?;
        Ok(Value::Range(Box::new(RangeValue {
            lower: None,
            upper: Some(x),
        })))
    });

    // No reverse eval for unary operators
}