vortex-array 0.62.0

Vortex in memory columnar data format
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

// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: Copyright the Vortex contributors

use itertools::Itertools;
use vortex_error::VortexResult;
use vortex_mask::Mask;

use crate::arrays::DecimalArray;
use crate::arrays::DecimalVTable;
use crate::compute::IsSortedIteratorExt;
use crate::compute::IsSortedKernel;
use crate::compute::IsSortedKernelAdapter;
use crate::dtype::NativeDecimalType;
use crate::match_each_decimal_value_type;
use crate::register_kernel;

impl IsSortedKernel for DecimalVTable {
    fn is_sorted(&self, array: &DecimalArray) -> VortexResult<Option<bool>> {
        is_decimal_sorted(array, false)
    }

    fn is_strict_sorted(&self, array: &DecimalArray) -> VortexResult<Option<bool>> {
        is_decimal_sorted(array, true)
    }
}

register_kernel!(IsSortedKernelAdapter(DecimalVTable).lift());

fn is_decimal_sorted(array: &DecimalArray, strict: bool) -> VortexResult<Option<bool>> {
    match_each_decimal_value_type!(array.values_type, |S| {
        compute_is_sorted::<S>(array, strict).map(Some)
    })
}

fn compute_is_sorted<T: NativeDecimalType>(array: &DecimalArray, strict: bool) -> VortexResult<bool>
where
    dyn Iterator<Item = T>: IsSortedIteratorExt,
{
    match array.validity_mask()? {
        Mask::AllFalse(_) => Ok(!strict),
        Mask::AllTrue(_) => {
            let buf = array.buffer::<T>();
            let iter = buf.iter().copied();

            Ok(if strict {
                IsSortedIteratorExt::is_strict_sorted(iter)
            } else {
                iter.is_sorted()
            })
        }
        Mask::Values(mask_values) => {
            let values = array.buffer::<T>();
            let iter = mask_values
                .bit_buffer()
                .iter()
                .zip_eq(values)
                .map(|(is_valid, v)| is_valid.then_some(v));

            Ok(if strict {
                IsSortedIteratorExt::is_strict_sorted(iter)
            } else {
                iter.is_sorted()
            })
        }
    }
}

#[cfg(test)]
mod tests {
    use arrow_array::types::Decimal128Type;
    use arrow_cast::parse::parse_decimal;
    use vortex_buffer::buffer;

    use crate::IntoArray;
    use crate::arrays::DecimalArray;
    use crate::compute::is_sorted;
    use crate::compute::is_strict_sorted;
    use crate::dtype::DecimalDType;
    use crate::validity::Validity;

    #[test]
    fn test_is_sorted() {
        let dtype = DecimalDType::new(19, 2);
        let i100 =
            parse_decimal::<Decimal128Type>("100.00", dtype.precision(), dtype.scale()).unwrap();
        let i200 =
            parse_decimal::<Decimal128Type>("200.00", dtype.precision(), dtype.scale()).unwrap();

        let sorted = buffer![i100, i200, i200];
        let unsorted = buffer![i200, i100, i200];

        let sorted_array = DecimalArray::new(sorted, dtype, Validity::NonNullable);
        let unsorted_array = DecimalArray::new(unsorted, dtype, Validity::NonNullable);

        assert!(is_sorted(&sorted_array.into_array()).unwrap().unwrap());
        assert!(!is_sorted(&unsorted_array.into_array()).unwrap().unwrap());
    }

    #[test]
    fn test_is_strict_sorted() {
        let dtype = DecimalDType::new(19, 2);
        let i100 =
            parse_decimal::<Decimal128Type>("100.00", dtype.precision(), dtype.scale()).unwrap();
        let i200 =
            parse_decimal::<Decimal128Type>("200.00", dtype.precision(), dtype.scale()).unwrap();
        let i300 =
            parse_decimal::<Decimal128Type>("300.00", dtype.precision(), dtype.scale()).unwrap();

        let strict_sorted = buffer![i100, i200, i300];
        let sorted = buffer![i100, i200, i200];

        let dtype = DecimalDType::new(19, 2);

        let strict_sorted_array = DecimalArray::new(strict_sorted, dtype, Validity::NonNullable);
        let sorted_array = DecimalArray::new(sorted, dtype, Validity::NonNullable);

        assert!(
            is_strict_sorted(&strict_sorted_array.into_array())
                .unwrap()
                .unwrap()
        );
        assert!(
            !is_strict_sorted(&sorted_array.into_array())
                .unwrap()
                .unwrap()
        );
    }
}