lora-executor 0.22.3

Query-plan executor for LoraDB's Cypher implementation.
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

//! `bits.*` — integer bit operations without a stringly operation argument.

use crate::value::LoraValue;

use super::super::binops::arithmetic_overflow;
use super::super::errors::set_eval_error;

pub(super) fn dispatch(op: &str, args: &[LoraValue]) -> Option<LoraValue> {
    Some(match op {
        "and" => binary(args, |a, b| a & b),
        "or" => binary(args, |a, b| a | b),
        "xor" => binary(args, |a, b| a ^ b),
        "shift_left" => shift(args, "bits.shift_left", shift_left),
        "shift_right" => shift(args, "bits.shift_right", shift_right),
        "not" => unary(args, |a| !a),
        _ => return None,
    })
}

fn unary(args: &[LoraValue], f: impl FnOnce(i64) -> i64) -> LoraValue {
    args.first()
        .and_then(LoraValue::as_i64)
        .map(f)
        .map(LoraValue::Int)
        .unwrap_or(LoraValue::Null)
}

fn binary(args: &[LoraValue], f: impl FnOnce(i64, i64) -> i64) -> LoraValue {
    match (
        args.first().and_then(LoraValue::as_i64),
        args.get(1).and_then(LoraValue::as_i64),
    ) {
        (Some(a), Some(b)) => LoraValue::Int(f(a, b)),
        _ => LoraValue::Null,
    }
}

fn shift(args: &[LoraValue], name: &str, f: fn(i64, i64, &str) -> LoraValue) -> LoraValue {
    match (
        args.first().and_then(LoraValue::as_i64),
        args.get(1).and_then(LoraValue::as_i64),
    ) {
        (Some(a), Some(b)) => f(a, b, name),
        _ => LoraValue::Null,
    }
}

/// `a` shifted left by `b` bits, i.e. `a * 2^b`. A shift outside 0..=63 is
/// an error, and so is a result that doesn't fit an integer, as for the
/// arithmetic operators.
pub(super) fn shift_left(a: i64, b: i64, name: &str) -> LoraValue {
    if !shift_in_range(b, name) {
        return LoraValue::Null;
    }
    let out = a << b;
    if out >> b != a {
        return arithmetic_overflow(name);
    }
    LoraValue::Int(out)
}

/// `a` shifted right by `b` bits, keeping the sign (`-8 >> 1` is `-4`).
/// A shift outside 0..=63 is an error.
pub(super) fn shift_right(a: i64, b: i64, name: &str) -> LoraValue {
    if !shift_in_range(b, name) {
        return LoraValue::Null;
    }
    LoraValue::Int(a >> b)
}

fn shift_in_range(b: i64, name: &str) -> bool {
    if (0..=63).contains(&b) {
        return true;
    }
    set_eval_error(format!("{name} shift must be between 0 and 63, got {b}"));
    false
}