Port IsSortedFn to IsSortedKernel (#3203)

Author: gatesn

encodings/dict/src/compute/is_sorted.rs

@@ -1,10 +1,12 @@
-use vortex_array::compute::{IsSortedFn, is_sorted, is_strict_sorted};
+use vortex_array::compute::{IsSortedKernel, IsSortedKernelAdapter, is_sorted, is_strict_sorted};
+use vortex_array::register_kernel;
 use vortex_error::VortexResult;
 
 use crate::{DictArray, DictEncoding};
 
-impl IsSortedFn<&DictArray> for DictEncoding {
+impl IsSortedKernel for DictEncoding {
     fn is_sorted(&self, array: &DictArray) -> VortexResult<bool> {
+        // TODO(ngates): we should change these kernels to return Option<bool> to allow for "unknown"
         let is_sorted = is_sorted(array.values())? && is_sorted(array.codes())?;
         Ok(is_sorted)
     }
@@ -14,3 +16,5 @@ impl IsSortedFn<&DictArray> for DictEncoding {
         Ok(is_sorted)
     }
 }
+
+register_kernel!(IsSortedKernelAdapter(DictEncoding).lift());

encodings/dict/src/compute/mod.rs

@@ -7,8 +7,8 @@ mod like;
 mod min_max;
 
 use vortex_array::compute::{
-    FillNullFn, FilterKernel, FilterKernelAdapter, IsSortedFn, MinMaxFn, ScalarAtFn, TakeFn,
-    filter, scalar_at, take,
+    FillNullFn, FilterKernel, FilterKernelAdapter, MinMaxFn, ScalarAtFn, TakeFn, filter, scalar_at,
+    take,
 };
 use vortex_array::vtable::ComputeVTable;
 use vortex_array::{Array, ArrayRef, register_kernel};
@@ -23,10 +23,6 @@ impl ComputeVTable for DictEncoding {
         Some(self)
     }
 
-    fn is_sorted_fn(&self) -> Option<&dyn IsSortedFn<&dyn Array>> {
-        Some(self)
-    }
-
     fn scalar_at_fn(&self) -> Option<&dyn ScalarAtFn<&dyn Array>> {
         Some(self)
     }

encodings/runend/src/compute/is_sorted.rs

@@ -1,9 +1,9 @@
-use vortex_array::Array;
-use vortex_array::compute::{IsSortedFn, is_sorted, is_strict_sorted};
+use vortex_array::compute::{IsSortedKernel, IsSortedKernelAdapter, is_sorted, is_strict_sorted};
+use vortex_array::{Array, register_kernel};
 
 use crate::{RunEndArray, RunEndEncoding};
 
-impl IsSortedFn<&RunEndArray> for RunEndEncoding {
+impl IsSortedKernel for RunEndEncoding {
     fn is_sorted(&self, array: &RunEndArray) -> vortex_error::VortexResult<bool> {
         is_sorted(array.values())
     }
@@ -12,3 +12,5 @@ impl IsSortedFn<&RunEndArray> for RunEndEncoding {
         is_strict_sorted(array.to_canonical()?.as_ref())
     }
 }
+
+register_kernel!(IsSortedKernelAdapter(RunEndEncoding).lift());

encodings/runend/src/compute/mod.rs

@@ -10,7 +10,7 @@ pub(crate) mod take;
 mod take_from;
 
 use vortex_array::Array;
-use vortex_array::compute::{FillNullFn, IsSortedFn, MinMaxFn, ScalarAtFn, TakeFn, TakeFromFn};
+use vortex_array::compute::{FillNullFn, MinMaxFn, ScalarAtFn, TakeFn, TakeFromFn};
 use vortex_array::vtable::ComputeVTable;
 
 use crate::RunEndEncoding;
@@ -20,10 +20,6 @@ impl ComputeVTable for RunEndEncoding {
         Some(self)
     }
 
-    fn is_sorted_fn(&self) -> Option<&dyn IsSortedFn<&dyn Array>> {
-        Some(self)
-    }
-
     fn scalar_at_fn(&self) -> Option<&dyn ScalarAtFn<&dyn Array>> {
         Some(self)
     }

vortex-array/src/arrays/bool/compute/is_sorted.rs

@@ -1,11 +1,11 @@
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
-use crate::Array;
 use crate::arrays::{BoolArray, BoolEncoding};
-use crate::compute::{IsSortedFn, IsSortedIteratorExt};
+use crate::compute::{IsSortedIteratorExt, IsSortedKernel, IsSortedKernelAdapter};
+use crate::{Array, register_kernel};
 
-impl IsSortedFn<&BoolArray> for BoolEncoding {
+impl IsSortedKernel for BoolEncoding {
     fn is_sorted(&self, array: &BoolArray) -> VortexResult<bool> {
         match array.validity_mask()? {
             Mask::AllFalse(_) => Ok(true),
@@ -42,3 +42,5 @@ impl IsSortedFn<&BoolArray> for BoolEncoding {
         }
     }
 }
+
+register_kernel!(IsSortedKernelAdapter(BoolEncoding).lift());

vortex-array/src/arrays/bool/compute/mod.rs

@@ -1,6 +1,6 @@
 use crate::Array;
 use crate::arrays::BoolEncoding;
-use crate::compute::{FillNullFn, IsSortedFn, MinMaxFn, ScalarAtFn, TakeFn, UncompressedSizeFn};
+use crate::compute::{FillNullFn, MinMaxFn, ScalarAtFn, TakeFn, UncompressedSizeFn};
 use crate::vtable::ComputeVTable;
 
 mod cast;
@@ -22,10 +22,6 @@ impl ComputeVTable for BoolEncoding {
         Some(self)
     }
 
-    fn is_sorted_fn(&self) -> Option<&dyn IsSortedFn<&dyn Array>> {
-        Some(self)
-    }
-
     fn min_max_fn(&self) -> Option<&dyn MinMaxFn<&dyn Array>> {
         Some(self)
     }

vortex-array/src/arrays/chunked/compute/is_sorted.rs

@@ -1,10 +1,12 @@
 use vortex_error::VortexResult;
 
-use crate::Array;
 use crate::arrays::{ChunkedArray, ChunkedEncoding};
-use crate::compute::{IsSortedFn, is_sorted, is_strict_sorted, scalar_at};
+use crate::compute::{
+    IsSortedKernel, IsSortedKernelAdapter, is_sorted, is_strict_sorted, scalar_at,
+};
+use crate::{Array, register_kernel};
 
-impl IsSortedFn<&ChunkedArray> for ChunkedEncoding {
+impl IsSortedKernel for ChunkedEncoding {
     fn is_sorted(&self, array: &ChunkedArray) -> VortexResult<bool> {
         is_sorted_impl(array, false, is_sorted)
     }
@@ -14,6 +16,8 @@ impl IsSortedFn<&ChunkedArray> for ChunkedEncoding {
     }
 }
 
+register_kernel!(IsSortedKernelAdapter(ChunkedEncoding).lift());
+
 fn is_sorted_impl(
     array: &ChunkedArray,
     strict: bool,

vortex-array/src/arrays/chunked/compute/mod.rs

@@ -1,6 +1,6 @@
 use crate::Array;
 use crate::arrays::ChunkedEncoding;
-use crate::compute::{FillNullFn, IsSortedFn, MinMaxFn, ScalarAtFn, TakeFn, UncompressedSizeFn};
+use crate::compute::{FillNullFn, MinMaxFn, ScalarAtFn, TakeFn, UncompressedSizeFn};
 use crate::vtable::ComputeVTable;
 
 mod cast;
@@ -23,10 +23,6 @@ impl ComputeVTable for ChunkedEncoding {
         Some(self)
     }
 
-    fn is_sorted_fn(&self) -> Option<&dyn IsSortedFn<&dyn Array>> {
-        Some(self)
-    }
-
     fn scalar_at_fn(&self) -> Option<&dyn ScalarAtFn<&dyn Array>> {
         Some(self)
     }

vortex-array/src/arrays/decimal/compute/is_sorted.rs

@@ -1,11 +1,12 @@
+use itertools::Itertools;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
 use crate::arrays::{DecimalArray, DecimalEncoding, NativeDecimalType};
-use crate::compute::{IsSortedFn, IsSortedIteratorExt};
-use crate::{Array, match_each_decimal_value_type};
+use crate::compute::{IsSortedIteratorExt, IsSortedKernel, IsSortedKernelAdapter};
+use crate::{Array, match_each_decimal_value_type, register_kernel};
 
-impl IsSortedFn<&DecimalArray> for DecimalEncoding {
+impl IsSortedKernel for DecimalEncoding {
     fn is_sorted(&self, array: &DecimalArray) -> VortexResult<bool> {
         is_decimal_sorted(array, false)
     }
@@ -15,6 +16,8 @@ impl IsSortedFn<&DecimalArray> for DecimalEncoding {
     }
 }
 
+register_kernel!(IsSortedKernelAdapter(DecimalEncoding).lift());
+
 fn is_decimal_sorted(array: &DecimalArray, strict: bool) -> VortexResult<bool> {
     match_each_decimal_value_type!(array.values_type, |$S| {
        compute_is_sorted::<$S>(array, strict)
@@ -38,12 +41,12 @@ where
             })
         }
         Mask::Values(mask_values) => {
-            let buf = array.buffer::<T>();
-
+            let values = array.buffer::<T>();
             let iter = mask_values
                 .boolean_buffer()
-                .set_indices()
-                .map(|idx| buf[idx]);
+                .iter()
+                .zip_eq(values)
+                .map(|(is_valid, v)| is_valid.then_some(v));
 
             Ok(if strict {
                 IsSortedIteratorExt::is_strict_sorted(iter)
@@ -56,6 +59,8 @@ where
 
 #[cfg(test)]
 mod tests {
+    use arrow_array::types::Decimal128Type;
+    use arrow_cast::parse::parse_decimal;
     use vortex_buffer::buffer;
     use vortex_dtype::DecimalDType;
 
@@ -65,10 +70,14 @@ mod tests {
 
     #[test]
     fn test_is_sorted() {
-        let sorted = buffer![100i128, 200i128, 200i128];
-        let unsorted = buffer![200i128, 100i128, 200i128];
-
         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);
@@ -79,8 +88,16 @@ mod tests {
 
     #[test]
     fn test_is_strict_sorted() {
-        let strict_sorted = buffer![100i128, 200i128, 300i128];
-        let sorted = buffer![100i128, 200i128, 200i128];
+        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);
 

vortex-array/src/arrays/decimal/compute/mod.rs

@@ -10,14 +10,10 @@ mod uncompressed_size;
 
 use crate::Array;
 use crate::arrays::DecimalEncoding;
-use crate::compute::{IsSortedFn, MinMaxFn, ScalarAtFn, TakeFn, UncompressedSizeFn};
+use crate::compute::{MinMaxFn, ScalarAtFn, TakeFn, UncompressedSizeFn};
 use crate::vtable::ComputeVTable;
 
 impl ComputeVTable for DecimalEncoding {
-    fn is_sorted_fn(&self) -> Option<&dyn IsSortedFn<&dyn Array>> {
-        Some(self)
-    }
-
     fn scalar_at_fn(&self) -> Option<&dyn ScalarAtFn<&dyn Array>> {
         Some(self)
     }