dbkit-engine 0.0.9

A columnar query execution engine
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

use ::block::Column;
use ::error::DBError;
use ::row::RowOffset;
use ::types;

/// Trait for setting column row values from rust native types.
/// Deals correctly with types that need to store data in the column's arena.
pub trait ValueSetter {
    fn set_row<'a>(&self, col: &mut Column<'a>, row: RowOffset) -> Result<(), DBError>;
}

impl ValueSetter for types::NullValue {
    fn set_row<'a>(&self, col: &mut Column<'a>, row: RowOffset) -> Result<(), DBError> {
        let rows = col.nulls_mut()?;
        rows[row] = true as u8;
        Ok(())
    }
}

impl ValueSetter for u32 {
    fn set_row<'a>(&self, col: &mut Column<'a>, row: RowOffset) -> Result<(), DBError> {
        let rows = col.rows_mut::<types::UInt32>()?;
        rows[row] = *self;
        Ok(())
    }
}

impl ValueSetter for u64 {
    fn set_row<'a>(&self, col: &mut Column<'a>, row: RowOffset) -> Result<(), DBError> {
        let rows = col.rows_mut::<types::UInt64>()?;
        rows[row] = *self;
        Ok(())
    }
}

impl ValueSetter for i32 {
    fn set_row<'a>(&self, col: &mut Column<'a>, row: RowOffset) -> Result<(), DBError> {
        let rows = col.rows_mut::<types::Int32>()?;
        rows[row] = *self;
        Ok(())
    }
}

impl ValueSetter for i64 {
    fn set_row<'a>(&self, col: &mut Column<'a>, row: RowOffset) -> Result<(), DBError> {
        let rows = col.rows_mut::<types::Int64>()?;
        rows[row] = *self;
        Ok(())
    }
}

impl ValueSetter for bool {
    fn set_row<'a>(&self, col: &mut Column<'a>, row: RowOffset) -> Result<(), DBError> {
        let rows = col.rows_mut::<types::Boolean>()?;
        rows[row] = *self;
        Ok(())
    }
}

impl<'b> ValueSetter for &'b str {
    fn set_row<'a>(&self, col: &mut Column<'a>, row: RowOffset) -> Result<(), DBError> {
        let data = self.as_bytes();
        let ptr = {
            let arena = col.arena();
            arena.append(data)?.1
        };

        let rows = col.rows_mut::<types::Text>()?;
        rows[row] = types::RawData{data: ptr, size: data.len()};
        Ok(())
    }
}

impl ValueSetter for String {
    fn set_row<'a>(&self, col: &mut Column<'a>, row: RowOffset) -> Result<(), DBError> {
        let data = self.as_bytes();
        let ptr = {
            let arena = col.arena();
            arena.append(data)?.1
        };

        let rows = col.rows_mut::<types::Text>()?;
        rows[row] = types::RawData{data: ptr, size: data.len()};
        Ok(())
    }
}

impl<'b> ValueSetter for &'b[u8] {
    fn set_row<'a>(&self, col: &mut Column<'a>, row: RowOffset) -> Result<(), DBError> {
        let ptr = {
            let arena = col.arena();
            arena.append(self)?.1
        };

        let rows = col.rows_mut::<types::Blob>()?;
        rows[row] = types::RawData{data: ptr, size: self.len()};
        Ok(())
    }
}

// TODO: Make a value alias... we can set a value but without copying the data in the arena.
// Clearly unsafe, but useful for things like join with Tiny... where it's always alive.