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

use std::collections::HashMap;

use marrow::{
    datatypes::FieldMeta,
    view::{BitsWithOffset, BooleanView, StructView, View},
};
use serde::Deserialize;
use serde_json::json;

use crate::{
    internal::testing::assert_error_contains,
    schema::{SchemaLike, SerdeArrowSchema},
    Deserializer,
};

#[test]
fn example_exhausted() {
    let views = vec![View::Struct(StructView {
        len: 5,
        validity: None,
        fields: vec![(
            FieldMeta {
                name: String::from("nested"),
                nullable: false,
                metadata: HashMap::new(),
            },
            View::Boolean(BooleanView {
                len: 2,
                validity: None,
                values: BitsWithOffset {
                    data: &[0b_0001_0011],
                    offset: 0,
                },
            }),
        )],
    })];

    let schema = SerdeArrowSchema::from_value(json!([{
        "name": "item",
        "data_type": "Struct",
        "children": [
            {"name": "nested", "data_type": "Bool"},
        ],
    }]))
    .unwrap();

    let deserializer = Deserializer::new(&schema.fields, views).unwrap();

    #[derive(Deserialize, Debug)]
    struct S {
        #[allow(dead_code)]
        item: Nested,
    }

    #[derive(Deserialize, Debug)]
    struct Nested {
        #[allow(dead_code)]
        nested: bool,
    }

    let err = Vec::<S>::deserialize(deserializer).unwrap_err();
    assert_error_contains(&err, "Out of bounds access");
    assert_error_contains(&err, "field: \"$.item.nested\"");
    assert_error_contains(&err, "data_type: \"Boolean\"");
}