IsSortedKernel

Signed-off-by: Nicholas Gates <nick@nickgates.com>

Author: gatesn

vortex-array/src/aggregate_fn/fns/is_sorted/bool.rs

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+use vortex_mask::Mask;
+
+use super::IsSortedIteratorExt;
+use crate::arrays::BoolArray;
+
+pub(super) fn check_bool_sorted(array: &BoolArray, strict: bool) -> VortexResult<bool> {
+    match array.validity_mask()? {
+        Mask::AllFalse(_) => Ok(!strict),
+        Mask::AllTrue(_) => {
+            let values = array.to_bit_buffer();
+            Ok(if strict {
+                values.iter().is_strict_sorted()
+            } else {
+                values.iter().is_sorted()
+            })
+        }
+        Mask::Values(mask_values) => {
+            if strict {
+                let validity_buffer = mask_values.bit_buffer();
+                let values = array.to_bit_buffer();
+                Ok(validity_buffer
+                    .iter()
+                    .zip(values.iter())
+                    .map(|(is_valid, value)| is_valid.then_some(value))
+                    .is_strict_sorted())
+            } else {
+                let set_indices = mask_values.bit_buffer().set_indices();
+                let values = array.to_bit_buffer();
+                let values_iter = set_indices.map(|idx|
+                    // Safety:
+                    // All idxs are in-bounds for the array.
+                    unsafe {
+                        values.value_unchecked(idx)
+                    });
+                Ok(values_iter.is_sorted())
+            }
+        }
+    }
+}

vortex-array/src/aggregate_fn/fns/is_sorted/decimal.rs

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use itertools::Itertools;
+use vortex_error::VortexResult;
+use vortex_mask::Mask;
+
+use super::IsSortedIteratorExt;
+use crate::arrays::DecimalArray;
+use crate::dtype::NativeDecimalType;
+use crate::match_each_decimal_value_type;
+
+pub(super) fn check_decimal_sorted(array: &DecimalArray, strict: bool) -> VortexResult<bool> {
+    match_each_decimal_value_type!(array.values_type(), |S| {
+        compute_is_sorted::<S>(array, strict)
+    })
+}
+
+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()
+            })
+        }
+    }
+}

vortex-array/src/aggregate_fn/fns/is_sorted/extension.rs

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+
+use crate::ExecutionCtx;
+use crate::arrays::ExtensionArray;
+
+pub(super) fn check_extension_sorted(
+    array: &ExtensionArray,
+    strict: bool,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<bool> {
+    if strict {
+        super::is_strict_sorted(array.storage_array(), ctx)
+    } else {
+        super::is_sorted(array.storage_array(), ctx)
+    }
+}