fix[array]: min_max return type non nullable

Signed-off-by: Joe Isaacs <[email protected]>

Author: joseph-isaacs

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

@@ -2,10 +2,11 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use itertools::Itertools;
-use vortex_dtype::{DType, NativeDecimalType};
+use vortex_dtype::Nullability::NonNullable;
+use vortex_dtype::{DecimalDType, NativeDecimalType};
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
-use vortex_scalar::{DecimalValue, Scalar, ScalarValue, match_each_decimal_value_type};
+use vortex_scalar::{DecimalValue, Scalar, match_each_decimal_value_type};
 
 use crate::arrays::{DecimalArray, DecimalVTable};
 use crate::compute::{MinMaxKernel, MinMaxKernelAdapter, MinMaxResult};
@@ -27,36 +28,38 @@ where
     D: Into<DecimalValue> + NativeDecimalType,
 {
     Ok(match array.validity_mask() {
-        Mask::AllTrue(_) => compute_min_max(array.buffer::<D>().iter(), array.dtype()),
+        Mask::AllTrue(_) => compute_min_max(array.buffer::<D>().iter(), array.decimal_dtype()),
         Mask::AllFalse(_) => None,
         Mask::Values(v) => compute_min_max(
             array
                 .buffer::<D>()
                 .iter()
                 .zip(v.bit_buffer().iter())
                 .filter_map(|(v, m)| m.then_some(v)),
-            array.dtype(),
+            array.decimal_dtype(),
         ),
     })
 }
 
-fn compute_min_max<'a, T>(iter: impl Iterator<Item = &'a T>, dtype: &DType) -> Option<MinMaxResult>
+fn compute_min_max<'a, T>(
+    iter: impl Iterator<Item = &'a T>,
+    decimal_dtype: DecimalDType,
+) -> Option<MinMaxResult>
 where
     T: Into<DecimalValue> + NativeDecimalType + Ord + Copy + 'a,
 {
-    let non_nullable_dtype = dtype.as_nonnullable();
     match iter.minmax_by(|a, b| a.cmp(b)) {
         itertools::MinMaxResult::NoElements => None,
         itertools::MinMaxResult::OneElement(&x) => {
-            let scalar = Scalar::new(non_nullable_dtype, ScalarValue::from(x.into()));
+            let scalar = Scalar::decimal(x.into(), decimal_dtype, NonNullable);
             Some(MinMaxResult {
                 min: scalar.clone(),
                 max: scalar,
             })
         }
         itertools::MinMaxResult::MinMax(&min, &max) => Some(MinMaxResult {
-            min: Scalar::new(non_nullable_dtype.clone(), ScalarValue::from(min.into())),
-            max: Scalar::new(non_nullable_dtype, ScalarValue::from(max.into())),
+            min: Scalar::decimal(min.into(), decimal_dtype, NonNullable),
+            max: Scalar::decimal(max.into(), decimal_dtype, NonNullable),
         }),
     }
 }

vortex-array/src/arrays/primitive/compute/min_max.rs

@@ -3,10 +3,10 @@
 
 use itertools::Itertools;
 use vortex_dtype::Nullability::NonNullable;
-use vortex_dtype::{DType, NativePType, match_each_native_ptype};
+use vortex_dtype::{NativePType, match_each_native_ptype};
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
-use vortex_scalar::{PValue, Scalar, ScalarValue};
+use vortex_scalar::{PValue, Scalar};
 
 use crate::arrays::{PrimitiveArray, PrimitiveVTable};
 use crate::compute::{MinMaxKernel, MinMaxKernelAdapter, MinMaxResult};
@@ -29,20 +29,19 @@ where
     PValue: From<T>,
 {
     Ok(match array.validity_mask() {
-        Mask::AllTrue(_) => compute_min_max(array.as_slice::<T>().iter(), array.dtype()),
+        Mask::AllTrue(_) => compute_min_max(array.as_slice::<T>().iter()),
         Mask::AllFalse(_) => None,
         Mask::Values(v) => compute_min_max(
             array
                 .as_slice::<T>()
                 .iter()
                 .zip(v.bit_buffer().iter())
                 .filter_map(|(v, m)| m.then_some(v)),
-            array.dtype(),
         ),
     })
 }
 
-fn compute_min_max<'a, T>(iter: impl Iterator<Item = &'a T>, dtype: &DType) -> Option<MinMaxResult>
+fn compute_min_max<'a, T>(iter: impl Iterator<Item = &'a T>) -> Option<MinMaxResult>
 where
     T: NativePType,
     PValue: From<T>,