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

use arrow2::array::{
    growable::{Growable, GrowablePrimitive},
    PrimitiveArray,
};

/// tests extending from a primitive array w/ offset nor nulls
#[test]
fn basics() {
    let b = PrimitiveArray::<u8>::from(vec![Some(1), Some(2), Some(3)]);
    let mut a = GrowablePrimitive::new(vec![&b], false, 3);
    a.extend(0, 0, 2);
    assert_eq!(a.len(), 2);
    let result: PrimitiveArray<u8> = a.into();
    let expected = PrimitiveArray::<u8>::from(vec![Some(1), Some(2)]);
    assert_eq!(result, expected);
}

/// tests extending from a primitive array with offset w/ nulls
#[test]
fn offset() {
    let b = PrimitiveArray::<u8>::from(vec![Some(1), Some(2), Some(3)]);
    let b = b.sliced(1, 2);
    let mut a = GrowablePrimitive::new(vec![&b], false, 2);
    a.extend(0, 0, 2);
    assert_eq!(a.len(), 2);
    let result: PrimitiveArray<u8> = a.into();
    let expected = PrimitiveArray::<u8>::from(vec![Some(2), Some(3)]);
    assert_eq!(result, expected);
}

/// tests extending from a primitive array with offset and nulls
#[test]
fn null_offset() {
    let b = PrimitiveArray::<u8>::from(vec![Some(1), None, Some(3)]);
    let b = b.sliced(1, 2);
    let mut a = GrowablePrimitive::new(vec![&b], false, 2);
    a.extend(0, 0, 2);
    assert_eq!(a.len(), 2);
    let result: PrimitiveArray<u8> = a.into();
    let expected = PrimitiveArray::<u8>::from(vec![None, Some(3)]);
    assert_eq!(result, expected);
}

#[test]
fn null_offset_validity() {
    let b = PrimitiveArray::<u8>::from(&[Some(1), Some(2), Some(3)]);
    let b = b.sliced(1, 2);
    let mut a = GrowablePrimitive::new(vec![&b], true, 2);
    a.extend(0, 0, 2);
    a.extend_validity(3);
    a.extend(0, 1, 1);
    assert_eq!(a.len(), 6);
    let result: PrimitiveArray<u8> = a.into();
    let expected = PrimitiveArray::<u8>::from(&[Some(2), Some(3), None, None, None, Some(3)]);
    assert_eq!(result, expected);
}

#[test]
fn joining_arrays() {
    let b = PrimitiveArray::<u8>::from(&[Some(1), Some(2), Some(3)]);
    let c = PrimitiveArray::<u8>::from(&[Some(4), Some(5), Some(6)]);
    let mut a = GrowablePrimitive::new(vec![&b, &c], false, 4);
    a.extend(0, 0, 2);
    a.extend(1, 1, 2);
    assert_eq!(a.len(), 4);
    let result: PrimitiveArray<u8> = a.into();

    let expected = PrimitiveArray::<u8>::from(&[Some(1), Some(2), Some(5), Some(6)]);
    assert_eq!(result, expected);
}