murr 0.2.1

Columnar in-memory cache for AI/ML inference workloads
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

use arrow::{
    array::{Array, ArrayRef},
    datatypes::{DataType, Int64Type},
};
use serde_json::Value;

use crate::{
    core::{DType, DTypeName, MurrError},
    io::{
        codec::{ArrowCodec, ColumnDecoder, ColumnEncoder, JsonCodec, primitive},
        schema::SegmentColumnSchema,
    },
};

pub struct Int64;

impl DType for Int64 {
    fn name(&self) -> DTypeName {
        DTypeName::Int64
    }
    fn arrow_dtype(&self) -> DataType {
        DataType::Int64
    }
    fn size(&self) -> usize {
        8
    }
}

impl ArrowCodec for Int64 {
    fn make_encoder(&self, col: SegmentColumnSchema, rows: usize) -> Box<dyn ColumnEncoder> {
        Box::new(primitive::Encoder::<Int64Type>::new(col, rows))
    }
    fn make_decoder(
        &self,
        col: SegmentColumnSchema,
        arr: &dyn Array,
    ) -> Result<Box<dyn ColumnDecoder>, MurrError> {
        Ok(Box::new(primitive::Decoder::<Int64Type>::new(col, arr)?))
    }
}

impl JsonCodec for Int64 {
    fn to_json(&self, arr: &dyn Array) -> Result<Vec<Value>, MurrError> {
        primitive::to_json::<Int64Type>(arr)
    }
    fn from_json(&self, vals: &[Value]) -> Result<ArrayRef, MurrError> {
        primitive::from_json::<Int64Type>(vals)
    }
}

#[cfg(test)]
mod tests {
    use crate::core::DTypeName;
    use crate::io::codec::test_util::{assert_json_roundtrip, assert_row_roundtrip};
    use arrow::array::Int64Array;
    use rstest::rstest;

    #[rstest]
    #[case::neg(Some(-7))]
    #[case::null(None)]
    #[case::min(Some(i64::MIN))]
    #[case::max(Some(i64::MAX))]
    #[case::zero(Some(0))]
    fn row_roundtrip(#[case] v: Option<i64>) {
        assert_row_roundtrip(DTypeName::Int64, &Int64Array::from(vec![v]));
    }

    #[rstest]
    #[case::neg(Some(-7))]
    #[case::null(None)]
    #[case::min(Some(i64::MIN))]
    #[case::max(Some(i64::MAX))]
    #[case::zero(Some(0))]
    fn json_roundtrip(#[case] v: Option<i64>) {
        assert_json_roundtrip(DTypeName::Int64, &Int64Array::from(vec![v]));
    }
}