fix

Signed-off-by: Robert Kruszewski <[email protected]>

Author: robert3005

fuzz/src/array/compare.rs

@@ -1,17 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use std::fmt::Debug;
-
 use vortex_array::accessor::ArrayAccessor;
-use vortex_array::arrays::BoolArray;
+use vortex_array::arrays::{BoolArray, NativeValue};
 use vortex_array::compute::{Operator, scalar_cmp};
 use vortex_array::validity::Validity;
 use vortex_array::{Array, ArrayRef, IntoArray, ToCanonical};
 use vortex_buffer::BitBuffer;
-use vortex_dtype::{
-    DType, NativePType, Nullability, match_each_decimal_value_type, match_each_native_ptype,
-};
+use vortex_dtype::{DType, Nullability, match_each_decimal_value_type, match_each_native_ptype};
 use vortex_error::{VortexExpect, VortexResult, vortex_err};
 use vortex_scalar::Scalar;
 
@@ -55,14 +51,14 @@ pub fn compare_canonical_array(
                 let pval = primitive
                     .typed_value::<P>()
                     .vortex_expect("nulls handled before");
-                Ok(compare_native_ptype(
+                Ok(compare_to(
                     primitive_array
                         .as_slice::<P>()
                         .iter()
                         .copied()
                         .zip(array.validity_mask().to_bit_buffer().iter())
-                        .map(|(b, v)| v.then_some(b)),
-                    pval,
+                        .map(|(b, v)| v.then_some(NativeValue(b))),
+                    NativeValue(pval),
                     operator,
                     result_nullability,
                 ))
@@ -157,30 +153,3 @@ fn compare_to<T: PartialOrd>(
         BoolArray::from_iter(values.map(|val| val.map(eval_fn))).into_array()
     }
 }
-
-fn compare_native_ptype<T: NativePType>(
-    values: impl Iterator<Item = Option<T>>,
-    cmp_value: T,
-    operator: Operator,
-    nullability: Nullability,
-) -> ArrayRef {
-    let eval_fn = |v: T| match operator {
-        Operator::Eq => v.is_eq(cmp_value),
-        Operator::NotEq => !v.is_eq(cmp_value),
-        Operator::Gt => v.is_gt(cmp_value),
-        Operator::Gte => v.is_ge(cmp_value),
-        Operator::Lt => v.is_lt(cmp_value),
-        Operator::Lte => v.is_le(cmp_value),
-    };
-
-    if !nullability.is_nullable() {
-        BoolArray::from_iter(
-            values
-                .map(|val| val.vortex_expect("non nullable"))
-                .map(eval_fn),
-        )
-        .into_array()
-    } else {
-        BoolArray::from_iter(values.map(|val| val.map(eval_fn))).into_array()
-    }
-}

vortex-array/src/arrays/primitive/native_value.rs

@@ -1,9 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::cmp::Ordering;
+
 use vortex_dtype::{NativePType, half};
 
-/// NativeValue serves as a wrapper type to allow us to implement Hash and Eq on all primitive types.
+/// NativeValue serves as a wrapper type to allow us to implement Hash, Eq and other traits on all primitive types.
 ///
 /// Rust does not define Hash/Eq for any of the float types due to the presence of
 /// NaN and +/- 0. We don't care about storing multiple NaNs or zeros in our dictionaries,
@@ -30,6 +32,12 @@ macro_rules! prim_value {
     };
 }
 
+impl<T: NativePType> PartialOrd<NativeValue<T>> for NativeValue<T> {
+    fn partial_cmp(&self, other: &NativeValue<T>) -> Option<Ordering> {
+        Some(self.0.total_compare(other.0))
+    }
+}
+
 macro_rules! float_value {
     ($typ:ty) => {
         impl core::hash::Hash for NativeValue<$typ> {