Fix: SparkAscii nullability to depend on input nullability (#19531)

Closes #19169 

## Rationale for this change:

The current implementation of `SparkAscii` UDF uses the default
`is_nullable` which always returns true. This is incorrect because the
output should only be nullable if the input argument is nullable. This
change implements proper null propagation behavior by using
`return_field_from_args` .

## Changes in PR:

- Implemented return_field_from_args for SparkAscii to properly compute
output nullability based on input argument nullability
- Changed `return_type` to `return internal_err!` since
`return_field_from_args` is now used (following the pattern used by
other Spark functions like ilike, concat, elt)
- Added unit tests verifying the nullability behavior:
   - Output is nullable when input is nullable
   - Output is non-nullable when input is non-nullable

## Test Coverage:

Yes, tests are included to verify the change.

## User-facing Changes:

No user-facing changes.

Co-authored-by: Jefffrey <[email protected]>

Author: Yuvraj-cyborg

datafusion/spark/src/function/string/ascii.rs

@@ -15,13 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use arrow::datatypes::DataType;
-use datafusion_common::Result;
+use std::sync::Arc;
+
+use arrow::datatypes::{DataType, Field, FieldRef};
 use datafusion_common::types::{NativeType, logical_string};
-use datafusion_expr::ColumnarValue;
+use datafusion_common::{Result, internal_err};
 use datafusion_expr::{
-    Coercion, ScalarFunctionArgs, ScalarUDFImpl, Signature, TypeSignatureClass,
-    Volatility,
+    Coercion, ColumnarValue, ReturnFieldArgs, ScalarFunctionArgs, ScalarUDFImpl,
+    Signature, TypeSignatureClass, Volatility,
 };
 use datafusion_functions::string::ascii::ascii;
 use datafusion_functions::utils::make_scalar_function;
@@ -75,10 +76,61 @@ impl ScalarUDFImpl for SparkAscii {
     }
 
     fn return_type(&self, _arg_types: &[DataType]) -> Result<DataType> {
-        Ok(DataType::Int32)
+        internal_err!("return_field_from_args should be used instead")
+    }
+
+    fn return_field_from_args(&self, args: ReturnFieldArgs) -> Result<FieldRef> {
+        // ascii returns an Int32 value
+        // The result is nullable only if any of the input arguments is nullable
+        let nullable = args.arg_fields.iter().any(|f| f.is_nullable());
+        Ok(Arc::new(Field::new("ascii", DataType::Int32, nullable)))
     }
 
     fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result<ColumnarValue> {
         make_scalar_function(ascii, vec![])(&args.args)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use datafusion_expr::ReturnFieldArgs;
+
+    #[test]
+    fn test_return_field_nullable_input() {
+        let ascii_func = SparkAscii::new();
+        let nullable_field = Arc::new(Field::new("input", DataType::Utf8, true));
+
+        let result = ascii_func
+            .return_field_from_args(ReturnFieldArgs {
+                arg_fields: &[nullable_field],
+                scalar_arguments: &[],
+            })
+            .unwrap();
+
+        assert_eq!(result.data_type(), &DataType::Int32);
+        assert!(
+            result.is_nullable(),
+            "Output should be nullable when input is nullable"
+        );
+    }
+
+    #[test]
+    fn test_return_field_non_nullable_input() {
+        let ascii_func = SparkAscii::new();
+        let non_nullable_field = Arc::new(Field::new("input", DataType::Utf8, false));
+
+        let result = ascii_func
+            .return_field_from_args(ReturnFieldArgs {
+                arg_fields: &[non_nullable_field],
+                scalar_arguments: &[],
+            })
+            .unwrap();
+
+        assert_eq!(result.data_type(), &DataType::Int32);
+        assert!(
+            !result.is_nullable(),
+            "Output should not be nullable when input is not nullable"
+        );
+    }
+}