arrow2 0.10.1

Unofficial implementation of Apache Arrow spec in safe Rust
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

use std::ops::Deref;

use arrow2::array::{BinaryArray, MutableArray, MutableBinaryArray};
use arrow2::bitmap::Bitmap;
use arrow2::error::ArrowError;

#[test]
fn new() {
    assert_eq!(MutableBinaryArray::<i32>::new().len(), 0);

    let a = MutableBinaryArray::<i32>::with_capacity(2);
    assert_eq!(a.len(), 0);
    assert!(a.offsets().capacity() >= 3);
    assert_eq!(a.values().capacity(), 0);

    let a = MutableBinaryArray::<i32>::with_capacities(2, 60);
    assert_eq!(a.len(), 0);
    assert!(a.offsets().capacity() >= 3);
    assert!(a.values().capacity() >= 60);
}

#[test]
fn from_iter() {
    let iter = (0..3u8).map(|x| Some(vec![x; x as usize]));
    let a: MutableBinaryArray<i32> = iter.clone().collect();
    assert_eq!(a.values().deref(), &[1u8, 2, 2]);
    assert_eq!(a.offsets().deref(), &[0, 0, 1, 3]);
    assert_eq!(a.validity(), None);

    let a = unsafe { MutableBinaryArray::<i32>::from_trusted_len_iter_unchecked(iter) };
    assert_eq!(a.values().deref(), &[1u8, 2, 2]);
    assert_eq!(a.offsets().deref(), &[0, 0, 1, 3]);
    assert_eq!(a.validity(), None);
}

#[test]
fn from_trusted_len_iter() {
    let iter = (0..3u8).map(|x| vec![x; x as usize]);
    let a: MutableBinaryArray<i32> = iter.clone().map(Some).collect();
    assert_eq!(a.values().deref(), &[1u8, 2, 2]);
    assert_eq!(a.offsets().deref(), &[0, 0, 1, 3]);
    assert_eq!(a.validity(), None);

    let a = unsafe {
        MutableBinaryArray::<i32>::from_trusted_len_iter_unchecked(iter.clone().map(Some))
    };
    assert_eq!(a.values().deref(), &[1u8, 2, 2]);
    assert_eq!(a.offsets().deref(), &[0, 0, 1, 3]);
    assert_eq!(a.validity(), None);

    let a = unsafe {
        MutableBinaryArray::<i32>::try_from_trusted_len_iter_unchecked::<ArrowError, _, _>(
            iter.clone().map(Some).map(Ok),
        )
    }
    .unwrap();
    assert_eq!(a.values().deref(), &[1u8, 2, 2]);
    assert_eq!(a.offsets().deref(), &[0, 0, 1, 3]);
    assert_eq!(a.validity(), None);

    let a = unsafe { MutableBinaryArray::<i32>::from_trusted_len_values_iter_unchecked(iter) };
    assert_eq!(a.values().deref(), &[1u8, 2, 2]);
    assert_eq!(a.offsets().deref(), &[0, 0, 1, 3]);
    assert_eq!(a.validity(), None);
}

#[test]
fn push_null() {
    let mut array = MutableBinaryArray::<i32>::new();
    array.push::<&str>(None);

    let array: BinaryArray<i32> = array.into();
    assert_eq!(array.validity(), Some(&Bitmap::from([false])));
}

#[test]
fn extend_trusted_len_values() {
    let mut array = MutableBinaryArray::<i32>::new();

    array.extend_trusted_len_values(vec![b"first".to_vec(), b"second".to_vec()].into_iter());
    array.extend_trusted_len_values(vec![b"third".to_vec()].into_iter());
    array.extend_trusted_len(vec![None, Some(b"fourth".to_vec())].into_iter());

    let array: BinaryArray<i32> = array.into();

    assert_eq!(array.values().as_slice(), b"firstsecondthirdfourth");
    assert_eq!(array.offsets().as_slice(), &[0, 5, 11, 16, 16, 22]);
    assert_eq!(
        array.validity(),
        Some(&Bitmap::from_u8_slice(&[0b00010111], 5))
    );
}

#[test]
fn extend_trusted_len() {
    let mut array = MutableBinaryArray::<i32>::new();

    array.extend_trusted_len(vec![Some(b"first".to_vec()), Some(b"second".to_vec())].into_iter());
    array.extend_trusted_len(vec![None, Some(b"third".to_vec())].into_iter());

    let array: BinaryArray<i32> = array.into();

    assert_eq!(array.values().as_slice(), b"firstsecondthird");
    assert_eq!(array.offsets().as_slice(), &[0, 5, 11, 11, 16]);
    assert_eq!(
        array.validity(),
        Some(&Bitmap::from_u8_slice(&[0b00001011], 4))
    );
}