feat(aggregate): simplify min/max helper and enhance testing for Dictionary(Int8, Utf8)

- Removed redundant `dictionary_inner_scalar_min_max` helper and invoked `min_max_scalar(...)` directly in the dictionary match arms to streamline code.
- Added end-to-end aggregate test for `Dictionary(Int8, Utf8)` via `test_min_max_dictionary_int8_keys`.
- Introduced a generic test helper for building string dictionaries with various key types, reducing setup duplication.

Author: kosiew

datafusion/functions-aggregate-common/src/min_max.rs

@@ -428,26 +428,15 @@ macro_rules! min_max_scalar_impl {
                     );
                 }
 
-                let result = dictionary_inner_scalar_min_max(
-                    lhs.as_ref(),
-                    rhs.as_ref(),
-                    choose_min_max!($OP),
-                )?;
+                let result =
+                    min_max_scalar(lhs.as_ref(), rhs.as_ref(), choose_min_max!($OP))?;
                 ScalarValue::Dictionary(lhs_key_type.clone(), Box::new(result))
             }
             (ScalarValue::Dictionary(_, lhs), rhs) => {
-                dictionary_inner_scalar_min_max(
-                    lhs.as_ref(),
-                    rhs,
-                    choose_min_max!($OP),
-                )?
+                min_max_scalar(lhs.as_ref(), rhs, choose_min_max!($OP))?
             }
             (lhs, ScalarValue::Dictionary(_, rhs)) => {
-                dictionary_inner_scalar_min_max(
-                    lhs,
-                    rhs.as_ref(),
-                    choose_min_max!($OP),
-                )?
+                min_max_scalar(lhs, rhs.as_ref(), choose_min_max!($OP))?
             }
 
             e => {
@@ -510,14 +499,6 @@ fn min_max_batch_generic(values: &ArrayRef, ordering: Ordering) -> Result<Scalar
     Ok(extreme)
 }
 
-fn dictionary_inner_scalar_min_max(
-    lhs: &ScalarValue,
-    rhs: &ScalarValue,
-    ordering: Ordering,
-) -> Result<ScalarValue> {
-    min_max_scalar(lhs, rhs, ordering)
-}
-
 /// An accumulator to compute the maximum value
 #[derive(Debug, Clone)]
 pub struct MaxAccumulator {

datafusion/functions-aggregate/src/min_max.rs

@@ -1004,12 +1004,13 @@ mod tests {
     use super::*;
     use arrow::{
         array::{
-            DictionaryArray, Float32Array, Int32Array, IntervalDayTimeArray,
-            IntervalMonthDayNanoArray, IntervalYearMonthArray, StringArray,
+            Array, DictionaryArray, Float32Array, Int32Array, Int8Array,
+            IntervalDayTimeArray, IntervalMonthDayNanoArray, PrimitiveArray,
+            IntervalYearMonthArray, StringArray,
         },
         datatypes::{
-            IntervalDayTimeType, IntervalMonthDayNanoType, IntervalUnit,
-            IntervalYearMonthType,
+            ArrowDictionaryKeyType, IntervalDayTimeType, IntervalMonthDayNanoType,
+            IntervalUnit, IntervalYearMonthType,
         },
     };
     use std::sync::Arc;
@@ -1272,10 +1273,18 @@ mod tests {
     }
 
     fn string_dictionary_batch(values: &[&str], keys: &[Option<i32>]) -> ArrayRef {
+        string_dictionary_batch_with_keys(Int32Array::from(keys.to_vec()), values)
+    }
+
+    fn string_dictionary_batch_with_keys<K>(
+        keys: PrimitiveArray<K>,
+        values: &[&str],
+    ) -> ArrayRef
+    where
+        K: ArrowDictionaryKeyType,
+    {
         let values = Arc::new(StringArray::from(values.to_vec())) as ArrayRef;
-        Arc::new(
-            DictionaryArray::try_new(Int32Array::from(keys.to_vec()), values).unwrap(),
-        ) as ArrayRef
+        Arc::new(DictionaryArray::try_new(keys, values).unwrap()) as ArrayRef
     }
 
     fn optional_string_dictionary_batch(
@@ -1383,6 +1392,18 @@ mod tests {
         assert_dictionary_min_max(&dict_type, &[batch1, batch2], "a", "d")
     }
 
+    #[test]
+    fn test_min_max_dictionary_int8_keys() -> Result<()> {
+        let dict_type =
+            DataType::Dictionary(Box::new(DataType::Int8), Box::new(DataType::Utf8));
+        let dict_array_ref = string_dictionary_batch_with_keys(
+            Int8Array::from(vec![Some(0), Some(1), Some(2), Some(3)]),
+            &["b", "c", "a", "d"],
+        );
+
+        assert_dictionary_min_max(&dict_type, &[dict_array_ref], "a", "d")
+    }
+
     #[test]
     fn test_min_max_dictionary_float_with_nans() -> Result<()> {
         let dict_type =