feat(spark): implement StringView for SparkConcat (apache#19984)

## Which issue does this PR close?

<!--
We generally require a GitHub issue to be filed for all bug fixes and
enhancements and this helps us generate change logs for our releases.
You can link an issue to this PR using the GitHub syntax. For example
`Closes apache#123` indicates that this PR will close issue apache#123.
-->

- This PR is part of the [Utf8View
support](apache#10918) epic. It
adds `Utf8View` support in the Spark-compat layer.

## Rationale for this change

In our internal project we're only suppporting `Utf8View` _(because of
design constraints)_ and the current implementation of `SparkConcat`
only supports `Utf8`. The `SparkConcat` function should accept
`Utf8View` and mixed string types in line with the main DataFusion
concat. This PR adds that support and follows the same patterns as
[DataFusion’s
concat](https://github.com/apache/datafusion/blob/main/datafusion/functions/src/string/concat.rs).

Prevents errors like : 

> The type of Utf8 AND Utf8View of like physical should be same.
> This issue was likely caused by a bug in DataFusion's code. Please
help us to resolve this by filing a bug report in our issue tracker:
https://github.com/apache/datafusion/issues

from a query like:-

```sql
select i_item_sk,
       item_info
from
  (select i_item_sk,
          CONCAT('Item: ', i_item_desc) as item_info
   from item) sub
where item_info LIKE 'Item: Electronic%'
order by 1;
```

 

## What changes are included in this PR?

- Extend the type signature to accept `Utf8View` in addition to `Utf8`
and `LargeUtf8` via `TypeSignature::Variadic(vec![Utf8View, Utf8,
LargeUtf8])` matching DataFusion’s concat.

- In `return_field_from_args`, compute the result type with precedence
Utf8View &gt; LargeUtf8 &gt; Utf8.
In spark_concat, handle Utf8View and LargeUtf8 in scalar paths
(zero-argument and all-NULL).


## Are these changes tested?

Yes.
- Unit tests: `cargo test --package datafusion-spark
function::string::concat::tests`, including `test_concat_utf8view`.
- Sqllogictest: `spark/string/concat.slt` includes a “**Utf8View: no
extra CAST in plan**” case that uses EXPLAIN and a temporary table to
ensure no extra CASTs when using arrow_cast(..., 'Utf8View') with table
columns.

## Are there any user-facing changes?

- **API:** SparkConcat’s signature is extended to include Utf8View in
the variadic list. No breaking changes.

_used gpt to rephrase some of these points_

Author: aryan-212

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

@@ -89,10 +89,21 @@ impl ScalarUDFImpl for SparkConcat {
         )
     }
     fn return_field_from_args(&self, args: ReturnFieldArgs<'_>) -> Result<FieldRef> {
+        use DataType::*;
+
         // Spark semantics: concat returns NULL if ANY input is NULL
         let nullable = args.arg_fields.iter().any(|f| f.is_nullable());
 
-        Ok(Arc::new(Field::new("concat", DataType::Utf8, nullable)))
+        // Determine return type: Utf8View > LargeUtf8 > Utf8
+        let mut dt = &Utf8;
+        for field in args.arg_fields {
+            let data_type = field.data_type();
+            if data_type == &Utf8View || (data_type == &LargeUtf8 && dt != &Utf8View) {
+                dt = data_type;
+            }
+        }
+
+        Ok(Arc::new(Field::new("concat", dt.clone(), nullable)))
     }
 }
 
@@ -110,17 +121,33 @@ fn spark_concat(args: ScalarFunctionArgs) -> Result<ColumnarValue> {
 
     // Handle zero-argument case: return empty string
     if arg_values.is_empty() {
-        return Ok(ColumnarValue::Scalar(ScalarValue::Utf8(
-            Some(String::new()),
-        )));
+        let return_type = return_field.data_type();
+        return match return_type {
+            DataType::Utf8View => Ok(ColumnarValue::Scalar(ScalarValue::Utf8View(Some(
+                String::new(),
+            )))),
+            DataType::LargeUtf8 => Ok(ColumnarValue::Scalar(ScalarValue::LargeUtf8(
+                Some(String::new()),
+            ))),
+            _ => Ok(ColumnarValue::Scalar(ScalarValue::Utf8(
+                Some(String::new()),
+            ))),
+        };
     }
 
     // Step 1: Check for NULL mask in incoming args
     let null_mask = compute_null_mask(&arg_values, number_rows)?;
 
     // If all scalars and any is NULL, return NULL immediately
     if matches!(null_mask, NullMaskResolution::ReturnNull) {
-        return Ok(ColumnarValue::Scalar(ScalarValue::Utf8(None)));
+        let return_type = return_field.data_type();
+        return match return_type {
+            DataType::Utf8View => Ok(ColumnarValue::Scalar(ScalarValue::Utf8View(None))),
+            DataType::LargeUtf8 => {
+                Ok(ColumnarValue::Scalar(ScalarValue::LargeUtf8(None)))
+            }
+            _ => Ok(ColumnarValue::Scalar(ScalarValue::Utf8(None))),
+        };
     }
 
     // Step 2: Delegate to DataFusion's concat
@@ -181,6 +208,7 @@ mod tests {
         );
         Ok(())
     }
+
     #[test]
     fn test_spark_concat_return_field_non_nullable() -> Result<()> {
         let func = SparkConcat::new();

datafusion/sqllogictest/test_files/spark/string/concat.slt

@@ -20,6 +20,12 @@ SELECT concat('Spark', 'SQL');
 ----
 SparkSQL
 
+# Test two Utf8View inputs: value and return type
+query TT
+SELECT concat(arrow_cast('Spark', 'Utf8View'), arrow_cast('SQL', 'Utf8View')), arrow_typeof(concat(arrow_cast('Spark', 'Utf8View'), arrow_cast('SQL', 'Utf8View')));
+----
+SparkSQL Utf8View
+
 query T
 SELECT concat('Spark', 'SQL', NULL);
 ----
@@ -46,3 +52,21 @@ SELECT concat(a, b, c) from (select 'a' a, 'b' b, 'c' c union all select null a,
 ----
 abc
 NULL
+
+# Test mixed types: Utf8View + Utf8
+query TT
+SELECT concat(arrow_cast('hello', 'Utf8View'), ' world'), arrow_typeof(concat(arrow_cast('hello', 'Utf8View'), ' world'));
+----
+hello world Utf8View
+
+# Test Utf8 + LargeUtf8 => return type LargeUtf8
+query TT
+SELECT concat('a', arrow_cast('b', 'LargeUtf8')), arrow_typeof(concat('a', arrow_cast('b', 'LargeUtf8')));
+----
+ab LargeUtf8
+
+# Test all three types mixed together
+query TT
+SELECT concat('a', arrow_cast('b', 'LargeUtf8'), arrow_cast('c', 'Utf8View')), arrow_typeof(concat('a', arrow_cast('b', 'LargeUtf8'), arrow_cast('c', 'Utf8View')));
+----
+abc Utf8View