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.tomlindex 529f6354ef..a8c41121b2 100644--- a/datafusion/functions/Cargo.toml+++ b/datafusion/functions/Cargo.toml@@ -311,6 +311,11 @@ harness = falsename = "left"required-features = ["unicode_expressions"]+[[bench]]+harness = false+name = "right"+required-features = ["unicode_expressions"]+[[bench]]harness = falsename = "factorial"diff --git a/datafusion/functions/benches/right.rs b/datafusion/functions/benches/right.rsnew file mode 100644index 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.rsindex 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.rsindex 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 stringsfn 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(())}}