arrow2 0.18.0

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

use arrow2::array::{
    growable::{Growable, GrowableBinary},
    BinaryArray,
};

#[test]
fn no_offsets() {
    let array = BinaryArray::<i32>::from([Some("a"), Some("bc"), None, Some("defh")]);

    let mut a = GrowableBinary::new(vec![&array], false, 0);

    a.extend(0, 1, 2);
    assert_eq!(a.len(), 2);

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

    let expected = BinaryArray::<i32>::from([Some("bc"), None]);
    assert_eq!(result, expected);
}

/// tests extending from a variable-sized (strings and binary) array
/// with an offset and nulls
#[test]
fn with_offsets() {
    let array = BinaryArray::<i32>::from([Some("a"), Some("bc"), None, Some("defh")]);
    let array = array.sliced(1, 3);

    let mut a = GrowableBinary::new(vec![&array], false, 0);

    a.extend(0, 0, 3);
    assert_eq!(a.len(), 3);

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

    let expected = BinaryArray::<i32>::from([Some("bc"), None, Some("defh")]);
    assert_eq!(result, expected);
}

#[test]
fn test_string_offsets() {
    let array = BinaryArray::<i32>::from([Some("a"), Some("bc"), None, Some("defh")]);
    let array = array.sliced(1, 3);

    let mut a = GrowableBinary::new(vec![&array], false, 0);

    a.extend(0, 0, 3);
    assert_eq!(a.len(), 3);

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

    let expected = BinaryArray::<i32>::from([Some("bc"), None, Some("defh")]);
    assert_eq!(result, expected);
}

#[test]
fn test_multiple_with_validity() {
    let array1 = BinaryArray::<i32>::from_slice([b"hello", b"world"]);
    let array2 = BinaryArray::<i32>::from([Some("1"), None]);

    let mut a = GrowableBinary::new(vec![&array1, &array2], false, 5);

    a.extend(0, 0, 2);
    a.extend(1, 0, 2);
    assert_eq!(a.len(), 4);

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

    let expected = BinaryArray::<i32>::from([Some("hello"), Some("world"), Some("1"), None]);
    assert_eq!(result, expected);
}

#[test]
fn test_string_null_offset_validity() {
    let array = BinaryArray::<i32>::from([Some("a"), Some("bc"), None, Some("defh")]);
    let array = array.sliced(1, 3);

    let mut a = GrowableBinary::new(vec![&array], true, 0);

    a.extend(0, 1, 2);
    a.extend_validity(1);
    assert_eq!(a.len(), 3);

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

    let expected = BinaryArray::<i32>::from([None, Some("defh"), None]);
    assert_eq!(result, expected);
}