perf: optimise right for byte access and StringView (#20069)

## Which issue does this PR close?

- Closes #20068.

## Rationale for this change

Similar to issue #19749 and the optimisation of `left` in #19980, it's
worth doing the same for `right`

## What changes are included in this PR?
 
- Improve efficiency of the function by making fewer memory allocations
and going directly to bytes, based on char boundaries

- Provide a specialisation for StringView with buffer zero-copy

- Use `arrow_array::buffer::make_view` for low-level view manipulation
(we still need to know about a magic constant 12 for a buffer layout)

- Benchmark - up to 90% performance improvement

```
right size=1024/string_array positive n/1024
                        time:   [24.286 µs 24.658 µs 25.087 µs]
                        change: [−86.881% −86.662% −86.424%] (p = 0.00 < 0.05)
                        Performance has improved.
right size=1024/string_array negative n/1024
                        time:   [29.996 µs 30.737 µs 31.511 µs]
                        change: [−89.442% −89.229% −89.003%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 1 outliers among 100 measurements (1.00%)
  1 (1.00%) high mild

right size=4096/string_array positive n/4096
                        time:   [105.58 µs 109.39 µs 113.51 µs]
                        change: [−86.119% −85.788% −85.497%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 9 outliers among 100 measurements (9.00%)
  6 (6.00%) high mild
  3 (3.00%) high severe
right size=4096/string_array negative n/4096
                        time:   [136.48 µs 138.34 µs 140.36 µs]
                        change: [−88.007% −87.848% −87.692%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 4 outliers among 100 measurements (4.00%)
  4 (4.00%) high mild

right size=1024/string_view_array positive n/1024
                        time:   [25.054 µs 25.500 µs 26.033 µs]
                        change: [−82.569% −82.285% −81.891%] (p = 0.00 < 0.05)
                        Performance has improved.
right size=1024/string_view_array negative n/1024
                        time:   [41.281 µs 42.730 µs 44.432 µs]
                        change: [−73.832% −73.288% −72.716%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 5 outliers among 100 measurements (5.00%)
  3 (3.00%) high mild
  2 (2.00%) high severe

right size=4096/string_view_array positive n/4096
                        time:   [129.38 µs 133.69 µs 137.61 µs]
                        change: [−79.497% −78.998% −78.581%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 4 outliers among 100 measurements (4.00%)
  4 (4.00%) high mild
right size=4096/string_view_array negative n/4096
                        time:   [218.16 µs 229.41 µs 243.30 µs]
                        change: [−65.405% −63.622% −61.515%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 10 outliers among 100 measurements (10.00%)
  3 (3.00%) high mild
  7 (7.00%) high severe
```

## Are these changes tested?

- Existing unit tests for `right`

- Added more unit tests

- Added bench similar to `right.rs`

- Existing SLTs pass

## Are there any user-facing changes?

No

Author: theirix

datafusion/functions/Cargo.toml

@@ -311,6 +311,11 @@ harness = false
 name = "left"
 required-features = ["unicode_expressions"]
 
+[[bench]]
+harness = false
+name = "right"
+required-features = ["unicode_expressions"]
+
 [[bench]]
 harness = false
 name = "factorial"

datafusion/functions/benches/right.rs

@@ -0,0 +1,150 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+extern crate criterion;
+
+use std::hint::black_box;
+use std::sync::Arc;
+
+use arrow::array::{ArrayRef, Int64Array};
+use arrow::datatypes::{DataType, Field};
+use arrow::util::bench_util::{
+    create_string_array_with_len, create_string_view_array_with_len,
+};
+use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
+use datafusion_common::config::ConfigOptions;
+use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};
+use datafusion_functions::unicode::right;
+
+fn create_args(
+    size: usize,
+    str_len: usize,
+    use_negative: bool,
+    is_string_view: bool,
+) -> Vec<ColumnarValue> {
+    let string_arg = if is_string_view {
+        ColumnarValue::Array(Arc::new(create_string_view_array_with_len(
+            size, 0.1, str_len, true,
+        )))
+    } else {
+        ColumnarValue::Array(Arc::new(create_string_array_with_len::<i32>(
+            size, 0.1, str_len,
+        )))
+    };
+
+    // For negative n, we want to trigger the double-iteration code path
+    let n_values: Vec<i64> = if use_negative {
+        (0..size).map(|i| -((i % 10 + 1) as i64)).collect()
+    } else {
+        (0..size).map(|i| (i % 10 + 1) as i64).collect()
+    };
+    let n_array = Arc::new(Int64Array::from(n_values));
+
+    vec![
+        string_arg,
+        ColumnarValue::Array(Arc::clone(&n_array) as ArrayRef),
+    ]
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    for is_string_view in [false, true] {
+        for size in [1024, 4096] {
+            let mut group = c.benchmark_group(format!("right size={size}"));
+
+            // Benchmark with positive n (no optimization needed)
+            let mut function_name = if is_string_view {
+                "string_view_array positive n"
+            } else {
+                "string_array positive n"
+            };
+            let args = create_args(size, 32, false, is_string_view);
+            group.bench_function(BenchmarkId::new(function_name, size), |b| {
+                let arg_fields = args
+                    .iter()
+                    .enumerate()
+                    .map(|(idx, arg)| {
+                        Field::new(format!("arg_{idx}"), arg.data_type(), true).into()
+                    })
+                    .collect::<Vec<_>>();
+                let return_type = if is_string_view {
+                    DataType::Utf8View
+                } else {
+                    DataType::Utf8
+                };
+                let config_options = Arc::new(ConfigOptions::default());
+
+                b.iter(|| {
+                    black_box(
+                        right()
+                            .invoke_with_args(ScalarFunctionArgs {
+                                args: args.clone(),
+                                arg_fields: arg_fields.clone(),
+                                number_rows: size,
+                                return_field: Field::new("f", return_type.clone(), true)
+                                    .into(),
+                                config_options: Arc::clone(&config_options),
+                            })
+                            .expect("right should work"),
+                    )
+                })
+            });
+
+            // Benchmark with negative n (triggers optimization)
+            function_name = if is_string_view {
+                "string_view_array negative n"
+            } else {
+                "string_array negative n"
+            };
+            let args = create_args(size, 32, true, is_string_view);
+            group.bench_function(BenchmarkId::new(function_name, size), |b| {
+                let arg_fields = args
+                    .iter()
+                    .enumerate()
+                    .map(|(idx, arg)| {
+                        Field::new(format!("arg_{idx}"), arg.data_type(), true).into()
+                    })
+                    .collect::<Vec<_>>();
+                let return_type = if is_string_view {
+                    DataType::Utf8View
+                } else {
+                    DataType::Utf8
+                };
+                let config_options = Arc::new(ConfigOptions::default());
+
+                b.iter(|| {
+                    black_box(
+                        right()
+                            .invoke_with_args(ScalarFunctionArgs {
+                                args: args.clone(),
+                                arg_fields: arg_fields.clone(),
+                                number_rows: size,
+                                return_field: Field::new("f", return_type.clone(), true)
+                                    .into(),
+                                config_options: Arc::clone(&config_options),
+                            })
+                            .expect("right should work"),
+                    )
+                })
+            });
+
+            group.finish();
+        }
+    }
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

datafusion/functions/src/unicode/left.rs

@@ -225,7 +225,7 @@ fn left_byte_length(string: &str, n: i64) -> usize {
         Ordering::Equal => 0,
         Ordering::Greater => string
             .char_indices()
-            .nth(n as usize)
+            .nth(n.unsigned_abs() as usize)
             .map(|(index, _)| index)
             .unwrap_or(string.len()),
     }