glaredb_core 25.6.3

Core functionality for GlareDB
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
111
112
113
114

use std::fmt;

use glaredb_error::Result;

use super::ExpressionState;
use crate::arrays::array::Array;
use crate::arrays::array::selection::Selection;
use crate::arrays::batch::Batch;
use crate::arrays::cache::NopCache;
use crate::arrays::datatype::DataType;
use crate::buffer::buffer_manager::DefaultBufferManager;

#[derive(Debug, Clone)]
pub struct PhysicalColumnExpr {
    pub idx: usize,
    pub datatype: DataType,
}

impl From<(usize, DataType)> for PhysicalColumnExpr {
    fn from((idx, datatype): (usize, DataType)) -> Self {
        Self::new(idx, datatype)
    }
}

impl PhysicalColumnExpr {
    pub(crate) fn new(idx: usize, datatype: DataType) -> Self {
        PhysicalColumnExpr { idx, datatype }
    }

    pub(crate) fn create_state(&self, _batch_size: usize) -> Result<ExpressionState> {
        Ok(ExpressionState::empty())
    }

    pub fn datatype(&self) -> DataType {
        self.datatype.clone()
    }

    pub(crate) fn eval(
        &self,
        input: &mut Batch,
        _: &mut ExpressionState,
        sel: Selection,
        output: &mut Array,
    ) -> Result<()> {
        let col = &mut input.arrays_mut()[self.idx];
        // Caching will never be useful here, since evaling this expression is
        // always going to try to clone the input array.
        output.clone_from_other(col, &mut NopCache)?;

        if !sel.is_linear() || sel.len() != input.num_rows() {
            output.select(&DefaultBufferManager, sel.iter())?;
        }

        Ok(())
    }
}

impl fmt::Display for PhysicalColumnExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "@{}", self.idx)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::arrays::datatype::DataType;
    use crate::testutil::arrays::assert_arrays_eq;
    use crate::util::iter::TryFromExactSizeIterator;

    #[test]
    fn column_expr_eval() {
        let mut input = Batch::from_arrays([
            Array::try_from_iter(["a", "b", "c", "d"]).unwrap(),
            Array::try_from_iter([1, 2, 3, 4]).unwrap(),
        ])
        .unwrap();

        let expr = PhysicalColumnExpr {
            idx: 1,
            datatype: DataType::int32(),
        };
        let mut out = Array::new(&DefaultBufferManager, DataType::int32(), 4).unwrap();
        let sel = Selection::linear(0, 4);

        expr.eval(&mut input, &mut ExpressionState::empty(), sel, &mut out)
            .unwrap();

        let expected = Array::try_from_iter([1, 2, 3, 4]).unwrap();
        assert_arrays_eq(&expected, &out);
    }

    #[test]
    fn column_expr_eval_with_selection() {
        let mut input = Batch::from_arrays([
            Array::try_from_iter(["a", "b", "c", "d"]).unwrap(),
            Array::try_from_iter([1, 2, 3, 4]).unwrap(),
        ])
        .unwrap();

        let expr = PhysicalColumnExpr {
            idx: 1,
            datatype: DataType::int32(),
        };
        let mut state = expr.create_state(4).unwrap();
        let mut out = Array::new(&DefaultBufferManager, DataType::int32(), 4).unwrap();
        let sel = Selection::slice(&[1, 3]);

        expr.eval(&mut input, &mut state, sel, &mut out).unwrap();

        let expected = Array::try_from_iter([2, 4]).unwrap();
        assert_arrays_eq(&expected, &out);
    }
}