perf: Optimize translate to use new bulk-NULL string builders (#22171)

## Which issue does this PR close?

- Closes #22170.

## Rationale for this change

This PR refactors and optimizes the `translate` UDF. In particular, we
switch to using the new bulk-NULL string builders, avoiding per-row NULL
computation, and avoid an intermediate string copy by using
`append_with` / `append_byte_map`.

Benchmarks (Arm64):

Scalar (scalar_from_to)

  - size=1024, str_len=8: 13.6 µs → 8.5 µs (-37.5%)
  - size=1024, str_len=32: 26.2 µs → 20.6 µs (-21.4%)
  - size=1024, str_len=128: 87.9 µs → 68.9 µs (-21.6%)
  - size=1024, str_len=1024: 572.9 µs → 531.1 µs (-7.3%)
  - size=4096, str_len=8: 51.6 µs → 31.4 µs (-39.1%)
  - size=4096, str_len=32: 103.1 µs → 79.8 µs (-22.6%)
  - size=4096, str_len=128: 341.1 µs → 273.4 µs (-19.8%)
  - size=4096, str_len=1024: 2.3 ms → 2.1 ms (-8.7%)

Array — ASCII (array_from_to)

  - size=1024, str_len=8: 50.6 µs → 21.2 µs (-58.1%)
  - size=1024, str_len=32: 106.5 µs → 26.7 µs (-74.9%)
  - size=1024, str_len=128: 265.4 µs → 59.9 µs (-77.4%)
  - size=1024, str_len=1024: 1760.8 µs → 797.1 µs (-54.7%)
  - size=4096, str_len=8: 211.4 µs → 84.3 µs (-60.1%)
  - size=4096, str_len=32: 435.2 µs → 120.6 µs (-72.3%)
  - size=4096, str_len=128: 1079.0 µs → 487.6 µs (-54.8%)
  - size=4096, str_len=1024: 7.2 ms → 3.2 ms (-55.6%)

Array — non-ASCII (array_from_to_non_ascii)

  - size=1024, str_len=8: 71.2 µs → 68.6 µs (-3.7%)
  - size=1024, str_len=32: 228.8 µs → 236.9 µs (+3.5%)
  - size=1024, str_len=128: 880.5 µs → 881.4 µs (+0.1%)
  - size=1024, str_len=1024: 6.7 ms → 6.7 ms (+0.6%)
  - size=4096, str_len=8: 375.5 µs → 376.6 µs (+0.3%)
  - size=4096, str_len=32: 1041.2 µs → 1079.6 µs (+3.7%)
  - size=4096, str_len=128: 3.5 ms → 3.6 ms (+2.9%)
  - size=4096, str_len=1024: 27.0 ms → 26.8 ms (-0.7%)

## What changes are included in this PR?

* Switch from using the Rust StringBuilders to our new bulk-NULL string
builders
* Switch from per-row NULL checks to computing the NULL bitmaps with
`NullBuffer::union_many`
* Use `append_with` and `append_byte_map` rather than `append_value`,
which avoids an intermediate scratch buffer
* Refactor lookup table code to use a single `TranslationTable` enum
* Add a benchmark for the "varying `from`/`to`, Unicode strings" case
* Add a unit test

## Are these changes tested?

Yes; new test added.

## Are there any user-facing changes?

No.

Author: neilconway

datafusion/functions/benches/translate.rs

@@ -15,18 +15,45 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use arrow::array::OffsetSizeTrait;
+use arrow::array::{GenericStringArray, 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::config::ConfigOptions;
 use datafusion_common::{DataFusionError, ScalarValue};
 use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};
 use datafusion_functions::unicode;
+use rand::SeedableRng;
+use rand::prelude::IndexedRandom;
+use rand::rngs::StdRng;
 use std::hint::black_box;
 use std::sync::Arc;
 use std::time::Duration;
 
+// Mix of 2-byte (Greek) and 3-byte (CJK/Hangul) UTF-8 to exercise
+// variable-width char paths in translate.
+const NON_ASCII_ALPHABET: &[char] = &[
+    'α', 'β', 'γ', 'δ', 'ε', 'ζ', 'η', 'θ', 'ι', 'κ', 'λ', 'μ', 'ν', 'ξ', 'ο', 'π', 'ρ',
+    'σ', 'τ', 'υ', 'φ', 'χ', 'ψ', 'ω', '日', '本', '語', '中', '文', '한', '국', '어',
+];
+
+fn create_non_ascii_string_array<O: OffsetSizeTrait>(
+    size: usize,
+    char_count: usize,
+    seed: u64,
+) -> GenericStringArray<O> {
+    let mut rng = StdRng::seed_from_u64(seed);
+    (0..size)
+        .map(|_| {
+            Some(
+                (0..char_count)
+                    .map(|_| *NON_ASCII_ALPHABET.choose(&mut rng).unwrap())
+                    .collect::<String>(),
+            )
+        })
+        .collect()
+}
+
 fn create_args_array_from_to<O: OffsetSizeTrait>(
     size: usize,
     str_len: usize,
@@ -42,6 +69,25 @@ fn create_args_array_from_to<O: OffsetSizeTrait>(
     ]
 }
 
+fn create_args_array_from_to_non_ascii<O: OffsetSizeTrait>(
+    size: usize,
+    str_len: usize,
+) -> Vec<ColumnarValue> {
+    let string_array = Arc::new(create_non_ascii_string_array::<O>(
+        size,
+        str_len,
+        0xA110_AAAA,
+    ));
+    let from_array = Arc::new(create_non_ascii_string_array::<O>(size, 3, 0xA110_BBBB));
+    let to_array = Arc::new(create_non_ascii_string_array::<O>(size, 2, 0xA110_CCCC));
+
+    vec![
+        ColumnarValue::Array(string_array),
+        ColumnarValue::Array(from_array),
+        ColumnarValue::Array(to_array),
+    ]
+}
+
 fn create_args_scalar_from_to<O: OffsetSizeTrait>(
     size: usize,
     str_len: usize,
@@ -91,6 +137,17 @@ fn criterion_benchmark(c: &mut Criterion) {
                 })
             });
 
+            let args = create_args_array_from_to_non_ascii::<i32>(size, str_len);
+            group.bench_function(
+                format!("array_from_to_non_ascii [str_len={str_len}]"),
+                |b| {
+                    b.iter(|| {
+                        let args_cloned = args.clone();
+                        black_box(invoke_translate_with_args(args_cloned, size))
+                    })
+                },
+            );
+
             let args = create_args_scalar_from_to::<i32>(size, str_len);
             group.bench_function(format!("scalar_from_to [str_len={str_len}]"), |b| {
                 b.iter(|| {