narrow 0.15.1

An implementation of Apache Arrow
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

//! Interop with `arrow-rs` boolean array.

use std::sync::Arc;

use crate::{
    Length,
    array::{NullArray, Nulls, Unit},
    buffer::BufferType,
    nullability::{NonNullable, Nullability},
};
use arrow_array::Array;
use arrow_schema::{DataType, Field};

impl<T: Unit, Nullable: Nullability, Buffer: BufferType> crate::arrow::Array
    for NullArray<T, Nullable, Buffer>
{
    type Array = arrow_array::NullArray;

    fn as_field(name: &str) -> arrow_schema::Field {
        Field::new(name, Self::data_type(), Nullable::NULLABLE)
    }

    fn data_type() -> arrow_schema::DataType {
        DataType::Null
    }
}

impl<T: Unit, Buffer: BufferType> From<Arc<dyn arrow_array::Array>>
    for NullArray<T, NonNullable, Buffer>
where
    Self: From<arrow_array::NullArray>,
{
    fn from(value: Arc<dyn arrow_array::Array>) -> Self {
        Self::from(arrow_array::NullArray::from(value.to_data()))
    }
}

impl<T: Unit, Buffer: BufferType> From<NullArray<T, NonNullable, Buffer>>
    for Arc<dyn arrow_array::Array>
where
    arrow_array::NullArray: From<NullArray<T, NonNullable, Buffer>>,
{
    fn from(value: NullArray<T, NonNullable, Buffer>) -> Self {
        Arc::new(arrow_array::NullArray::from(value))
    }
}

impl<T: Unit, Buffer: BufferType> From<NullArray<T, NonNullable, Buffer>>
    for arrow_array::NullArray
{
    fn from(value: NullArray<T, NonNullable, Buffer>) -> Self {
        arrow_array::NullArray::new(value.len())
    }
}

impl<T: Unit, Buffer: BufferType> From<arrow_array::NullArray>
    for NullArray<T, NonNullable, Buffer>
{
    fn from(value: arrow_array::NullArray) -> Self {
        NullArray(Nulls::new(value.len()))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    use crate::buffer::ArcBuffer;

    const INPUT: [(); 4] = [(), (), (), ()];

    #[test]
    #[cfg(feature = "derive")]
    fn derive() {
        use crate::array::StructArray;
        use arrow_array::{Array, cast::AsArray};
        use std::sync::Arc;

        #[derive(crate::ArrayType, Copy, Clone, Debug, Default)]
        struct Unit;

        #[derive(crate::ArrayType, Copy, Clone, Debug, Default)]
        struct NestedUnit(Unit);

        let input = [Unit; 4];
        let array = input.into_iter().collect::<NullArray<Unit>>();
        let arrow_array = arrow_array::NullArray::from(array);
        assert!(arrow_array.data_type().is_null());
        let narrow_array = NullArray::<Unit>::from(arrow_array);
        assert_eq!(narrow_array.len(), 4);

        let input_nested = [NestedUnit(Unit); 4];
        let array_nested = input_nested
            .into_iter()
            .collect::<StructArray<NestedUnit>>();
        let arrow_array_nested = arrow_array::StructArray::from(array_nested);
        assert!(
            arrow_array_nested
                .column(0)
                .as_struct()
                .column(0)
                .data_type()
                .is_null()
        );
        assert_eq!(arrow_array_nested.len(), 4);
        let inner_unit = Arc::clone(arrow_array_nested.column(0).as_struct().column(0));
        let narrow_array_inner = NullArray::<Unit>::from(inner_unit);
        assert_eq!(narrow_array_inner.len(), 4);
        let narrow_array_nested = StructArray::<NestedUnit>::from(arrow_array_nested);
        assert_eq!(narrow_array_nested.len(), 4);
    }

    #[test]
    fn from() {
        let null_array = INPUT.into_iter().collect::<NullArray>();
        assert_eq!(
            arrow_array::NullArray::new(null_array.len()).len(),
            INPUT.len()
        );

        let null_array_arc = INPUT
            .into_iter()
            .collect::<NullArray<_, NonNullable, ArcBuffer>>();
        assert_eq!(
            arrow_array::NullArray::new(null_array_arc.len()).len(),
            INPUT.len()
        );
    }

    #[test]
    fn into() {
        let null_array = arrow_array::NullArray::new(INPUT.len());
        assert_eq!(
            NullArray::<(), NonNullable, crate::arrow::buffer::ScalarBuffer>::from(null_array)
                .into_iter()
                .collect::<Vec<_>>(),
            INPUT
        );
    }
}