Add ASCII fast path optimization to replace function

Add a fast path for replacing single ASCII characters with another single
ASCII character, matching Rust's str::replace() optimization. This enables
vectorization and avoids UTF-8 boundary checking overhead.

Changes:
- Added ASCII character detection in replace_into_string()
- When both 'from' and 'to' are single ASCII bytes, use direct byte mapping
- Updated benchmark to include single ASCII character replacement tests

Optimization:
- Fast path operates directly on bytes using simple map operation
- Compiler can vectorize the byte-wise replacement
- Avoids overhead of match_indices() pattern matching for this common case

Benchmark Results (Single ASCII Character Replacement) against previous commit:
- size=1024, str_len=32:  29.5 µs → 21.4 µs (27% faster)
- size=1024, str_len=128: 73.9 µs → 23.4 µs (68% faster)
- size=4096, str_len=32:  121.8 µs → 85.6 µs (30% faster)
- size=4096, str_len=128: 316.9 µs → 83.8 µs (74% faster)

The optimization shows exceptional 27-74% improvements, with the benefit
scaling dramatically with string length. For 128-character strings, we
achieve over 3x speedup by enabling vectorization and eliminating
pattern matching overhead.

This addresses reviewer feedback about capturing Rust's str::replace()
optimization tricks for single ASCII character replacements.

Author: viirya

datafusion/functions/benches/replace.rs

@@ -35,12 +35,17 @@ fn create_args<O: OffsetSizeTrait>(
     size: usize,
     str_len: usize,
     force_view_types: bool,
+    from_len: usize,
+    to_len: usize,
 ) -> Vec<ColumnarValue> {
     if force_view_types {
         let string_array =
             Arc::new(create_string_view_array_with_len(size, 0.1, str_len, false));
-        let from_array = Arc::new(create_string_view_array_with_len(size, 0.1, 3, false));
-        let to_array = Arc::new(create_string_view_array_with_len(size, 0.1, 5, false));
+        let from_array = Arc::new(create_string_view_array_with_len(
+            size, 0.1, from_len, false,
+        ));
+        let to_array =
+            Arc::new(create_string_view_array_with_len(size, 0.1, to_len, false));
         vec![
             ColumnarValue::Array(string_array),
             ColumnarValue::Array(from_array),
@@ -49,8 +54,8 @@ fn create_args<O: OffsetSizeTrait>(
     } else {
         let string_array =
             Arc::new(create_string_array_with_len::<O>(size, 0.1, str_len));
-        let from_array = Arc::new(create_string_array_with_len::<O>(size, 0.1, 3));
-        let to_array = Arc::new(create_string_array_with_len::<O>(size, 0.1, 5));
+        let from_array = Arc::new(create_string_array_with_len::<O>(size, 0.1, from_len));
+        let to_array = Arc::new(create_string_array_with_len::<O>(size, 0.1, to_len));
 
         vec![
             ColumnarValue::Array(string_array),
@@ -87,9 +92,21 @@ fn criterion_benchmark(c: &mut Criterion) {
         group.sample_size(10);
         group.measurement_time(Duration::from_secs(10));
 
-        // Small strings
+        // ASCII single character replacement (fast path)
         let str_len = 32;
-        let args = create_args::<i32>(size, str_len, true);
+        let args = create_args::<i32>(size, str_len, false, 1, 1);
+        group.bench_function(
+            format!("replace_string_ascii_single [size={size}, str_len={str_len}]"),
+            |b| {
+                b.iter(|| {
+                    let args_cloned = args.clone();
+                    black_box(invoke_replace_with_args(args_cloned, size))
+                })
+            },
+        );
+
+        // Multi-character strings (general path)
+        let args = create_args::<i32>(size, str_len, true, 3, 5);
         group.bench_function(
             format!("replace_string_view [size={size}, str_len={str_len}]"),
             |b| {
@@ -100,7 +117,7 @@ fn criterion_benchmark(c: &mut Criterion) {
             },
         );
 
-        let args = create_args::<i32>(size, str_len, false);
+        let args = create_args::<i32>(size, str_len, false, 3, 5);
         group.bench_function(
             format!("replace_string [size={size}, str_len={str_len}]"),
             |b| {
@@ -111,7 +128,7 @@ fn criterion_benchmark(c: &mut Criterion) {
             },
         );
 
-        let args = create_args::<i64>(size, str_len, false);
+        let args = create_args::<i64>(size, str_len, false, 3, 5);
         group.bench_function(
             format!("replace_large_string [size={size}, str_len={str_len}]"),
             |b| {
@@ -124,7 +141,18 @@ fn criterion_benchmark(c: &mut Criterion) {
 
         // Larger strings
         let str_len = 128;
-        let args = create_args::<i32>(size, str_len, true);
+        let args = create_args::<i32>(size, str_len, false, 1, 1);
+        group.bench_function(
+            format!("replace_string_ascii_single [size={size}, str_len={str_len}]"),
+            |b| {
+                b.iter(|| {
+                    let args_cloned = args.clone();
+                    black_box(invoke_replace_with_args(args_cloned, size))
+                })
+            },
+        );
+
+        let args = create_args::<i32>(size, str_len, true, 3, 5);
         group.bench_function(
             format!("replace_string_view [size={size}, str_len={str_len}]"),
             |b| {
@@ -135,7 +163,7 @@ fn criterion_benchmark(c: &mut Criterion) {
             },
         );
 
-        let args = create_args::<i32>(size, str_len, false);
+        let args = create_args::<i32>(size, str_len, false, 3, 5);
         group.bench_function(
             format!("replace_string [size={size}, str_len={str_len}]"),
             |b| {
@@ -146,7 +174,7 @@ fn criterion_benchmark(c: &mut Criterion) {
             },
         );
 
-        let args = create_args::<i64>(size, str_len, false);
+        let args = create_args::<i64>(size, str_len, false, 3, 5);
         group.bench_function(
             format!("replace_large_string [size={size}, str_len={str_len}]"),
             |b| {

datafusion/functions/src/string/replace.rs

@@ -228,6 +228,22 @@ fn replace_into_string(buffer: &mut String, string: &str, from: &str, to: &str)
         return;
     }
 
+    // Fast path for replacing a single ASCII character with another single ASCII character
+    // This matches Rust's str::replace() optimization and enables vectorization
+    if let ([from_byte], [to_byte]) = (from.as_bytes(), to.as_bytes())
+        && from_byte.is_ascii()
+        && to_byte.is_ascii()
+    {
+        // SAFETY: We're replacing ASCII with ASCII, which preserves UTF-8 validity
+        let replaced: Vec<u8> = string
+            .as_bytes()
+            .iter()
+            .map(|b| if *b == *from_byte { *to_byte } else { *b })
+            .collect();
+        buffer.push_str(unsafe { std::str::from_utf8_unchecked(&replaced) });
+        return;
+    }
+
     let mut last_end = 0;
     for (start, _part) in string.match_indices(from) {
         buffer.push_str(&string[last_end..start]);