Added support for min/max for decimal (#897)

src/compute/aggregate/min_max.rs

@@ -394,6 +394,7 @@ pub fn max(array: &dyn Array) -> Result<Box<dyn Scalar>> {
  DataType::Float16 => unreachable!(),
  DataType::Float32 => dyn_primitive!(f32, array, max_primitive),
  DataType::Float64 => dyn_primitive!(f64, array, max_primitive),
+ DataType::Decimal(_, _) => dyn_primitive!(i128, array, max_primitive),
  DataType::Utf8 => dyn_generic!(Utf8Array<i32>, Utf8Scalar<i32>, array, max_string),
  DataType::LargeUtf8 => dyn_generic!(Utf8Array<i64>, Utf8Scalar<i64>, array, max_string),
  DataType::Binary => dyn_generic!(BinaryArray<i32>, BinaryScalar<i32>, array, max_binary),
@@ -435,6 +436,7 @@ pub fn min(array: &dyn Array) -> Result<Box<dyn Scalar>> {
  DataType::Float16 => unreachable!(),
  DataType::Float32 => dyn_primitive!(f32, array, min_primitive),
  DataType::Float64 => dyn_primitive!(f64, array, min_primitive),
+ DataType::Decimal(_, _) => dyn_primitive!(i128, array, min_primitive),
  DataType::Utf8 => dyn_generic!(Utf8Array<i32>, Utf8Scalar<i32>, array, min_string),
  DataType::LargeUtf8 => dyn_generic!(Utf8Array<i64>, Utf8Scalar<i64>, array, min_string),
  DataType::Binary => dyn_generic!(BinaryArray<i32>, BinaryScalar<i32>, array, min_binary),

src/compute/aggregate/simd/mod.rs

@@ -1,3 +1,63 @@
+use super::SimdOrd;
+use crate::types::simd::{i128x8, NativeSimd};
+
+macro_rules! simd_ord_int {
+ ($simd:tt, $type:ty) => {
+ impl SimdOrd<$type> for $simd {
+ const MIN: $type = <$type>::MIN;
+ const MAX: $type = <$type>::MAX;
+
+ #[inline]
+ fn max_element(self) -> $type {
+ self.0.iter().copied().fold(Self::MIN, <$type>::max)
+ }
+
+ #[inline]
+ fn min_element(self) -> $type {
+ self.0.iter().copied().fold(Self::MAX, <$type>::min)
+ }
+
+ #[inline]
+ fn max_lane(self, x: Self) -> Self {
+ let mut result = <$simd>::default();
+ result
+ .0
+ .iter_mut()
+ .zip(self.0.iter())
+ .zip(x.0.iter())
+ .for_each(|((a, b), c)| *a = (*b).max(*c));
+ result
+ }
+
+ #[inline]
+ fn min_lane(self, x: Self) -> Self {
+ let mut result = <$simd>::default();
+ result
+ .0
+ .iter_mut()
+ .zip(self.0.iter())
+ .zip(x.0.iter())
+ .for_each(|((a, b), c)| *a = (*b).min(*c));
+ result
+ }
+
+ #[inline]
+ fn new_min() -> Self {
+ Self([Self::MAX; <$simd>::LANES])
+ }
+
+ #[inline]
+ fn new_max() -> Self {
+ Self([Self::MIN; <$simd>::LANES])
+ }
+ }
+ };
+}
+
+pub(super) use simd_ord_int;
+
+simd_ord_int!(i128x8, i128);
+
 #[cfg(not(feature = "simd"))]
 mod native;
 #[cfg(not(feature = "simd"))]

src/compute/aggregate/simd/native.rs

@@ -4,6 +4,7 @@ use crate::types::simd::*;
 
 use super::super::min_max::SimdOrd;
 use super::super::sum::Sum;
+use super::simd_ord_int;
 
 macro_rules! simd_add {
  ($simd:tt, $type:ty, $lanes:expr, $add:tt) => {
@@ -53,59 +54,6 @@ simd_add!(i64x8, i64, 8, wrapping_add);
 simd_add!(f32x16, f32, 16, add);
 simd_add!(f64x8, f64, 8, add);
 
-macro_rules! simd_ord_int {
- ($simd:tt, $type:ty) => {
- impl SimdOrd<$type> for $simd {
- const MIN: $type = <$type>::MIN;
- const MAX: $type = <$type>::MAX;
-
- #[inline]
- fn max_element(self) -> $type {
- self.0.iter().copied().fold(Self::MIN, <$type>::max)
- }
-
- #[inline]
- fn min_element(self) -> $type {
- self.0.iter().copied().fold(Self::MAX, <$type>::min)
- }
-
- #[inline]
- fn max_lane(self, x: Self) -> Self {
- let mut result = <$simd>::default();
- result
- .0
- .iter_mut()
- .zip(self.0.iter())
- .zip(x.0.iter())
- .for_each(|((a, b), c)| *a = (*b).max(*c));
- result
- }
-
- #[inline]
- fn min_lane(self, x: Self) -> Self {
- let mut result = <$simd>::default();
- result
- .0
- .iter_mut()
- .zip(self.0.iter())
- .zip(x.0.iter())
- .for_each(|((a, b), c)| *a = (*b).min(*c));
- result
- }
-
- #[inline]
- fn new_min() -> Self {
- Self([Self::MAX; <$simd>::LANES])
- }
-
- #[inline]
- fn new_max() -> Self {
- Self([Self::MIN; <$simd>::LANES])
- }
- }
- };
-}
-
 macro_rules! simd_ord_float {
  ($simd:tt, $type:ty) => {
  impl SimdOrd<$type> for $simd {

tests/it/compute/aggregate/min_max.rs

@@ -25,6 +25,13 @@ fn test_primitive_min_max_1() {
  assert_eq!(Some(5), max_primitive(&a));
 }
 
+#[test]
+fn decimal() {
+ let a = Int128Array::from(&[None, None, Some(5), Some(2)]);
+ assert_eq!(Some(2), min_primitive(&a));
+ assert_eq!(Some(5), max_primitive(&a));
+}
+
 #[test]
 fn min_max_f32() {
  let a = Float32Array::from(&[None, None, Some(5.0), Some(2.0)]);