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
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

use std::cmp::Ordering;

use arrow2::array::ord::build_compare;
use arrow2::array::*;
use arrow2::datatypes::DataType;
use arrow2::error::Result;

#[test]
fn i32() -> Result<()> {
    let array = Int32Array::from_slice([1, 2]);

    let cmp = build_compare(&array, &array)?;

    assert_eq!(Ordering::Less, (cmp)(0, 1));
    Ok(())
}

#[test]
fn i32_i32() -> Result<()> {
    let array1 = Int32Array::from_slice([1]);
    let array2 = Int32Array::from_slice([2]);

    let cmp = build_compare(&array1, &array2)?;

    assert_eq!(Ordering::Less, (cmp)(0, 0));
    Ok(())
}

#[test]
fn f32() -> Result<()> {
    let array = &Float32Array::from_slice([1.0, 2.0]);

    let cmp = build_compare(array, array)?;

    assert_eq!(Ordering::Less, (cmp)(0, 1));
    Ok(())
}

#[test]
fn f64() -> Result<()> {
    let array = Float64Array::from_slice([1.0, 2.0]);

    let cmp = build_compare(&array, &array)?;

    assert_eq!(Ordering::Less, (cmp)(0, 1));
    Ok(())
}

#[test]
fn f64_nan() -> Result<()> {
    let array = Float64Array::from_slice([1.0, f64::NAN]);

    let cmp = build_compare(&array, &array)?;

    assert_eq!(Ordering::Less, (cmp)(0, 1));
    Ok(())
}

#[test]
fn f64_zeros() -> Result<()> {
    let array = Float64Array::from_slice([-0.0, 0.0]);

    let cmp = build_compare(&array, &array)?;

    // official IEEE 754 (2008 revision)
    assert_eq!(Ordering::Less, (cmp)(0, 1));
    assert_eq!(Ordering::Greater, (cmp)(1, 0));
    Ok(())
}

#[test]
fn decimal() -> Result<()> {
    let array = Int128Array::from_slice([1, 2]).to(DataType::Decimal(38, 0));

    let cmp = build_compare(&array, &array)?;

    assert_eq!(Ordering::Less, (cmp)(0, 1));
    assert_eq!(Ordering::Equal, (cmp)(1, 1));
    assert_eq!(Ordering::Greater, (cmp)(1, 0));

    Ok(())
}

#[test]
fn dict_utf8() -> Result<()> {
    let data = vec!["a", "b", "c", "a", "a", "c", "c"];

    let data = data.into_iter().map(Some);
    let mut array = MutableDictionaryArray::<i32, MutableUtf8Array<i32>>::new();
    array.try_extend(data)?;
    let array: DictionaryArray<i32> = array.into();

    let cmp = build_compare(&array, &array)?;

    assert_eq!(Ordering::Less, (cmp)(0, 1));
    assert_eq!(Ordering::Equal, (cmp)(3, 4));
    assert_eq!(Ordering::Greater, (cmp)(2, 3));
    Ok(())
}

#[test]
fn dict_i32() -> Result<()> {
    let data = vec![1, 2, 3, 1, 1, 3, 3];

    let data = data.into_iter().map(Some);

    let mut array = MutableDictionaryArray::<i32, MutablePrimitiveArray<i32>>::new();
    array.try_extend(data)?;
    let array = array.into_arc();

    let cmp = build_compare(array.as_ref(), array.as_ref())?;

    assert_eq!(Ordering::Less, (cmp)(0, 1));
    assert_eq!(Ordering::Equal, (cmp)(3, 4));
    assert_eq!(Ordering::Greater, (cmp)(2, 3));
    Ok(())
}