fix: Avoid unnecessary type casts in concat_ws (apache#20436)

## Which issue does this PR close?

- Closes apache#20434.

## Rationale for this change

1. `concat_ws` returned `Utf8`, regardless of the input types it was
called with. If it was called with `LargeUtf8`, returning `Utf8` might
overflow. In general, functions like these should operate on all three
string representations unless there is a compelling reason not to (e.g.,
this is how `concat` works).
4. `simplify_concat_ws` always constructed new literals with type
`Utf8`. This lead to unnecessary casts when its inputs were of a
different string type.

## What changes are included in this PR?

* Support `concat_ws` return type matching its input types, following
how `concat` does it.
* In `simplify_concat_ws`, construct literals with the right type, not
always `Utf8`
* Refactor `return_type` for `concat` to be more readable
* Make `StringViewArrayBuilder` API more similar to the other string
array builders, WRT null handling
* Add new unit and SLT tests
* Update test output for changed types

## Are these changes tested?

Yes.

## Are there any user-facing changes?

Yes: some queries involving `concat_ws` will now omit unnecessary cast
operations, and the return type of `concat_ws` might be any of the three
string types. Generally these changes should match user expectations
better than the previous behavior.

Author: neilconway

datafusion/functions/src/string/concat.rs

@@ -88,37 +88,33 @@ impl ScalarUDFImpl for ConcatFunc {
         &self.signature
     }
 
+    /// Match the return type to the input types to avoid unnecessary casts. On
+    /// mixed inputs, prefer Utf8View; prefer LargeUtf8 over Utf8 to avoid
+    /// potential overflow on LargeUtf8 input.
     fn return_type(&self, arg_types: &[DataType]) -> Result<DataType> {
         use DataType::*;
-        let mut dt = &Utf8;
-        arg_types.iter().for_each(|data_type| {
-            if data_type == &Utf8View {
-                dt = data_type;
-            }
-            if data_type == &LargeUtf8 && dt != &Utf8View {
-                dt = data_type;
-            }
-        });
-
-        Ok(dt.to_owned())
+        if arg_types.contains(&Utf8View) {
+            Ok(Utf8View)
+        } else if arg_types.contains(&LargeUtf8) {
+            Ok(LargeUtf8)
+        } else {
+            Ok(Utf8)
+        }
     }
 
     /// Concatenates the text representations of all the arguments. NULL arguments are ignored.
     /// concat('abcde', 2, NULL, 22) = 'abcde222'
     fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result<ColumnarValue> {
         let ScalarFunctionArgs { args, .. } = args;
 
-        let mut return_datatype = DataType::Utf8;
-        args.iter().for_each(|col| {
-            if col.data_type() == DataType::Utf8View {
-                return_datatype = col.data_type();
-            }
-            if col.data_type() == DataType::LargeUtf8
-                && return_datatype != DataType::Utf8View
-            {
-                return_datatype = col.data_type();
-            }
-        });
+        let return_datatype = if args.iter().any(|c| c.data_type() == DataType::Utf8View)
+        {
+            DataType::Utf8View
+        } else if args.iter().any(|c| c.data_type() == DataType::LargeUtf8) {
+            DataType::LargeUtf8
+        } else {
+            DataType::Utf8
+        };
 
         let array_len = args.iter().find_map(|x| match x {
             ColumnarValue::Array(array) => Some(array.len()),
@@ -247,7 +243,7 @@ impl ScalarUDFImpl for ConcatFunc {
                     builder.append_offset();
                 }
 
-                let string_array = builder.finish();
+                let string_array = builder.finish(None);
                 Ok(ColumnarValue::Array(Arc::new(string_array)))
             }
             DataType::LargeUtf8 => {