Skip to content

Apache DataFusion SQL Query Engine

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

theirix545c37fbcab3
diff --git a/datafusion/functions/Cargo.toml b/datafusion/functions/Cargo.toml
index 529f6354ef..a8c41121b2 100644
--- a/datafusion/functions/Cargo.toml
+++ b/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"
diff --git a/datafusion/functions/benches/right.rs b/datafusion/functions/benches/right.rs
new file mode 100644
index 0000000000..80294ecc4b
--- /dev/null
+++ b/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);
diff --git a/datafusion/functions/src/unicode/left.rs b/datafusion/functions/src/unicode/left.rs
index c7b37ea3ec..54f204993c 100644
--- a/datafusion/functions/src/unicode/left.rs
+++ b/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()),
}
diff --git a/datafusion/functions/src/unicode/right.rs b/datafusion/functions/src/unicode/right.rs
index ac98a3f202..569f20d329 100644
--- a/datafusion/functions/src/unicode/right.rs
+++ b/datafusion/functions/src/unicode/right.rs
@@ -16,16 +16,16 @@
// under the License.
use std::any::Any;
-use std::cmp::{Ordering, max};
+use std::cmp::Ordering;
use std::sync::Arc;
+use crate::utils::make_scalar_function;
use arrow::array::{
- Array, ArrayAccessor, ArrayIter, ArrayRef, GenericStringArray, Int64Array,
- OffsetSizeTrait,
+ Array, ArrayAccessor, ArrayIter, ArrayRef, ByteView, GenericStringArray, Int64Array,
+ OffsetSizeTrait, StringViewArray, make_view,
};
use arrow::datatypes::DataType;
-
-use crate::utils::{make_scalar_function, utf8_to_str_type};
+use arrow_buffer::{NullBuffer, ScalarBuffer};
use datafusion_common::Result;
use datafusion_common::cast::{
as_generic_string_array, as_int64_array, as_string_view_array,
@@ -94,7 +94,7 @@ impl ScalarUDFImpl for RightFunc {
}
fn return_type(&self, arg_types: &[DataType]) -> Result<DataType> {
- utf8_to_str_type(&arg_types[0], "right")
+ Ok(arg_types[0].clone())
}
fn invoke_with_args(
@@ -103,13 +103,13 @@ impl ScalarUDFImpl for RightFunc {
) -> Result<ColumnarValue> {
let args = &args.args;
match args[0].data_type() {
- DataType::Utf8 | DataType::Utf8View => {
- make_scalar_function(right::<i32>, vec![])(args)
+ DataType::Utf8 | DataType::Utf8View | DataType::LargeUtf8 => {
+ make_scalar_function(right, vec![])(args)
}
- DataType::LargeUtf8 => make_scalar_function(right::<i64>, vec![])(args),
other => exec_err!(
- "Unsupported data type {other:?} for function right,\
- expected Utf8View, Utf8 or LargeUtf8."
+ "Unsupported data type {other:?} for function {},\
+ expected Utf8View, Utf8 or LargeUtf8.",
+ self.name()
),
}
}
@@ -119,47 +119,44 @@ impl ScalarUDFImpl for RightFunc {
}
}
-/// Returns last n characters in the string, or when n is negative, returns all but first |n| characters.
+/// Returns right n characters in the string, or when n is negative, returns all but first |n| characters.
/// right('abcde', 2) = 'de'
+/// right('abcde', -2) = 'cde'
/// The implementation uses UTF-8 code points as characters
-fn right<T: OffsetSizeTrait>(args: &[ArrayRef]) -> Result<ArrayRef> {
+fn right(args: &[ArrayRef]) -> Result<ArrayRef> {
let n_array = as_int64_array(&args[1])?;
- if args[0].data_type() == &DataType::Utf8View {
- // string_view_right(args)
- let string_array = as_string_view_array(&args[0])?;
- right_impl::<T, _>(&mut string_array.iter(), n_array)
- } else {
- // string_right::<T>(args)
- let string_array = &as_generic_string_array::<T>(&args[0])?;
- right_impl::<T, _>(&mut string_array.iter(), n_array)
+
+ match args[0].data_type() {
+ DataType::Utf8 => {
+ let string_array = as_generic_string_array::<i32>(&args[0])?;
+ right_impl::<i32, _>(string_array, n_array)
+ }
+ DataType::LargeUtf8 => {
+ let string_array = as_generic_string_array::<i64>(&args[0])?;
+ right_impl::<i64, _>(string_array, n_array)
+ }
+ DataType::Utf8View => {
+ let string_view_array = as_string_view_array(&args[0])?;
+ right_impl_view(string_view_array, n_array)
+ }
+ _ => exec_err!("Not supported"),
}
}
-// Currently the return type can only be Utf8 or LargeUtf8, to reach fully support, we need
-// to edit the `get_optimal_return_type` in utils.rs to make the udfs be able to return Utf8View
-// See https://github.com/apache/datafusion/issues/11790#issuecomment-2283777166
+/// `right` implementation for strings
fn right_impl<'a, T: OffsetSizeTrait, V: ArrayAccessor<Item = &'a str>>(
- string_array_iter: &mut ArrayIter<V>,
+ string_array: V,
n_array: &Int64Array,
) -> Result<ArrayRef> {
- let result = string_array_iter
+ let iter = ArrayIter::new(string_array);
+ let result = iter
.zip(n_array.iter())
.map(|(string, n)| match (string, n) {
- (Some(string), Some(n)) => match n.cmp(&0) {
- Ordering::Less => Some(
- string
- .chars()
- .skip(n.unsigned_abs() as usize)
- .collect::<String>(),
- ),
- Ordering::Equal => Some("".to_string()),
- Ordering::Greater => Some(
- string
- .chars()
- .skip(max(string.chars().count() as i64 - n, 0) as usize)
- .collect::<String>(),
- ),
- },
+ (Some(string), Some(n)) => {
+ let byte_length = right_byte_length(string, n);
+ // Extract starting from `byte_length` bytes from a byte-indexed slice
+ Some(&string[byte_length..])
+ }
_ => None,
})
.collect::<GenericStringArray<T>>();
@@ -167,10 +164,88 @@ fn right_impl<'a, T: OffsetSizeTrait, V: ArrayAccessor<Item = &'a str>>(
Ok(Arc::new(result) as ArrayRef)
}
+/// `right` implementation for StringViewArray
+fn right_impl_view(
+ string_view_array: &StringViewArray,
+ n_array: &Int64Array,
+) -> Result<ArrayRef> {
+ let len = n_array.len();
+
+ let views = string_view_array.views();
+ // Every string in StringViewArray has one corresponding view in `views`
+ debug_assert!(views.len() == string_view_array.len());
+
+ // Compose null buffer at once
+ let string_nulls = string_view_array.nulls();
+ let n_nulls = n_array.nulls();
+ let new_nulls = NullBuffer::union(string_nulls, n_nulls);
+
+ let new_views = (0..len)
+ .map(|idx| {
+ let view = views[idx];
+
+ let is_valid = match &new_nulls {
+ Some(nulls_buf) => nulls_buf.is_valid(idx),
+ None => true,
+ };
+
+ if is_valid {
+ let string: &str = string_view_array.value(idx);
+ let n = n_array.value(idx);
+
+ let new_offset = right_byte_length(string, n);
+ let result_bytes = &string.as_bytes()[new_offset..];
+
+ if result_bytes.len() > 12 {
+ let byte_view = ByteView::from(view);
+ // Reuse buffer, but adjust offset and length
+ make_view(
+ result_bytes,
+ byte_view.buffer_index,
+ byte_view.offset + new_offset as u32,
+ )
+ } else {
+ // inline value does not need block id or offset
+ make_view(result_bytes, 0, 0)
+ }
+ } else {
+ // For nulls, keep the original view
+ view
+ }
+ })
+ .collect::<Vec<u128>>();
+
+ // Buffers are unchanged
+ let result = StringViewArray::try_new(
+ ScalarBuffer::from(new_views),
+ Vec::from(string_view_array.data_buffers()),
+ new_nulls,
+ )?;
+ Ok(Arc::new(result) as ArrayRef)
+}
+
+/// Calculate the byte length of the substring of last `n` chars from string `string`
+/// (or all but first `|n|` chars if n is negative)
+fn right_byte_length(string: &str, n: i64) -> usize {
+ match n.cmp(&0) {
+ Ordering::Less => string
+ .char_indices()
+ .nth(n.unsigned_abs().min(usize::MAX as u64) as usize)
+ .map(|(index, _)| index)
+ .unwrap_or(string.len()),
+ Ordering::Equal => string.len(),
+ Ordering::Greater => string
+ .char_indices()
+ .nth_back((n.unsigned_abs().min(usize::MAX as u64) - 1) as usize)
+ .map(|(index, _)| index)
+ .unwrap_or(0),
+ }
+}
+
#[cfg(test)]
mod tests {
- use arrow::array::{Array, StringArray};
- use arrow::datatypes::DataType::Utf8;
+ use arrow::array::{Array, StringArray, StringViewArray};
+ use arrow::datatypes::DataType::{Utf8, Utf8View};
use datafusion_common::{Result, ScalarValue};
use datafusion_expr::{ColumnarValue, ScalarUDFImpl};
@@ -213,6 +288,17 @@ mod tests {
Utf8,
StringArray
);
+ test_function!(
+ RightFunc::new(),
+ vec![
+ ColumnarValue::Scalar(ScalarValue::from("abcde")),
+ ColumnarValue::Scalar(ScalarValue::from(i64::MIN)),
+ ],
+ Ok(Some("")),
+ &str,
+ Utf8,
+ StringArray
+ );
test_function!(
RightFunc::new(),
vec![
@@ -260,10 +346,10 @@ mod tests {
test_function!(
RightFunc::new(),
vec![
- ColumnarValue::Scalar(ScalarValue::from("joséésoj")),
+ ColumnarValue::Scalar(ScalarValue::from("joséérend")),
ColumnarValue::Scalar(ScalarValue::from(5i64)),
],
- Ok(Some("éésoj")),
+ Ok(Some("érend")),
&str,
Utf8,
StringArray
@@ -271,10 +357,10 @@ mod tests {
test_function!(
RightFunc::new(),
vec![
- ColumnarValue::Scalar(ScalarValue::from("joséésoj")),
+ ColumnarValue::Scalar(ScalarValue::from("joséérend")),
ColumnarValue::Scalar(ScalarValue::from(-3i64)),
],
- Ok(Some("éésoj")),
+ Ok(Some("éérend")),
&str,
Utf8,
StringArray
@@ -294,6 +380,71 @@ mod tests {
StringArray
);
+ // StringView cases
+ test_function!(
+ RightFunc::new(),
+ vec![
+ ColumnarValue::Scalar(ScalarValue::Utf8View(Some("abcde".to_string()))),
+ ColumnarValue::Scalar(ScalarValue::from(2i64)),
+ ],
+ Ok(Some("de")),
+ &str,
+ Utf8View,
+ StringViewArray
+ );
+ test_function!(
+ RightFunc::new(),
+ vec![
+ ColumnarValue::Scalar(ScalarValue::Utf8View(Some("abcde".to_string()))),
+ ColumnarValue::Scalar(ScalarValue::from(200i64)),
+ ],
+ Ok(Some("abcde")),
+ &str,
+ Utf8View,
+ StringViewArray
+ );
+ test_function!(
+ RightFunc::new(),
+ vec![
+ ColumnarValue::Scalar(ScalarValue::Utf8View(Some("".to_string()))),
+ ColumnarValue::Scalar(ScalarValue::from(200i64)),
+ ],
+ Ok(Some("")),
+ &str,
+ Utf8View,
+ StringViewArray
+ );
+ test_function!(
+ RightFunc::new(),
+ vec![
+ ColumnarValue::Scalar(ScalarValue::Utf8View(Some(
+ "joséérend".to_string()
+ ))),
+ ColumnarValue::Scalar(ScalarValue::from(-3i64)),
+ ],
+ Ok(Some("éérend")),
+ &str,
+ Utf8View,
+ StringViewArray
+ );
+
+ // Unicode indexing case
+ let input = "joé楽s𐀀so↓j";
+ for n in 1..=input.chars().count() {
+ let expected = input.chars().skip(n).collect::<String>();
+ test_function!(
+ RightFunc::new(),
+ vec![
+ ColumnarValue::Scalar(ScalarValue::from(input)),
+ ColumnarValue::Scalar(ScalarValue::from(-(n as i64))),
+ ],
+ Ok(Some(expected.as_str())),
+ &str,
+ Utf8,
+ StringArray
+ );
+ }
+
Ok(())
}
}