serde_arrow 0.14.0

Convert sequences of Rust objects to Arrow arrays and back again
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

use serde::{Deserialize, Serialize};

use crate::{
    _impl::arrow::{array::ArrayRef, datatypes::FieldRef},
    schema::{SchemaLike, TracingOptions},
    ArrayBuilder, Deserializer,
};

#[derive(Debug, Deserialize, Serialize, PartialEq, Clone, Copy)]
struct Record {
    a: i32,
    b: Option<bool>,
}

#[derive(Debug, Deserialize, Serialize)]
struct StructWrapper(Record, Record);

#[derive(Debug, Deserialize, Serialize)]
struct NewTypeWrapper<I>(I);

#[derive(Debug, Serialize)]
enum Enum<'a> {
    NewTypeVariant(&'a [Record]),
    TupleVariant(Record, Record),
}

fn serialize<I: Serialize + ?Sized>(fields: &[FieldRef], items: &I) -> Vec<ArrayRef> {
    let builder = ArrayBuilder::from_arrow(fields).unwrap();
    items
        .serialize(crate::Serializer::new(builder))
        .unwrap()
        .into_inner()
        .to_arrow()
        .unwrap()
}

fn deserialize<'de, I: Deserialize<'de>>(fields: &[FieldRef], arrays: &'de [ArrayRef]) -> I {
    I::deserialize(Deserializer::<'de>::from_arrow(fields, arrays).unwrap()).unwrap()
}

#[test]
fn serialize_tuples() {
    let fields = Vec::<FieldRef>::from_type::<Record>(TracingOptions::default()).unwrap();

    let item = Record {
        a: 0,
        b: Some(true),
    };

    let _ = serialize::<(Record, Record)>(&fields, &(item, item));
    let _ = serialize::<StructWrapper>(&fields, &StructWrapper(item, item));
    let _ = serialize::<[Record]>(&fields, &[item, item]);
    let _ = serialize::<[Record; 2]>(&fields, &[item, item]);
    let _ = serialize::<NewTypeWrapper<&[Record]>>(&fields, &NewTypeWrapper(&[item, item]));
    let _ = serialize::<Enum>(&fields, &Enum::NewTypeVariant(&[item, item]));
    let _ = serialize::<Enum>(&fields, &Enum::TupleVariant(item, item));
}

#[test]
fn deserialize_tuples() {
    let fields = Vec::<FieldRef>::from_type::<Record>(TracingOptions::default()).unwrap();
    let arrays = serialize(
        &fields,
        &[
            Record {
                a: 0,
                b: Some(true),
            },
            Record { a: 1, b: None },
        ],
    );

    // try the different options to deserialize
    let _ = deserialize::<(Record, Record)>(&fields, &arrays);
    let _ = deserialize::<[Record; 2]>(&fields, &arrays);
    let _ = deserialize::<StructWrapper>(&fields, &arrays);
    let _ = deserialize::<Vec<Record>>(&fields, &arrays);
    let _ = deserialize::<NewTypeWrapper<Vec<Record>>>(&fields, &arrays);
}