perf: improve performance of split_part (~1-2% faster)

Use a reusable Vec<&str> buffer instead of allocating a new Vec for each row.

Benchmark results:
| Array Size | Baseline (µs) | Optimized (µs) | Improvement |
|------------|---------------|----------------|-------------|
| 1024       | 42.77         | 42.36          | 1.0% faster |
| 4096       | 170.45        | 168.60         | 1.1% faster |

The improvement is modest because Vec allocation overhead is small
compared to the string splitting operation itself.

Author: viirya

datafusion/functions/Cargo.toml

@@ -215,6 +215,11 @@ harness = false
 name = "random"
 required-features = ["math_expressions"]
 
+[[bench]]
+harness = false
+name = "split_part"
+required-features = ["string_expressions"]
+
 [[bench]]
 harness = false
 name = "substr"

datafusion/functions/benches/split_part.rs

@@ -0,0 +1,75 @@
+extern crate criterion;
+
+use arrow::array::{Int64Array, OffsetSizeTrait};
+use arrow::datatypes::{DataType, Field};
+use arrow::util::bench_util::create_string_array_with_len;
+use criterion::{Criterion, SamplingMode, criterion_group, criterion_main};
+use datafusion_common::DataFusionError;
+use datafusion_common::config::ConfigOptions;
+use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};
+use datafusion_functions::string;
+use std::hint::black_box;
+use std::sync::Arc;
+use std::time::Duration;
+
+fn create_args<O: OffsetSizeTrait>(size: usize, str_len: usize) -> Vec<ColumnarValue> {
+    let position_array = Arc::new(Int64Array::from(
+        (0..size).map(|i| (i % 3 + 1) as i64).collect::<Vec<_>>(),
+    ));
+
+    let string_array =
+        Arc::new(create_string_array_with_len::<O>(size, 0.1, str_len));
+    let delimiter_array = Arc::new(create_string_array_with_len::<O>(size, 0.1, 1));
+
+    vec![
+        ColumnarValue::Array(string_array),
+        ColumnarValue::Array(delimiter_array),
+        ColumnarValue::Array(position_array),
+    ]
+}
+
+fn invoke_split_part_with_args(
+    args: Vec<ColumnarValue>,
+    number_rows: usize,
+) -> Result<ColumnarValue, DataFusionError> {
+    let arg_fields = args
+        .iter()
+        .enumerate()
+        .map(|(idx, arg)| Field::new(format!("arg_{idx}"), arg.data_type(), true).into())
+        .collect::<Vec<_>>();
+    let config_options = Arc::new(ConfigOptions::default());
+
+    string::split_part().invoke_with_args(ScalarFunctionArgs {
+        args,
+        arg_fields,
+        number_rows,
+        return_field: Field::new("f", DataType::Utf8, true).into(),
+        config_options: Arc::clone(&config_options),
+    })
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    for size in [1024, 4096] {
+        let mut group = c.benchmark_group(format!("split_part size={size}"));
+        group.sampling_mode(SamplingMode::Flat);
+        group.sample_size(10);
+        group.measurement_time(Duration::from_secs(10));
+
+        let str_len = 32;
+        let args = create_args::<i32>(size, str_len);
+        group.bench_function(
+            format!("split_part_string [size={size}, str_len={str_len}]"),
+            |b| {
+                b.iter(|| {
+                    let args_cloned = args.clone();
+                    black_box(invoke_split_part_with_args(args_cloned, size))
+                })
+            },
+        );
+
+        group.finish();
+    }
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);