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
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

//! Temporal instant plus duration operator evaluation for ISO/IEC 39075:2024 ยง20.26.

use jiff::Span;
use selene_core::Value;

use crate::{
    BinaryOp, SourceSpan,
    runtime::{DataExceptionSubclass, ExecutorError},
};

pub(super) fn eval_duration_plus_temporal(
    duration: Span,
    instant: Value,
    span: SourceSpan,
) -> Result<Value, ExecutorError> {
    eval_temporal_duration(BinaryOp::Add, instant, duration, span)
}

pub(super) fn eval_temporal_duration(
    op: BinaryOp,
    instant: Value,
    duration: Span,
    span: SourceSpan,
) -> Result<Value, ExecutorError> {
    match op {
        BinaryOp::Add => add_duration(instant, &duration, span),
        BinaryOp::Sub => subtract_duration(instant, &duration, span),
        _ => Err(ExecutorError::data_exception(
            DataExceptionSubclass::InvalidValueType,
            "temporal instant operands only support addition and subtraction by duration",
            span,
        )),
    }
}

fn add_duration(instant: Value, duration: &Span, span: SourceSpan) -> Result<Value, ExecutorError> {
    match instant {
        Value::ZonedDateTime(value) => value
            .checked_add(duration)
            .map(|value| Value::ZonedDateTime(Box::new(value)))
            .map_err(|error| range_error(error, span)),
        Value::LocalDateTime(value) => value
            .checked_add(duration)
            .map(Value::LocalDateTime)
            .map_err(|error| range_error(error, span)),
        Value::Date(value) => value
            .checked_add(duration)
            .map(Value::Date)
            .map_err(|error| range_error(error, span)),
        Value::ZonedTime(value) => value
            .checked_add(duration)
            .map(|value| Value::ZonedTime(Box::new(value)))
            .map_err(|error| range_error(error, span)),
        Value::LocalTime(value) => value
            .checked_add(duration)
            .map(Value::LocalTime)
            .map_err(|error| range_error(error, span)),
        _ => Err(invalid_temporal(span)),
    }
}

fn subtract_duration(
    instant: Value,
    duration: &Span,
    span: SourceSpan,
) -> Result<Value, ExecutorError> {
    match instant {
        Value::ZonedDateTime(value) => value
            .checked_sub(duration)
            .map(|value| Value::ZonedDateTime(Box::new(value)))
            .map_err(|error| range_error(error, span)),
        Value::LocalDateTime(value) => value
            .checked_sub(duration)
            .map(Value::LocalDateTime)
            .map_err(|error| range_error(error, span)),
        Value::Date(value) => value
            .checked_sub(duration)
            .map(Value::Date)
            .map_err(|error| range_error(error, span)),
        Value::ZonedTime(value) => value
            .checked_sub(duration)
            .map(|value| Value::ZonedTime(Box::new(value)))
            .map_err(|error| range_error(error, span)),
        Value::LocalTime(value) => value
            .checked_sub(duration)
            .map(Value::LocalTime)
            .map_err(|error| range_error(error, span)),
        _ => Err(invalid_temporal(span)),
    }
}

fn invalid_temporal(span: SourceSpan) -> ExecutorError {
    ExecutorError::data_exception(
        DataExceptionSubclass::InvalidValueType,
        "duration arithmetic operand is not a temporal instant",
        span,
    )
}

fn range_error(error: jiff::Error, span: SourceSpan) -> ExecutorError {
    ExecutorError::data_exception(
        DataExceptionSubclass::NumericValueOutOfRange,
        format!("temporal instant arithmetic result is out of range: {error}"),
        span,
    )
}