ScalarUDF: Remove supports_zero_argument and avoid creating null array for empty args

datafusion/core/tests/user_defined/user_defined_scalar_functions.rs

@@ -434,15 +434,10 @@ impl ScalarUDFImpl for RandomUDF {
     }
 
     fn invoke(&self, args: &[ColumnarValue]) -> Result<ColumnarValue> {
-        let len: usize = match &args[0] {
-            // This udf is always invoked with zero argument so its argument
-            // is a null array indicating the batch size.
-            ColumnarValue::Array(array) if array.data_type().is_null() => array.len(),
-            _ => {
-                return Err(datafusion::error::DataFusionError::Internal(
-                    "Invalid argument type".to_string(),
-                ))
-            }
+        let len = if args.is_empty() {
+            1
+        } else {
+            return internal_err!("Invalid argument type");
         };
         let mut rng = thread_rng();
         let values = iter::repeat_with(|| rng.gen_range(0.1..1.0)).take(len);

datafusion/functions/src/math/pi.rs

@@ -63,9 +63,10 @@ impl ScalarUDFImpl for PiFunc {
     }
 
     fn invoke(&self, args: &[ColumnarValue]) -> Result<ColumnarValue> {
-        if !matches!(&args[0], ColumnarValue::Array(_)) {
-            return exec_err!("Expect pi function to take no param");
-        }
+        if !args.is_empty() {
+            return exec_err!("Expect {} function to take no param", self.name());
+        };
+
         let array = Float64Array::from_value(std::f64::consts::PI, 1);
         Ok(ColumnarValue::Array(Arc::new(array)))
     }

datafusion/functions/src/math/random.rs

@@ -69,12 +69,13 @@ impl ScalarUDFImpl for RandomFunc {
     }
 }
 
-/// Random SQL function
 fn random(args: &[ColumnarValue]) -> Result<ColumnarValue> {
-    let len: usize = match &args[0] {
-        ColumnarValue::Array(array) => array.len(),
-        _ => return exec_err!("Expect random function to take no param"),
+    let len = if args.is_empty() {
+        1
+    } else {
+        return exec_err!("Expect random function to take no param");
     };
+
     let mut rng = thread_rng();
     let values = iter::repeat_with(|| rng.gen_range(0.0..1.0)).take(len);
     let array = Float64Array::from_iter_values(values);
@@ -83,19 +84,13 @@ fn random(args: &[ColumnarValue]) -> Result<ColumnarValue> {
 
 #[cfg(test)]
 mod test {
-    use std::sync::Arc;
-
-    use arrow::array::NullArray;
-
     use datafusion_common::cast::as_float64_array;
-    use datafusion_expr::ColumnarValue;
 
-    use crate::math::random::random;
+    use super::*;
 
     #[test]
     fn test_random_expression() {
-        let args = vec![ColumnarValue::Array(Arc::new(NullArray::new(1)))];
-        let array = random(&args)
+        let array = random(&[])
             .expect("failed to initialize function random")
             .into_array(1)
             .expect("Failed to convert to array");

datafusion/functions/src/string/uuid.rs

@@ -61,9 +61,10 @@ impl ScalarUDFImpl for UuidFunc {
     /// Prints random (v4) uuid values per row
     /// uuid() = 'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'
     fn invoke(&self, args: &[ColumnarValue]) -> Result<ColumnarValue> {
-        let len: usize = match &args[0] {
-            ColumnarValue::Array(array) => array.len(),
-            _ => return exec_err!("Expect uuid function to take no param"),
+        let len = if args.is_empty() {
+            1
+        } else {
+            return exec_err!("Expect {} function to take no param", self.name());
         };
 
         let values = iter::repeat_with(|| Uuid::new_v4().to_string()).take(len);

datafusion/physical-expr/src/scalar_function.rs

@@ -142,21 +142,11 @@ impl PhysicalExpr for ScalarFunctionExpr {
     }
 
     fn evaluate(&self, batch: &RecordBatch) -> Result<ColumnarValue> {
-        // evaluate the arguments, if there are no arguments we'll instead pass in a null array
-        // indicating the batch size (as a convention)
-        let inputs = match self.args.is_empty() {
-            // If the function supports zero argument, we pass in a null array indicating the batch size.
-            // This is for user-defined functions.
-            // MakeArray support zero argument but has the different behavior from the array with one null.
-            true if self.supports_zero_argument && self.name != "make_array" => {
-                vec![ColumnarValue::create_null_array(batch.num_rows())]
-            }
-            _ => self
-                .args
-                .iter()
-                .map(|e| e.evaluate(batch))
-                .collect::<Result<Vec<_>>>()?,
-        };
+        let inputs = self
+            .args
+            .iter()
+            .map(|e| e.evaluate(batch))
+            .collect::<Result<Vec<_>>>()?;
 
         // evaluate the function
         match self.fun {