graphrecords-query 0.5.0

High-performance graph-based data records
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

mod add;
mod divide;
mod modulo;
mod multiply;
mod power;
mod subtract;

use crate::{
    IndexDomain, QueryResult, ValueDomain,
    element::{BarePipeline, IndexedValuePipeline, Pipeline, Retention},
    operations::{ArgumentSource, Keyed, Unaligned},
    registry::OperationManifest,
};
pub use add::AddOperation;
pub use divide::DivideOperation;
pub use modulo::ModuloOperation;
pub use multiply::MultiplyOperation;
pub use power::PowerOperation;
pub use subtract::SubtractOperation;

pub(super) fn operation_manifests() -> Vec<OperationManifest> {
    vec![
        add::operation_manifest(),
        divide::operation_manifest(),
        modulo::operation_manifest(),
        multiply::operation_manifest(),
        power::operation_manifest(),
        subtract::operation_manifest(),
    ]
}

type ArithmeticFunction<'a, V> = fn(
    &'static str,
    <V as ValueDomain>::Value<'a>,
    <V as ValueDomain>::Value<'a>,
) -> QueryResult<<V as ValueDomain>::Value<'a>>;

fn arithmetic_indexed<'a, I, V, A>(
    prepared: A::Prepared<'a>,
    label: &'static str,
    operation: ArithmeticFunction<'a, V>,
) -> IndexedValuePipeline<'a, I, V, V, A::Retention>
where
    I: IndexDomain,
    V: ValueDomain,
    A: ArgumentSource<Keyed<I>, V>,
    A::Prepared<'a>: 'a,
{
    Pipeline::keyed(move |index, item| {
        let value = match item {
            Ok(value) => value,
            Err(original) => {
                return A::Retention::keep(Err(original));
            }
        };

        let step = A::resolve(&prepared, &index, label);

        A::Retention::map_step(step, |resolved| {
            resolved.and_then(|argument| {
                operation(label, value, argument).map_err(|failure| failure.at::<I>(&index))
            })
        })
    })
}

fn arithmetic_bare<'a, V, A>(
    prepared: A::Prepared<'a>,
    label: &'static str,
    operation: ArithmeticFunction<'a, V>,
) -> BarePipeline<'a, V, V, A::Retention>
where
    V: ValueDomain,
    A: ArgumentSource<Unaligned, V>,
    A::Prepared<'a>: 'a,
{
    Pipeline::new(move |item| {
        let value = match item {
            Ok(value) => value,
            Err(original) => {
                return A::Retention::keep(Err(original));
            }
        };

        let step = A::resolve(&prepared, &(), label);

        A::Retention::map_step(step, |resolved| {
            resolved.and_then(|argument| operation(label, value, argument))
        })
    })
}