Addressing review comments

datafusion/functions-aggregate/src/min_max.rs

@@ -531,7 +531,7 @@ macro_rules! min_max_batch {
 }
 
 /// dynamically-typed min(array) -> ScalarValue
-fn min_batch(values: &ArrayRef) -> Result<ScalarValue> {
+pub fn min_batch(values: &ArrayRef) -> Result<ScalarValue> {
     Ok(match values.data_type() {
         DataType::Utf8 => {
             typed_min_max_batch_string!(values, StringArray, Utf8, min_string)

datafusion/functions-nested/src/min.rs

@@ -17,18 +17,18 @@
 
 //! [`ScalarUDFImpl`] definitions for array_min function.
 
-use crate::sort::array_sort_inner;
 use crate::utils::make_scalar_function;
-use arrow_array::{Array, ArrayRef, StringArray};
+use arrow_array::ArrayRef;
 use arrow_schema::DataType;
 use arrow_schema::DataType::{FixedSizeList, LargeList, List};
 use datafusion_common::cast::as_list_array;
 use datafusion_common::exec_err;
 use datafusion_doc::Documentation;
 use datafusion_expr::{ColumnarValue, ScalarUDFImpl, Signature, Volatility};
+use datafusion_functions::utils::take_function_args;
+use datafusion_functions_aggregate::min_max;
 use datafusion_macros::user_doc;
 use std::any::Any;
-use std::sync::Arc;
 
 make_udf_expr_and_func!(
     ArrayMin,
@@ -125,29 +125,14 @@ impl ScalarUDFImpl for ArrayMin {
 /// For example:
 /// > array_min(\[3, 1, 2]) -> 1
 pub fn array_min_inner(args: &[ArrayRef]) -> datafusion_common::Result<ArrayRef> {
-    if args.len() != 1 {
-        return exec_err!("array_min needs one argument");
-    }
+    let [arg1] = take_function_args("array_min", args)?;
 
-    match &args[0].data_type() {
+    match &arg1.data_type() {
         List(_) | LargeList(_) | FixedSizeList(_, _) => {
-            let new_args = vec![
-                Arc::<dyn Array>::clone(&args[0]),
-                Arc::new(StringArray::from_iter(vec![Some("ASC")])),
-                Arc::new(StringArray::from_iter(vec![Some("NULLS LAST")])),
-            ];
-            array_min_internal(&new_args)
+            let input_array = as_list_array(&arg1)?.value(0);
+            let min_result = min_max::min_batch(&input_array);
+            min_result?.to_array()
         }
         _ => exec_err!("array_min does not support type: {:?}", args[0].data_type()),
     }
 }
-
-fn array_min_internal(args: &[ArrayRef]) -> datafusion_common::Result<ArrayRef> {
-    let sorted_array = array_sort_inner(args)?;
-    let result_array = as_list_array(&sorted_array)?.value(0);
-    if result_array.is_empty() {
-        return exec_err!("array_min needs one argument as non-empty array");
-    }
-    let min_result = result_array.slice(0, 1);
-    Ok(min_result)
-}

datafusion/sqllogictest/test_files/array.slt

@@ -1485,13 +1485,24 @@ select array_min(make_array(TIMESTAMP '1992-09-01', TIMESTAMP '1984-10-01', TIME
 ----
 1984-10-01T00:00:00
 
+query R
+select array_min(make_array(5.1, -3.2, 6.3, 4.9));
+----
+-3.2
+
 query P
 select array_min(make_array(NULL, TIMESTAMP '1996-10-01', TIMESTAMP '1995-06-01'));
 ----
 1995-06-01T00:00:00
 
-query error Execution error: array_min needs one argument as non-empty array
+query I
 select array_min(make_array());
+----
+NULL
+
+# Testing with empty arguments should result in an error
+query error DataFusion error: Error during planning: 'array_min' does not support zero arguments
+select array_min();
 
 ## array_pop_back (aliases: `list_pop_back`)