risinglight 0.2.0

An OLAP database system for educational purpose
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
107
108
109
110

// Copyright 2022 RisingLight Project Authors. Licensed under Apache-2.0.

// use crate::array::ArrayImplValidExt;
use super::*;
use crate::array::Array;

/// State for first/last aggregation
pub struct FirstLastAggregationState {
    result: Option<DataValue>,
    is_first: bool, // or last
}

impl FirstLastAggregationState {
    pub fn new(is_first: bool) -> Self {
        Self {
            result: None,
            is_first,
        }
    }
}

macro_rules! update_func {
    ($( { $Abc:ident, $Value:ident} ),*) => {
        impl FirstLastAggregationState {

            pub fn update_impl(&mut self, array: &ArrayImpl) {
                match array {
                    $(
                        ArrayImpl::$Abc(arr) => {
                            match &self.result {
                                Some(_) => {
                                    if !self.is_first {
                                        // try get last value
                                        let arr_value = arr.iter().last();
                                        if let Some(value) = arr_value {
                                            match value {
                                                Some(_) => self.result = Some(array.get(array.len() - 1)),
                                                None => self.result = Some(DataValue::Null),
                                            }
                                        };
                                    }
                                }
                                None => {
                                    if self.is_first {
                                        let arr_value = arr.iter().next();
                                        if let Some(value) = arr_value {
                                            match value {
                                                Some(_) => self.result = Some(array.get(0)),
                                                None => self.result = Some(DataValue::Null),
                                            }
                                        }
                                    } else {
                                        let arr_value = arr.iter().last();
                                        if let Some(value) = arr_value {
                                            match value {
                                                Some(_) => self.result = Some(array.get(array.len() - 1)),
                                                None => self.result = Some(DataValue::Null),
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    )*
                }
            }
        }
    }
}

update_func!(
    {Null, Null},
    {Bool, Bool},
    {Int32, Int32},
    {Int64, Int64},
    {Float64, Float64},
    {Utf8, String},
    {Blob, Blob},
    {Decimal, Decimal},
    {Date, Date},
    {Interval, Interval}
);

impl AggregationState for FirstLastAggregationState {
    fn update(&mut self, array: &ArrayImpl) -> Result<(), ExecutorError> {
        self.update_impl(array);
        Ok(())
    }

    fn update_single(&mut self, value: &DataValue) -> Result<(), ExecutorError> {
        match &self.result {
            Some(_) => {
                if !self.is_first {
                    self.result = Some(value.clone());
                }
            }
            None => {
                self.result = Some(value.clone());
            }
        }
        Ok(())
    }

    fn output(&self) -> DataValue {
        match &self.result {
            Some(value) => value.clone(),
            None => DataValue::Null,
        }
    }
}