This is an automated email from the ASF dual-hosted git repository.

alamb pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/datafusion.git


The following commit(s) were added to refs/heads/main by this push:
     new f99f8da461 Fix CI in main (#15917)
f99f8da461 is described below

commit f99f8da4614fac33e6ddbec7df1cf2fd5b7f3560
Author: Dmitrii Blaginin <dmit...@blaginin.me>
AuthorDate: Fri May 2 12:15:45 2025 +0100

    Fix CI in main (#15917)
---
 datafusion/spark/src/function/utils.rs | 41 ++++++++++++++++++++--------------
 1 file changed, 24 insertions(+), 17 deletions(-)

diff --git a/datafusion/spark/src/function/utils.rs 
b/datafusion/spark/src/function/utils.rs
index b05e4acd20..57505170c2 100644
--- a/datafusion/spark/src/function/utils.rs
+++ b/datafusion/spark/src/function/utils.rs
@@ -28,7 +28,20 @@ pub mod test {
             let expected: datafusion_common::Result<Option<$EXPECTED_TYPE>> = 
$EXPECTED;
             let func = $FUNC;
 
-            let type_array = $ARGS.iter().map(|arg| 
arg.data_type()).collect::<Vec<_>>();
+            let arg_fields_owned = $ARGS
+                .iter()
+                .enumerate()
+                .map(|(idx, arg)| {
+
+                let nullable = match arg {
+                    datafusion_expr::ColumnarValue::Scalar(scalar) => 
scalar.is_null(),
+                    datafusion_expr::ColumnarValue::Array(a) => a.null_count() 
> 0,
+                };
+
+                arrow::datatypes::Field::new(format!("arg_{idx}"), 
arg.data_type(), nullable)
+            })
+                .collect::<Vec<_>>();
+
             let cardinality = $ARGS
                 .iter()
                 .fold(Option::<usize>::None, |acc, arg| match arg {
@@ -43,24 +56,18 @@ pub mod test {
             }).collect::<Vec<_>>();
             let scalar_arguments_refs = scalar_arguments.iter().map(|arg| 
arg.as_ref()).collect::<Vec<_>>();
 
-            let nullables = $ARGS.iter().map(|arg| match arg {
-                datafusion_expr::ColumnarValue::Scalar(scalar) => 
scalar.is_null(),
-                datafusion_expr::ColumnarValue::Array(a) => a.null_count() > 0,
-            }).collect::<Vec<_>>();
 
-            let return_info = 
func.return_type_from_args(datafusion_expr::ReturnTypeArgs {
-                arg_types: &type_array,
-                scalar_arguments: &scalar_arguments_refs,
-                nullables: &nullables
+            let return_field = 
func.return_field_from_args(datafusion_expr::ReturnFieldArgs {
+                arg_fields: &arg_fields_owned,
+                scalar_arguments: &scalar_arguments_refs
             });
 
             match expected {
                 Ok(expected) => {
-                    assert_eq!(return_info.is_ok(), true);
-                    let (return_type, _nullable) = 
return_info.unwrap().into_parts();
-                    assert_eq!(return_type, $EXPECTED_DATA_TYPE);
+                    let return_field = return_field.unwrap();
+                    assert_eq!(return_field.data_type(), &$EXPECTED_DATA_TYPE);
 
-                    let result = 
func.invoke_with_args(datafusion_expr::ScalarFunctionArgs{args: $ARGS, 
number_rows: cardinality, return_type: &return_type});
+                    let result = 
func.invoke_with_args(datafusion_expr::ScalarFunctionArgs{args: $ARGS, 
number_rows: cardinality, return_field: &return_field, arg_fields: 
arg_fields_owned.iter().collect()});
                     assert_eq!(result.is_ok(), true, "function returned an 
error: {}", result.unwrap_err());
 
                     let result = 
result.unwrap().to_array(cardinality).expect("Failed to convert to array");
@@ -74,17 +81,17 @@ pub mod test {
                     };
                 }
                 Err(expected_error) => {
-                    if return_info.is_err() {
-                        match return_info {
+                    if return_field.is_err() {
+                        match return_field {
                             Ok(_) => assert!(false, "expected error"),
                             Err(error) => { 
datafusion_common::assert_contains!(expected_error.strip_backtrace(), 
error.strip_backtrace()); }
                         }
                     }
                     else {
-                        let (return_type, _nullable) = 
return_info.unwrap().into_parts();
+                        let return_field = return_field.unwrap();
 
                         // invoke is expected error - cannot use .expect_err() 
due to Debug not being implemented
-                        match 
func.invoke_with_args(datafusion_expr::ScalarFunctionArgs{args: $ARGS, 
number_rows: cardinality, return_type: &return_type}) {
+                        match 
func.invoke_with_args(datafusion_expr::ScalarFunctionArgs{args: $ARGS, 
number_rows: cardinality,  return_field: &return_field, arg_fields: 
arg_fields_owned.iter().collect()}) {
                             Ok(_) => assert!(false, "expected error"),
                             Err(error) => {
                                 
assert!(expected_error.strip_backtrace().starts_with(&error.strip_backtrace()));


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscr...@datafusion.apache.org
For additional commands, e-mail: commits-h...@datafusion.apache.org

Reply via email to