Apache DataFusion SQL Query Engine
perf: Use `sub_view` in `trim`, `substr`, `split_part`, and `substring_index` (#26121)
Neil Conway55b2f093bb80
diff --git a/datafusion/functions/benches/string_expressions/split_part.rs b/datafusion/functions/benches/string_expressions/split_part.rsindex 910814d8e3..052ca17b71 100644--- a/datafusion/functions/benches/string_expressions/split_part.rs+++ b/datafusion/functions/benches/string_expressions/split_part.rs@@ -15,254 +15,170 @@// specific language governing permissions and limitations// under the License.-use arrow::array::{ArrayRef, Int64Array, StringArray, StringViewArray};-use arrow::datatypes::{DataType, Field};-use criterion::{BenchmarkId, Criterion, criterion_group};+use std::hint::black_box;+use std::ops::{Range, RangeInclusive};+use std::sync::Arc;++use arrow::array::{StringArray, StringViewArray};+use arrow::datatypes::{Field, Int64Type};+use arrow::util::bench_util::create_primitive_array_range;+use criterion::{Criterion, criterion_group};use datafusion_common::ScalarValue;use datafusion_common::config::ConfigOptions;-use datafusion_expr::{ColumnarValue, ScalarFunctionArgs, ScalarUDF};+use datafusion_expr::{ColumnarValue, ReturnFieldArgs, ScalarFunctionArgs};use datafusion_functions::string::split_part;use rand::distr::Alphanumeric;-use rand::prelude::StdRng;+use rand::rngs::StdRng;use rand::{Rng, SeedableRng};-use std::hint::black_box;-use std::sync::Arc;-const N_ROWS: usize = 8192;+const BATCH_SIZE: usize = 8192;-/// Creates an array of strings with `num_parts` random alphanumeric segments-/// of `part_len` bytes each, joined by `delimiter`.-fn gen_string_array(- n_rows: usize,- num_parts: usize,- part_len: usize,+/// How the position argument is passed.+enum Position {+ /// The same position for every row, as in `split_part(s, '.', 2)`.+ Scalar(i64),+ /// A different position for each row, drawn from the range.+ PerRow(Range<i64>),+}++/// Returns strings of alphanumeric fields joined by `delimiter`. Each row's+/// number of fields and each field's length are drawn from the given ranges.+fn create_strings(+ field_len: &RangeInclusive<usize>,+ num_fields: &RangeInclusive<usize>,delimiter: &str,- use_string_view: bool,-) -> ColumnarValue {+) -> Vec<Option<String>> {let mut rng = StdRng::seed_from_u64(42);-- let mut strings: Vec<String> = Vec::with_capacity(n_rows);- for _ in 0..n_rows {- let mut parts: Vec<String> = Vec::with_capacity(num_parts);- for _ in 0..num_parts {- let part: String = (&mut rng)- .sample_iter(&Alphanumeric)- .take(part_len)- .map(char::from)+ (0..BATCH_SIZE)+ .map(|_| {+ if rng.random::<f32>() < 0.1 {+ return None;+ }+ let fields: Vec<String> = (0..rng.random_range(num_fields.clone()))+ .map(|_| {+ let len = rng.random_range(field_len.clone());+ (&mut rng)+ .sample_iter(&Alphanumeric)+ .take(len)+ .map(char::from)+ .collect()+ }).collect();- parts.push(part);- }- strings.push(parts.join(delimiter));- }+ Some(fields.join(delimiter))+ })+ .collect()+}- if use_string_view {- let string_array: StringViewArray = strings.into_iter().map(Some).collect();- ColumnarValue::Array(Arc::new(string_array) as ArrayRef)+fn create_args(+ field_len: &RangeInclusive<usize>,+ num_fields: &RangeInclusive<usize>,+ delimiter: &str,+ position: &Position,+ is_string_view: bool,+) -> Vec<ColumnarValue> {+ let strings = create_strings(field_len, num_fields, delimiter);+ let string_arg = if is_string_view {+ ColumnarValue::Array(Arc::new(strings.into_iter().collect::<StringViewArray>()))} else {- let string_array: StringArray = strings.into_iter().map(Some).collect();- ColumnarValue::Array(Arc::new(string_array) as ArrayRef)- }-}+ ColumnarValue::Array(Arc::new(strings.into_iter().collect::<StringArray>()))+ };-#[expect(clippy::too_many_arguments)]-fn bench_split_part(- group: &mut criterion::BenchmarkGroup<'_, criterion::measurement::WallTime>,- func: &ScalarUDF,- config_options: &Arc<ConfigOptions>,- name: &str,- tag: &str,- strings: ColumnarValue,- delimiter: ColumnarValue,- position: ColumnarValue,-) {- let args = vec![strings, delimiter, position];- let arg_fields: Vec<_> = args- .iter()- .enumerate()- .map(|(idx, arg)| Field::new(format!("arg_{idx}"), arg.data_type(), true).into())- .collect();- let return_type = match args[0].data_type() {- DataType::Utf8View => DataType::Utf8View,- _ => DataType::Utf8,+ let position_arg = match position {+ Position::Scalar(n) => ColumnarValue::Scalar(ScalarValue::Int64(Some(*n))),+ Position::PerRow(range) => ColumnarValue::Array(Arc::new(+ create_primitive_array_range::<Int64Type>(BATCH_SIZE, 0.0, range.clone()),+ )),};- let return_field = Field::new("f", return_type, true).into();- group.bench_function(BenchmarkId::new(name, tag), |b| {- b.iter(|| {- black_box(- func.invoke_with_args(ScalarFunctionArgs {- args: args.clone(),- arg_fields: arg_fields.clone(),- number_rows: N_ROWS,- return_field: Arc::clone(&return_field),- config_options: Arc::clone(config_options),- })- .expect("split_part should work"),- )- })- });+ vec![+ string_arg,+ ColumnarValue::Scalar(ScalarValue::from(delimiter)),+ position_arg,+ ]}fn criterion_benchmark(c: &mut Criterion) {- let split_part_func = split_part();+ // Field lengths and counts vary within each case, as in real data: with+ // fixed lengths, per-row work that depends on them is unrealistically+ // predictable.+ let cases = [+ // Fields of up to 8 bytes, stored inline in StringView arrays (≤12 bytes).+ ("short_fields", 1..=8, 3..=6, ".", Position::Scalar(2)),+ // Fields of more than 12 bytes, stored out of line.+ ("long_fields", 16..=48, 3..=6, ".", Position::Scalar(2)),+ // A field near the middle of many fields.+ ("many_fields", 1..=16, 20..=50, ".", Position::Scalar(10)),+ // A negative position counts fields from the end.+ (+ "negative_position",+ 1..=32,+ 3..=6,+ ".",+ Position::Scalar(-1),+ ),+ // A delimiter of more than one character.+ (+ "multi_char_delimiter",+ 1..=32,+ 3..=6,+ "~@~",+ Position::Scalar(2),+ ),+ // The position computed per row.+ (+ "per_row_position",+ 1..=32,+ 3..=6,+ ".",+ Position::PerRow(1..4),+ ),+ ];+ let function = split_part();let config_options = Arc::new(ConfigOptions::default());- let mut group = c.benchmark_group("split_part");-- // ── Scalar delimiter and position ────────────────-- // Utf8, single-char delimiter, scalar args- {- let strings = gen_string_array(N_ROWS, 10, 8, ".", false);- let delimiter = ColumnarValue::Scalar(ScalarValue::Utf8(Some(".".into())));- let position = ColumnarValue::Scalar(ScalarValue::Int64(Some(1)));- bench_split_part(- &mut group,- &split_part_func,- &config_options,- "scalar_utf8_single_char",- "pos_first",- strings,- delimiter,- position,- );- }-- {- let strings = gen_string_array(N_ROWS, 10, 8, ".", false);- let delimiter = ColumnarValue::Scalar(ScalarValue::Utf8(Some(".".into())));- let position = ColumnarValue::Scalar(ScalarValue::Int64(Some(5)));- bench_split_part(- &mut group,- &split_part_func,- &config_options,- "scalar_utf8_single_char",- "pos_middle",- strings,- delimiter,- position,- );- }-- {- let strings = gen_string_array(N_ROWS, 10, 8, ".", false);- let delimiter = ColumnarValue::Scalar(ScalarValue::Utf8(Some(".".into())));- let position = ColumnarValue::Scalar(ScalarValue::Int64(Some(-1)));- bench_split_part(- &mut group,- &split_part_func,- &config_options,- "scalar_utf8_single_char",- "pos_negative",- strings,- delimiter,- position,- );- }-- // Utf8, multi-char delimiter, scalar args- {- let strings = gen_string_array(N_ROWS, 10, 8, "~@~", false);- let delimiter = ColumnarValue::Scalar(ScalarValue::Utf8(Some("~@~".into())));- let position = ColumnarValue::Scalar(ScalarValue::Int64(Some(5)));- bench_split_part(- &mut group,- &split_part_func,- &config_options,- "scalar_utf8_multi_char",- "pos_middle",- strings,- delimiter,- position,- );- }-- // Utf8, long strings, scalar args- {- let strings = gen_string_array(N_ROWS, 50, 16, ".", false);- let delimiter = ColumnarValue::Scalar(ScalarValue::Utf8(Some(".".into())));- let position = ColumnarValue::Scalar(ScalarValue::Int64(Some(25)));- bench_split_part(- &mut group,- &split_part_func,- &config_options,- "scalar_utf8_long_strings",- "pos_middle",- strings,- delimiter,- position,- );- }-- // Utf8View, long parts, scalar args- {- let strings = gen_string_array(N_ROWS, 10, 32, ".", true);- let delimiter = ColumnarValue::Scalar(ScalarValue::Utf8View(Some(".".into())));- let position = ColumnarValue::Scalar(ScalarValue::Int64(Some(5)));- bench_split_part(- &mut group,- &split_part_func,- &config_options,- "scalar_utf8view_long_parts",- "pos_middle",- strings,- delimiter,- position,- );- }-- // Utf8View, very long parts (256 bytes), position 1- {- let strings = gen_string_array(N_ROWS, 5, 256, ".", true);- let delimiter = ColumnarValue::Scalar(ScalarValue::Utf8View(Some(".".into())));- let position = ColumnarValue::Scalar(ScalarValue::Int64(Some(1)));- bench_split_part(- &mut group,- &split_part_func,- &config_options,- "scalar_utf8view_very_long_parts",- "pos_first",- strings,- delimiter,- position,- );- }-- // ── Array delimiter and position ─────────────────-- // Utf8, single-char delimiter, array args- {- let strings = gen_string_array(N_ROWS, 10, 8, ".", false);- let delimiters: StringArray = vec![Some("."); N_ROWS].into_iter().collect();- let delimiter = ColumnarValue::Array(Arc::new(delimiters) as ArrayRef);- let positions = ColumnarValue::Array(Arc::new(Int64Array::from(vec![5; N_ROWS])));- bench_split_part(- &mut group,- &split_part_func,- &config_options,- "array_utf8_single_char",- "pos_middle",- strings,- delimiter,- positions,- );- }-- // Utf8, multi-char delimiter, array args- {- let strings = gen_string_array(N_ROWS, 10, 8, "~@~", false);- let delimiters: StringArray = vec![Some("~@~"); N_ROWS].into_iter().collect();- let delimiter = ColumnarValue::Array(Arc::new(delimiters) as ArrayRef);- let positions = ColumnarValue::Array(Arc::new(Int64Array::from(vec![5; N_ROWS])));- bench_split_part(- &mut group,- &split_part_func,- &config_options,- "array_utf8_multi_char",- "pos_middle",- strings,- delimiter,- positions,- );+ let mut group = c.benchmark_group(function.name().to_string());++ for is_string_view in [false, true] {+ let array_type = if is_string_view {+ "string_view"+ } else {+ "string"+ };++ for (case_name, field_len, num_fields, delimiter, position) in &cases {+ let args =+ create_args(field_len, num_fields, delimiter, position, is_string_view);++ let arg_fields: Vec<_> = args+ .iter()+ .enumerate()+ .map(|(idx, arg)| {+ Field::new(format!("arg_{idx}"), arg.data_type(), true).into()+ })+ .collect();+ let scalar_arguments = vec![None; arg_fields.len()];+ let return_field = function+ .return_field_from_args(ReturnFieldArgs {+ arg_fields: &arg_fields,+ scalar_arguments: &scalar_arguments,+ })+ .expect("should resolve return field");++ group.bench_function(format!("{array_type} {case_name}"), |b| {+ b.iter(|| {+ black_box(+ function+ .invoke_with_args(ScalarFunctionArgs {+ args: args.clone(),+ arg_fields: arg_fields.clone(),+ number_rows: BATCH_SIZE,+ return_field: Arc::clone(&return_field),+ config_options: Arc::clone(&config_options),+ })+ .expect("should work"),+ )+ })+ });+ }}group.finish();diff --git a/datafusion/functions/benches/string_expressions/trim.rs b/datafusion/functions/benches/string_expressions/trim.rsindex 9970cf2f80..bc318758f9 100644--- a/datafusion/functions/benches/string_expressions/trim.rs+++ b/datafusion/functions/benches/string_expressions/trim.rs@@ -15,418 +15,161 @@// specific language governing permissions and limitations// under the License.-use arrow::array::{ArrayRef, LargeStringArray, StringArray, StringViewArray};-use arrow::datatypes::{DataType, Field};-use criterion::{- BenchmarkGroup, Criterion, SamplingMode, criterion_group, measurement::Measurement,-};-use datafusion_common::ScalarValue;-use datafusion_common::config::ConfigOptions;-use datafusion_expr::{ColumnarValue, ScalarFunctionArgs, ScalarUDF};-use datafusion_functions::string;-use rand::{Rng, SeedableRng, distr::Alphanumeric, rngs::StdRng};use std::hint::black_box;-use std::{fmt, sync::Arc};--#[derive(Clone, Copy)]-pub enum StringArrayType {- Utf8View,- Utf8,- LargeUtf8,-}--impl fmt::Display for StringArrayType {- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {- match self {- StringArrayType::Utf8View => f.write_str("string_view"),- StringArrayType::Utf8 => f.write_str("string"),- StringArrayType::LargeUtf8 => f.write_str("large_string"),- }- }-}+use std::ops::RangeInclusive;+use std::sync::Arc;-#[derive(Clone, Copy)]-pub enum TrimType {- Ltrim,- Rtrim,- Btrim,+use arrow::array::{StringArray, StringViewArray};+use arrow::datatypes::Field;+use criterion::{Criterion, criterion_group};+use datafusion_common::ScalarValue;+use datafusion_common::config::ConfigOptions;+use datafusion_expr::{ColumnarValue, ReturnFieldArgs, ScalarFunctionArgs};+use datafusion_functions::string::{btrim, ltrim, rtrim};+use rand::distr::Alphanumeric;+use rand::rngs::StdRng;+use rand::{Rng, SeedableRng};++const BATCH_SIZE: usize = 8192;++/// The characters to trim.+enum Pattern {+ /// Spaces, as in `trim(s)`.+ Spaces,+ /// Any of the given characters, as in `trim(s, ',!()')`.+ Chars(&'static str),}-impl fmt::Display for TrimType {- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {- match self {- TrimType::Ltrim => f.write_str("ltrim"),- TrimType::Rtrim => f.write_str("rtrim"),- TrimType::Btrim => f.write_str("btrim"),- }+/// Returns strings of alphanumeric content, with padding to trim at the start+/// and/or end. Each row's content and padding lengths are drawn from the given+/// ranges.+fn create_strings(+ content_len: &RangeInclusive<usize>,+ pad_len: &RangeInclusive<usize>,+ pattern: &Pattern,+ pad_start: bool,+ pad_end: bool,+) -> Vec<Option<String>> {+ let mut rng = StdRng::seed_from_u64(42);+ let pad_chars = match pattern {+ Pattern::Spaces => " ",+ Pattern::Chars(chars) => chars,}-}--/// Returns an array of strings with trim characters positioned according to trim type,-/// and `characters` as a ScalarValue.-///-/// For ltrim: trim characters are at the start (prefix)-/// For rtrim: trim characters are at the end (suffix)-/// For btrim: trim characters are at both start and end-fn create_string_array_and_characters(- size: usize,- characters: &str,- trimmed: &str,- remaining_len: usize,- string_array_type: StringArrayType,- trim_type: TrimType,-) -> (ArrayRef, ScalarValue) {- let rng = &mut StdRng::seed_from_u64(42);+ .as_bytes();+ let padding = |rng: &mut StdRng| -> String {+ let len = rng.random_range(pad_len.clone());+ (0..len)+ .map(|_| pad_chars[rng.random_range(0..pad_chars.len())] as char)+ .collect()+ };- // Create `size` rows:- // - 10% rows will be `None`- // - Other 90% will be strings with `remaining_len` content length- let string_iter = (0..size).map(|_| {- if rng.random::<f32>() < 0.1 {- None- } else {- let content: String = rng+ (0..BATCH_SIZE)+ .map(|_| {+ if rng.random::<f32>() < 0.1 {+ return None;+ }+ let len = rng.random_range(content_len.clone());+ let content: String = (&mut rng).sample_iter(&Alphanumeric)- .take(remaining_len)+ .take(len).map(char::from).collect();-- let value = match trim_type {- TrimType::Ltrim => format!("{trimmed}{content}"),- TrimType::Rtrim => format!("{content}{trimmed}"),- TrimType::Btrim => format!("{trimmed}{content}{trimmed}"),+ let start = if pad_start {+ padding(&mut rng)+ } else {+ String::new()};- Some(value)- }- });-- // Build the target `string array` and `characters` according to `string_array_type`- match string_array_type {- StringArrayType::Utf8View => (- Arc::new(string_iter.collect::<StringViewArray>()),- ScalarValue::Utf8View(Some(characters.to_string())),- ),- StringArrayType::Utf8 => (- Arc::new(string_iter.collect::<StringArray>()),- ScalarValue::Utf8(Some(characters.to_string())),- ),- StringArrayType::LargeUtf8 => (- Arc::new(string_iter.collect::<LargeStringArray>()),- ScalarValue::LargeUtf8(Some(characters.to_string())),- ),- }-}--/// Create args for the trim benchmark-fn create_args(- size: usize,- characters: &str,- trimmed: &str,- remaining_len: usize,- string_array_type: StringArrayType,- trim_type: TrimType,-) -> Vec<ColumnarValue> {- let (string_array, pattern) = create_string_array_and_characters(- size,- characters,- trimmed,- remaining_len,- string_array_type,- trim_type,- );- vec![- ColumnarValue::Array(string_array),- ColumnarValue::Scalar(pattern),- ]-}--/// Create args for trim benchmark where space characters are being trimmed-fn create_space_trim_args(- size: usize,- pad_len: usize,- remaining_len: usize,- string_array_type: StringArrayType,- trim_type: TrimType,-) -> Vec<ColumnarValue> {- let rng = &mut StdRng::seed_from_u64(42);- let spaces = " ".repeat(pad_len);-- let string_iter = (0..size).map(|_| {- if rng.random::<f32>() < 0.1 {- None- } else {- let content: String = rng- .sample_iter(&Alphanumeric)- .take(remaining_len)- .map(char::from)- .collect();-- let value = match trim_type {- TrimType::Ltrim => format!("{spaces}{content}"),- TrimType::Rtrim => format!("{content}{spaces}"),- TrimType::Btrim => format!("{spaces}{content}{spaces}"),+ let end = if pad_end {+ padding(&mut rng)+ } else {+ String::new()};- Some(value)- }- });-- let string_array: ArrayRef = match string_array_type {- StringArrayType::Utf8View => Arc::new(string_iter.collect::<StringViewArray>()),- StringArrayType::Utf8 => Arc::new(string_iter.collect::<StringArray>()),- StringArrayType::LargeUtf8 => Arc::new(string_iter.collect::<LargeStringArray>()),- };-- vec![ColumnarValue::Array(string_array)]-}--#[expect(clippy::too_many_arguments)]-fn run_with_string_type<M: Measurement>(- group: &mut BenchmarkGroup<'_, M>,- trim_func: &ScalarUDF,- trim_type: TrimType,- size: usize,- total_len: usize,- characters: &str,- trimmed: &str,- remaining_len: usize,- string_type: StringArrayType,-) {- let args = create_args(- size,- characters,- trimmed,- remaining_len,- string_type,- trim_type,- );- let arg_fields = args- .iter()- .enumerate()- .map(|(idx, arg)| Field::new(format!("arg_{idx}"), arg.data_type(), true).into())- .collect::<Vec<_>>();- let config_options = Arc::new(ConfigOptions::default());-- group.bench_function(- format!(- "{trim_type} {string_type} [size={size}, len={total_len}, remaining={remaining_len}]",- ),- |b| {- b.iter(|| {- let args_cloned = args.clone();- black_box(trim_func.invoke_with_args(ScalarFunctionArgs {- args: args_cloned,- arg_fields: arg_fields.clone(),- number_rows: size,- return_field: Field::new("f", DataType::Utf8, true).into(),- config_options: Arc::clone(&config_options),- }))- })- },- );-}--#[expect(clippy::too_many_arguments)]-fn run_trim_benchmark(- c: &mut Criterion,- group_name: &str,- trim_func: &ScalarUDF,- trim_type: TrimType,- string_types: &[StringArrayType],- size: usize,- total_len: usize,- characters: &str,- trimmed: &str,- remaining_len: usize,-) {- let mut group = c.benchmark_group(group_name);- group.sampling_mode(SamplingMode::Flat);- group.sample_size(10);-- for string_type in string_types {- run_with_string_type(- &mut group,- trim_func,- trim_type,- size,- total_len,- characters,- trimmed,- remaining_len,- *string_type,- );- }-- group.finish();-}--#[expect(clippy::too_many_arguments)]-fn run_space_trim_benchmark(- c: &mut Criterion,- group_name: &str,- trim_func: &ScalarUDF,- trim_type: TrimType,- string_types: &[StringArrayType],- size: usize,- pad_len: usize,- remaining_len: usize,-) {- let mut group = c.benchmark_group(group_name);- group.sampling_mode(SamplingMode::Flat);- group.sample_size(10);-- let total_len = match trim_type {- TrimType::Btrim => 2 * pad_len + remaining_len,- _ => pad_len + remaining_len,- };-- for string_type in string_types {- let args =- create_space_trim_args(size, pad_len, remaining_len, *string_type, trim_type);- let arg_fields = args- .iter()- .enumerate()- .map(|(idx, arg)| {- Field::new(format!("arg_{idx}"), arg.data_type(), true).into()- })- .collect::<Vec<_>>();- let config_options = Arc::new(ConfigOptions::default());-- group.bench_function(- format!(- "{trim_type} {string_type} [size={size}, len={total_len}, pad={pad_len}]",- ),- |b| {- b.iter(|| {- let args_cloned = args.clone();- black_box(trim_func.invoke_with_args(ScalarFunctionArgs {- args: args_cloned,- arg_fields: arg_fields.clone(),- number_rows: size,- return_field: Field::new("f", DataType::Utf8, true).into(),- config_options: Arc::clone(&config_options),- }))- })- },- );- }-- group.finish();+ Some(format!("{start}{content}{end}"))+ })+ .collect()}fn criterion_benchmark(c: &mut Criterion) {- let ltrim = string::ltrim();- let rtrim = string::rtrim();- let btrim = string::btrim();-- let characters = ",!()";-- let string_types = [- StringArrayType::Utf8View,- StringArrayType::Utf8,- StringArrayType::LargeUtf8,- ];-- let trim_funcs = [- (<rim, TrimType::Ltrim),- (&rtrim, TrimType::Rtrim),- (&btrim, TrimType::Btrim),+ // Content and padding lengths vary within each case, as in real data: with+ // fixed lengths, per-row work that depends on them is unrealistically+ // predictable.+ let cases = [+ // A little padding. Results of up to 12 bytes are stored inline in+ // StringView arrays, and longer ones out of line.+ ("spaces", 1..=64, 0..=8, Pattern::Spaces),+ // Short values padded to a long width, as in `CHAR(n)` data.+ ("heavy_padding", 1..=12, 32..=64, Pattern::Spaces),+ // Values that are already trimmed.+ ("nothing_to_trim", 1..=64, 0..=0, Pattern::Spaces),+ // Short values with long padding made of several different characters.+ ("char_set", 1..=12, 32..=64, Pattern::Chars(",!()")),];+ let config_options = Arc::new(ConfigOptions::default());- for size in [4096] {- for (trim_func, trim_type) in &trim_funcs {- // Scenario 1: Short strings (len <= 12, inline in StringView)- // trimmed_len=4, remaining_len=8- let total_len = 12;- let trimmed = characters;- let remaining_len = total_len - trimmed.len();- run_trim_benchmark(- c,- "short strings (len <= 12)",- trim_func,- *trim_type,- &string_types,- size,- total_len,- characters,- trimmed,- remaining_len,- );-- // Scenario 2: Long strings, short trim (len > 12, output > 12)- // trimmed_len=4, remaining_len=60- let total_len = 64;- let trimmed = characters;- let remaining_len = total_len - trimmed.len();- run_trim_benchmark(- c,- "long strings, short trim",- trim_func,- *trim_type,- &string_types,- size,- total_len,- characters,- trimmed,- remaining_len,- );-- // Scenario 3: Long strings, long trim (len > 12, output <= 12)- // trimmed_len=56, remaining_len=8- let total_len = 64;- let trimmed = characters.repeat(14);- let remaining_len = total_len - trimmed.len();- run_trim_benchmark(- c,- "long strings, long trim",- trim_func,- *trim_type,- &string_types,- size,- total_len,- characters,- &trimmed,- remaining_len,- );-- // Scenario 4: Trim spaces, short strings (len <= 12)- // pad_len=4, remaining_len=8- run_space_trim_benchmark(- c,- "trim spaces, short strings (len <= 12)",- trim_func,- *trim_type,- &string_types,- size,- 4,- 8,- );-- // Scenario 5: Trim spaces, long strings (len > 12)- // pad_len=4, remaining_len=60- run_space_trim_benchmark(- c,- "trim spaces, long strings",- trim_func,- *trim_type,- &string_types,- size,- 4,- 60,- );+ for (function, pad_start, pad_end) in [+ (ltrim(), true, false),+ (rtrim(), false, true),+ (btrim(), true, true),+ ] {+ let mut group = c.benchmark_group(function.name().to_string());++ for is_string_view in [false, true] {+ let array_type = if is_string_view {+ "string_view"+ } else {+ "string"+ };- // Scenario 6: Trim spaces, long strings, heavy padding- // pad_len=56, remaining_len=8- run_space_trim_benchmark(- c,- "trim spaces, heavy padding",- trim_func,- *trim_type,- &string_types,- size,- 56,- 8,- );+ for (case_name, content_len, pad_len, pattern) in &cases {+ let strings =+ create_strings(content_len, pad_len, pattern, pad_start, pad_end);+ let mut args = vec![if is_string_view {+ ColumnarValue::Array(Arc::new(+ strings.into_iter().collect::<StringViewArray>(),+ ))+ } else {+ ColumnarValue::Array(Arc::new(+ strings.into_iter().collect::<StringArray>(),+ ))+ }];+ if let Pattern::Chars(chars) = pattern {+ args.push(ColumnarValue::Scalar(ScalarValue::from(*chars)));+ }++ let arg_fields: Vec<_> = args+ .iter()+ .enumerate()+ .map(|(idx, arg)| {+ Field::new(format!("arg_{idx}"), arg.data_type(), true).into()+ })+ .collect();+ let scalar_arguments = vec![None; arg_fields.len()];+ let return_field = function+ .return_field_from_args(ReturnFieldArgs {+ arg_fields: &arg_fields,+ scalar_arguments: &scalar_arguments,+ })+ .expect("should resolve return field");++ group.bench_function(format!("{array_type} {case_name}"), |b| {+ b.iter(|| {+ black_box(+ function+ .invoke_with_args(ScalarFunctionArgs {+ args: args.clone(),+ arg_fields: arg_fields.clone(),+ number_rows: BATCH_SIZE,+ return_field: Arc::clone(&return_field),+ config_options: Arc::clone(&config_options),+ })+ .expect("should work"),+ )+ })+ });+ }}++ group.finish();}}diff --git a/datafusion/functions/benches/unicode_expressions/substr.rs b/datafusion/functions/benches/unicode_expressions/substr.rsindex a59dd7a007..571eee39a3 100644--- a/datafusion/functions/benches/unicode_expressions/substr.rs+++ b/datafusion/functions/benches/unicode_expressions/substr.rs@@ -15,279 +15,152 @@// specific language governing permissions and limitations// under the License.-use arrow::array::{ArrayRef, Int64Array, OffsetSizeTrait};-use arrow::datatypes::{DataType, Field};-use arrow::util::bench_util::{- create_string_array_with_len, create_string_view_array_with_len,-};-use criterion::{Criterion, SamplingMode, criterion_group};-use datafusion_common::config::ConfigOptions;-use datafusion_common::{DataFusionError, ScalarValue};-use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};-use datafusion_functions::unicode;use std::hint::black_box;+use std::ops::{Range, RangeInclusive};use std::sync::Arc;-fn make_i64_arg(value: i64, size: usize, as_scalar: bool) -> ColumnarValue {- if as_scalar {- ColumnarValue::Scalar(ScalarValue::from(value))- } else {- ColumnarValue::Array(Arc::new(Int64Array::from(vec![value; size])))- }-}+use arrow::array::StringViewArray;+use arrow::datatypes::{Field, Int64Type};+use arrow::util::bench_util::{+ create_primitive_array_range, create_string_array_with_len_range_and_prefix_and_seed,+};+use criterion::{Criterion, criterion_group};+use datafusion_common::ScalarValue;+use datafusion_common::config::ConfigOptions;+use datafusion_expr::{ColumnarValue, ReturnFieldArgs, ScalarFunctionArgs};+use datafusion_functions::unicode::substr;-fn create_args_without_count<O: OffsetSizeTrait>(- size: usize,- str_len: usize,- start_half_way: bool,- force_view_types: bool,- scalar_start: bool,-) -> Vec<ColumnarValue> {- let start_val = if start_half_way {- (str_len / 2) as i64- } else {- 1i64- };- let start = make_i64_arg(start_val, size, scalar_start);+const BATCH_SIZE: usize = 8192;- let string_array: ArrayRef = if force_view_types {- Arc::new(create_string_view_array_with_len(size, 0.1, str_len, false))- } else {- Arc::new(create_string_array_with_len::<O>(size, 0.1, str_len))- };+/// How an integer argument is passed.+enum IntArg {+ /// The same value for every row, as in `substr(s, 1, 5)`.+ Scalar(i64),+ /// A different value for each row, drawn from the range.+ PerRow(Range<i64>),+}- vec![ColumnarValue::Array(string_array), start]+impl IntArg {+ fn to_columnar_value(&self) -> ColumnarValue {+ match self {+ IntArg::Scalar(value) => {+ ColumnarValue::Scalar(ScalarValue::Int64(Some(*value)))+ }+ IntArg::PerRow(range) => ColumnarValue::Array(Arc::new(+ create_primitive_array_range::<Int64Type>(BATCH_SIZE, 0.0, range.clone()),+ )),+ }+ }}-fn create_args_with_count<O: OffsetSizeTrait>(- size: usize,- str_len: usize,- count_max: usize,- force_view_types: bool,- scalar_args: bool,+fn create_args(+ str_len: &RangeInclusive<usize>,+ start: &IntArg,+ count: Option<&IntArg>,+ is_string_view: bool,) -> Vec<ColumnarValue> {- let count = count_max.min(str_len) as i64;- let start = make_i64_arg(1i64, size, scalar_args);- let count = make_i64_arg(count, size, scalar_args);-- let string_array: ArrayRef = if force_view_types {- Arc::new(create_string_view_array_with_len(size, 0.1, str_len, false))+ let strings = create_string_array_with_len_range_and_prefix_and_seed::<i32>(+ BATCH_SIZE,+ 0.1,+ *str_len.start(),+ *str_len.end(),+ "",+ 42,+ );+ let string_arg = if is_string_view {+ ColumnarValue::Array(Arc::new(strings.iter().collect::<StringViewArray>()))} else {- Arc::new(create_string_array_with_len::<O>(size, 0.1, str_len))+ ColumnarValue::Array(Arc::new(strings))};- vec![ColumnarValue::Array(string_array), start, count]-}--#[expect(clippy::needless_pass_by_value)]-fn invoke_substr_with_args(- args: Vec<ColumnarValue>,- number_rows: usize,-) -> Result<ColumnarValue, DataFusionError> {- let arg_fields = args- .iter()- .enumerate()- .map(|(idx, arg)| Field::new(format!("arg_{idx}"), arg.data_type(), true).into())- .collect::<Vec<_>>();- let config_options = Arc::new(ConfigOptions::default());-- unicode::substr().invoke_with_args(ScalarFunctionArgs {- args: args.clone(),- arg_fields,- number_rows,- return_field: Field::new("f", DataType::Utf8View, true).into(),- config_options: Arc::clone(&config_options),- })+ let mut args = vec![string_arg, start.to_columnar_value()];+ args.extend(count.map(IntArg::to_columnar_value));+ args}fn criterion_benchmark(c: &mut Criterion) {- for size in [1024, 4096] {- // string_len = 12, substring_len=6 (see `create_args_without_count`)- let len = 12;- let mut group = c.benchmark_group("substr, no count, short strings");- group.sampling_mode(SamplingMode::Flat);- group.sample_size(10);-- let args = create_args_without_count::<i32>(size, len, true, true, false);- group.bench_function(- format!("substr_string_view [size={size}, strlen={len}]"),- |b| b.iter(|| black_box(invoke_substr_with_args(args.clone(), size))),- );-- let args = create_args_without_count::<i32>(size, len, false, false, false);- group.bench_function(format!("substr_string [size={size}, strlen={len}]"), |b| {- b.iter(|| black_box(invoke_substr_with_args(args.clone(), size)))- });-- let args = create_args_without_count::<i64>(size, len, true, false, false);- group.bench_function(- format!("substr_large_string [size={size}, strlen={len}]"),- |b| b.iter(|| black_box(invoke_substr_with_args(args.clone(), size))),- );-- group.finish();-- // string_len = 128, start=1, count=64, substring_len=64- let len = 128;- let count = 64;- let mut group = c.benchmark_group("substr, with count, long strings");- group.sampling_mode(SamplingMode::Flat);- group.sample_size(10);-- let args = create_args_with_count::<i32>(size, len, count, true, false);- group.bench_function(- format!("substr_string_view [size={size}, count={count}, strlen={len}]"),- |b| b.iter(|| black_box(invoke_substr_with_args(args.clone(), size))),- );-- let args = create_args_with_count::<i32>(size, len, count, false, false);- group.bench_function(- format!("substr_string [size={size}, count={count}, strlen={len}]"),- |b| b.iter(|| black_box(invoke_substr_with_args(args.clone(), size))),- );-- let args = create_args_with_count::<i64>(size, len, count, false, false);- group.bench_function(- format!("substr_large_string [size={size}, count={count}, strlen={len}]"),- |b| b.iter(|| black_box(invoke_substr_with_args(args.clone(), size))),- );-- group.finish();-- // string_len = 128, start=1, count=6, substring_len=6- let len = 128;- let count = 6;- let mut group = c.benchmark_group("substr, short count, long strings");- group.sampling_mode(SamplingMode::Flat);- group.sample_size(10);-- let args = create_args_with_count::<i32>(size, len, count, true, false);- group.bench_function(- format!("substr_string_view [size={size}, count={count}, strlen={len}]"),- |b| b.iter(|| black_box(invoke_substr_with_args(args.clone(), size))),- );-- let args = create_args_with_count::<i32>(size, len, count, false, false);- group.bench_function(- format!("substr_string [size={size}, count={count}, strlen={len}]"),- |b| b.iter(|| black_box(invoke_substr_with_args(args.clone(), size))),- );-- let args = create_args_with_count::<i64>(size, len, count, false, false);- group.bench_function(- format!("substr_large_string [size={size}, count={count}, strlen={len}]"),- |b| b.iter(|| black_box(invoke_substr_with_args(args.clone(), size))),- );-- group.finish();-- // Scalar start, no count, short strings- let len = 12;- let mut group =- c.benchmark_group("substr, scalar start, no count, short strings");- group.sampling_mode(SamplingMode::Flat);- group.sample_size(10);-- let args = create_args_without_count::<i32>(size, len, true, true, true);- group.bench_function(- format!("substr_string_view [size={size}, strlen={len}]"),- |b| b.iter(|| black_box(invoke_substr_with_args(args.clone(), size))),- );-- let args = create_args_without_count::<i32>(size, len, false, false, true);- group.bench_function(format!("substr_string [size={size}, strlen={len}]"), |b| {- b.iter(|| black_box(invoke_substr_with_args(args.clone(), size)))- });-- group.finish();-- // Scalar start, no count, long strings, start near middle- let len = 128;- let mut group = c.benchmark_group("substr, scalar start, no count, long strings");- group.sampling_mode(SamplingMode::Flat);- group.sample_size(10);-- let args = create_args_without_count::<i32>(size, len, true, true, true);- group.bench_function(- format!("substr_string_view [size={size}, strlen={len}]"),- |b| b.iter(|| black_box(invoke_substr_with_args(args.clone(), size))),- );-- let args = create_args_without_count::<i32>(size, len, false, false, true);- group.bench_function(format!("substr_string [size={size}, strlen={len}]"), |b| {- b.iter(|| black_box(invoke_substr_with_args(args.clone(), size)))- });-- group.finish();-- // Scalar start=1, no count, long strings- let len = 128;- let mut group =- c.benchmark_group("substr, scalar start=1, no count, long strings");- group.sampling_mode(SamplingMode::Flat);- group.sample_size(10);-- let args = create_args_without_count::<i32>(size, len, false, true, true);- group.bench_function(- format!("substr_string_view [size={size}, strlen={len}]"),- |b| b.iter(|| black_box(invoke_substr_with_args(args.clone(), size))),- );-- let args = create_args_without_count::<i32>(size, len, false, false, true);- group.bench_function(format!("substr_string [size={size}, strlen={len}]"), |b| {- b.iter(|| black_box(invoke_substr_with_args(args.clone(), size)))- });-- group.finish();-- // Scalar start and count, short strings- let len = 12;- let count = 6;- let mut group = c.benchmark_group("substr, scalar args, short strings");- group.sampling_mode(SamplingMode::Flat);- group.sample_size(10);-- let args = create_args_with_count::<i32>(size, len, count, true, true);- group.bench_function(- format!("substr_string_view [size={size}, count={count}, strlen={len}]"),- |b| b.iter(|| black_box(invoke_substr_with_args(args.clone(), size))),- );-- let args = create_args_with_count::<i32>(size, len, count, false, true);- group.bench_function(- format!("substr_string [size={size}, count={count}, strlen={len}]"),- |b| b.iter(|| black_box(invoke_substr_with_args(args.clone(), size))),- );-- group.finish();-- // Scalar start and count, long strings- let len = 128;- let count = 64;- let mut group = c.benchmark_group("substr, scalar args, long strings");- group.sampling_mode(SamplingMode::Flat);- group.sample_size(10);-- let args = create_args_with_count::<i32>(size, len, count, true, true);- group.bench_function(- format!("substr_string_view [size={size}, count={count}, strlen={len}]"),- |b| b.iter(|| black_box(invoke_substr_with_args(args.clone(), size))),- );-- let args = create_args_with_count::<i32>(size, len, count, false, true);- group.bench_function(- format!("substr_string [size={size}, count={count}, strlen={len}]"),- |b| b.iter(|| black_box(invoke_substr_with_args(args.clone(), size))),- );-- let args = create_args_with_count::<i64>(size, len, count, false, true);- group.bench_function(- format!("substr_large_string [size={size}, count={count}, strlen={len}]"),- |b| b.iter(|| black_box(invoke_substr_with_args(args.clone(), size))),- );-- group.finish();+ // Input lengths vary within each case, as in real data: with fixed-length+ // inputs, per-row work that depends on the input length is unrealistically+ // predictable.+ let cases = [+ // Results of up to 5 chars, stored inline in StringView arrays (≤12 bytes).+ (+ "short_result",+ 1..=32,+ IntArg::Scalar(1),+ Some(IntArg::Scalar(5)),+ ),+ // 25-char results, stored out of line.+ (+ "long_result",+ 32..=64,+ IntArg::Scalar(5),+ Some(IntArg::Scalar(25)),+ ),+ // Short results from long inputs.+ (+ "short_result_long_input",+ 96..=256,+ IntArg::Scalar(1),+ Some(IntArg::Scalar(5)),+ ),+ // No count, so each result runs to the end of the input.+ ("no_count", 1..=64, IntArg::Scalar(5), None),+ // `start` computed per row, as in `substr(s, strpos(s, ':') + 1, 8)`.+ (+ "per_row_start",+ 1..=32,+ IntArg::PerRow(1..11),+ Some(IntArg::Scalar(8)),+ ),+ ];+ let function = substr();+ let config_options = Arc::new(ConfigOptions::default());+ let mut group = c.benchmark_group(function.name().to_string());++ for is_string_view in [false, true] {+ let array_type = if is_string_view {+ "string_view"+ } else {+ "string"+ };++ for (case_name, str_len, start, count) in &cases {+ let args = create_args(str_len, start, count.as_ref(), is_string_view);+ let arg_fields: Vec<_> = args+ .iter()+ .enumerate()+ .map(|(idx, arg)| {+ Field::new(format!("arg_{idx}"), arg.data_type(), true).into()+ })+ .collect();+ let scalar_arguments = vec![None; arg_fields.len()];+ let return_field = function+ .return_field_from_args(ReturnFieldArgs {+ arg_fields: &arg_fields,+ scalar_arguments: &scalar_arguments,+ })+ .expect("should resolve return field");++ group.bench_function(format!("{array_type} {case_name}"), |b| {+ b.iter(|| {+ black_box(+ function+ .invoke_with_args(ScalarFunctionArgs {+ args: args.clone(),+ arg_fields: arg_fields.clone(),+ number_rows: BATCH_SIZE,+ return_field: Arc::clone(&return_field),+ config_options: Arc::clone(&config_options),+ })+ .expect("should work"),+ )+ })+ });+ }}++ group.finish();}criterion_group!(benches, criterion_benchmark);diff --git a/datafusion/functions/benches/unicode_expressions/substr_index.rs b/datafusion/functions/benches/unicode_expressions/substr_index.rsindex fb5e77cfa0..432d2536bb 100644--- a/datafusion/functions/benches/unicode_expressions/substr_index.rs+++ b/datafusion/functions/benches/unicode_expressions/substr_index.rs@@ -30,6 +30,7 @@ use rand::distr::{Alphanumeric, Uniform};use rand::prelude::Distribution;use rand::rngs::StdRng;+const BATCH_SIZE: usize = 8192;const ARRAY_DATA_SEED: u64 = 0x5EED_AAAA;const SCALAR_DATA_SEED: u64 = 0x5EED_BBBB;@@ -101,20 +102,17 @@ fn random_token<R: Rng + ?Sized>(rng: &mut R, len: usize) -> String {.collect()}-fn array_data(- batch_size: usize,- single_char_delimiter: bool,-) -> (Vec<String>, Vec<String>, Vec<i64>) {+fn array_data(single_char_delimiter: bool) -> (Vec<String>, Vec<String>, Vec<i64>) {let count_dist = Filter {dist: Uniform::new(-4, 5).expect("valid count distribution"),test: |x: &i64| x != &0,};let mut rng = StdRng::seed_from_u64(ARRAY_DATA_SEED);- let mut strings = Vec::with_capacity(batch_size);- let mut delimiters = Vec::with_capacity(batch_size);- let mut counts = Vec::with_capacity(batch_size);+ let mut strings = Vec::with_capacity(BATCH_SIZE);+ let mut delimiters = Vec::with_capacity(BATCH_SIZE);+ let mut counts = Vec::with_capacity(BATCH_SIZE);- for _ in 0..batch_size {+ for _ in 0..BATCH_SIZE {let length = rng.random_range(20..50);let base = random_token(&mut rng, length);@@ -146,11 +144,11 @@ fn array_data((strings, delimiters, counts)}-fn scalar_data(batch_size: usize, delimiter: &str) -> Vec<String> {+fn scalar_data(delimiter: &str) -> Vec<String> {let mut rng = StdRng::seed_from_u64(SCALAR_DATA_SEED);- let mut strings = Vec::with_capacity(batch_size);+ let mut strings = Vec::with_capacity(BATCH_SIZE);- for _ in 0..batch_size {+ for _ in 0..BATCH_SIZE {let left_len = rng.random_range(12..24);let middle_len = rng.random_range(12..24);let right_len = rng.random_range(12..24);@@ -167,7 +165,6 @@ fn run_benchmark(b: &mut criterion::Bencher,args: &[ColumnarValue],return_type: &DataType,- number_rows: usize,) {let arg_fields = args.iter()@@ -184,7 +181,7 @@ fn run_benchmark(.invoke_with_args(ScalarFunctionArgs {args: args.to_vec(),arg_fields: arg_fields.clone(),- number_rows,+ number_rows: BATCH_SIZE,return_field: Field::new("f", return_type.clone(), true).into(),config_options: Arc::clone(&config_options),})@@ -195,61 +192,50 @@ fn run_benchmark(fn criterion_benchmark(c: &mut Criterion) {let mut group = c.benchmark_group("substr_index");- let batch_sizes = [100, 1000, 10_000];-- for batch_size in batch_sizes {- for rep in [StringRep::Utf8, StringRep::Utf8View] {- let rep_name = rep.name();-- group.bench_function(- format!("substr_index_{rep_name}_{batch_size}_array_single_delimiter"),- |b| {- let (strings, delimiters, counts) = array_data(batch_size, true);- let args = vec![- ColumnarValue::Array(rep.array(&strings)),- ColumnarValue::Array(rep.array(&delimiters)),- ColumnarValue::Array(- Arc::new(Int64Array::from(counts)) as ArrayRef- ),- ];- run_benchmark(b, &args, &rep.data_type(), batch_size);- },- );-- group.bench_function(- format!("substr_index_{rep_name}_{batch_size}_array_long_delimiter"),- |b| {- let (strings, delimiters, counts) = array_data(batch_size, false);- let args = vec![- ColumnarValue::Array(rep.array(&strings)),- ColumnarValue::Array(rep.array(&delimiters)),- ColumnarValue::Array(- Arc::new(Int64Array::from(counts)) as ArrayRef- ),- ];- run_benchmark(b, &args, &rep.data_type(), batch_size);- },- );-- for (name, delimiter, count) in [- ("single_delimiter_pos", ".", 1_i64),- ("single_delimiter_neg", ".", -1_i64),- ("long_delimiter_pos", "|||", 1_i64),- ("long_delimiter_neg", "|||", -1_i64),- ] {- group.bench_function(- format!("substr_index_{rep_name}_{batch_size}_scalar_{name}"),- |b| {- let strings = scalar_data(batch_size, delimiter);- let args = vec![- ColumnarValue::Array(rep.array(&strings)),- ColumnarValue::Scalar(rep.scalar(delimiter)),- ColumnarValue::Scalar(ScalarValue::Int64(Some(count))),- ];- run_benchmark(b, &args, &rep.data_type(), batch_size);- },- );- }+ for rep in [StringRep::Utf8, StringRep::Utf8View] {+ let rep_name = rep.name();++ group.bench_function(+ format!("substr_index_{rep_name}_array_single_delimiter"),+ |b| {+ let (strings, delimiters, counts) = array_data(true);+ let args = vec![+ ColumnarValue::Array(rep.array(&strings)),+ ColumnarValue::Array(rep.array(&delimiters)),+ ColumnarValue::Array(Arc::new(Int64Array::from(counts)) as ArrayRef),+ ];+ run_benchmark(b, &args, &rep.data_type());+ },+ );++ group.bench_function(+ format!("substr_index_{rep_name}_array_long_delimiter"),+ |b| {+ let (strings, delimiters, counts) = array_data(false);+ let args = vec![+ ColumnarValue::Array(rep.array(&strings)),+ ColumnarValue::Array(rep.array(&delimiters)),+ ColumnarValue::Array(Arc::new(Int64Array::from(counts)) as ArrayRef),+ ];+ run_benchmark(b, &args, &rep.data_type());+ },+ );++ for (name, delimiter, count) in [+ ("single_delimiter_pos", ".", 1_i64),+ ("single_delimiter_neg", ".", -1_i64),+ ("long_delimiter_pos", "|||", 1_i64),+ ("long_delimiter_neg", "|||", -1_i64),+ ] {+ group.bench_function(format!("substr_index_{rep_name}_scalar_{name}"), |b| {+ let strings = scalar_data(delimiter);+ let args = vec![+ ColumnarValue::Array(rep.array(&strings)),+ ColumnarValue::Scalar(rep.scalar(delimiter)),+ ColumnarValue::Scalar(ScalarValue::Int64(Some(count))),+ ];+ run_benchmark(b, &args, &rep.data_type());+ });}}diff --git a/datafusion/functions/src/string/common.rs b/datafusion/functions/src/string/common.rsindex 0bc63afa6a..f2544fa386 100644--- a/datafusion/functions/src/string/common.rs+++ b/datafusion/functions/src/string/common.rs@@ -21,7 +21,7 @@ use std::sync::Arc;use crate::strings::{GenericStringArrayBuilder, STRING_VIEW_INIT_BLOCK_SIZE, STRING_VIEW_MAX_BLOCK_SIZE,- StringViewArrayBuilder, StringWriter, append_view,+ StringViewArrayBuilder, StringWriter, substr_view,};use arrow::array::{Array, ArrayRef, AsArray, GenericStringArray, NullBufferBuilder, OffsetSizeTrait,@@ -37,15 +37,14 @@ use datafusion_expr::ColumnarValue;/// Trait for trim operations, allowing compile-time dispatch instead of runtime matching.///-/// Each implementation performs its specific trim operation and returns-/// (trimmed_str, start_offset) where start_offset is the byte offset-/// from the beginning of the input string where the trimmed result starts.+/// Each implementation performs its specific trim operation and returns the+/// trimmed slice of the input.pub(crate) trait Trimmer {- fn trim<'a>(input: &'a str, pattern: &[char]) -> (&'a str, u32);+ fn trim<'a>(input: &'a str, pattern: &[char]) -> &'a str;/// Optimized trim for a single ASCII byte./// Uses byte-level scanning instead of char-level iteration.- fn trim_ascii_char(input: &str, byte: u8) -> (&str, u32);+ fn trim_ascii_char(input: &str, byte: u8) -> &str;}/// Returns the number of leading bytes matching `byte`@@ -65,19 +64,16 @@ pub(crate) struct TrimLeft;impl Trimmer for TrimLeft {#[inline]- fn trim<'a>(input: &'a str, pattern: &[char]) -> (&'a str, u32) {+ fn trim<'a>(input: &'a str, pattern: &[char]) -> &'a str {if pattern.len() == 1 && pattern[0].is_ascii() {return Self::trim_ascii_char(input, pattern[0] as u8);}- let trimmed = input.trim_start_matches(pattern);- let offset = (input.len() - trimmed.len()) as u32;- (trimmed, offset)+ input.trim_start_matches(pattern)}#[inline]- fn trim_ascii_char(input: &str, byte: u8) -> (&str, u32) {- let start = leading_bytes(input.as_bytes(), byte);- (&input[start..], start as u32)+ fn trim_ascii_char(input: &str, byte: u8) -> &str {+ &input[leading_bytes(input.as_bytes(), byte)..]}}@@ -86,19 +82,17 @@ pub(crate) struct TrimRight;impl Trimmer for TrimRight {#[inline]- fn trim<'a>(input: &'a str, pattern: &[char]) -> (&'a str, u32) {+ fn trim<'a>(input: &'a str, pattern: &[char]) -> &'a str {if pattern.len() == 1 && pattern[0].is_ascii() {return Self::trim_ascii_char(input, pattern[0] as u8);}- let trimmed = input.trim_end_matches(pattern);- (trimmed, 0)+ input.trim_end_matches(pattern)}#[inline]- fn trim_ascii_char(input: &str, byte: u8) -> (&str, u32) {+ fn trim_ascii_char(input: &str, byte: u8) -> &str {let bytes = input.as_bytes();- let end = bytes.len() - trailing_bytes(bytes, byte);- (&input[..end], 0)+ &input[..bytes.len() - trailing_bytes(bytes, byte)]}}@@ -107,22 +101,19 @@ pub(crate) struct TrimBoth;impl Trimmer for TrimBoth {#[inline]- fn trim<'a>(input: &'a str, pattern: &[char]) -> (&'a str, u32) {+ fn trim<'a>(input: &'a str, pattern: &[char]) -> &'a str {if pattern.len() == 1 && pattern[0].is_ascii() {return Self::trim_ascii_char(input, pattern[0] as u8);}- let left_trimmed = input.trim_start_matches(pattern);- let offset = (input.len() - left_trimmed.len()) as u32;- let trimmed = left_trimmed.trim_end_matches(pattern);- (trimmed, offset)+ input.trim_matches(pattern)}#[inline]- fn trim_ascii_char(input: &str, byte: u8) -> (&str, u32) {+ fn trim_ascii_char(input: &str, byte: u8) -> &str {let bytes = input.as_bytes();let start = leading_bytes(bytes, byte);let end = bytes.len() - trailing_bytes(&bytes[start..], byte);- (&input[start..end], start as u32)+ &input[start..end]}}@@ -155,8 +146,8 @@ fn string_view_trim<Tr: Trimmer>(args: &[ArrayRef]) -> Result<ArrayRef> {.zip(string_view_array.views().iter()){if let Some(src_str) = src_str_opt {- let (trimmed, offset) = Tr::trim_ascii_char(src_str, b' ');- append_view(&mut views_buf, raw_view, trimmed, offset);+ let trimmed = Tr::trim_ascii_char(src_str, b' ');+ views_buf.push(substr_view(*raw_view, src_str, trimmed));null_builder.append_non_null();} else {null_builder.append_null();@@ -202,8 +193,8 @@ fn string_view_trim<Tr: Trimmer>(args: &[ArrayRef]) -> Result<ArrayRef> {{pattern.clear();pattern.extend(characters.chars());- let (trimmed, offset) = Tr::trim(src_str, &pattern);- append_view(&mut views_buf, raw_view, trimmed, offset);+ let trimmed = Tr::trim(src_str, &pattern);+ views_buf.push(substr_view(*raw_view, src_str, trimmed));null_builder.append_non_null();} else {null_builder.append_null();@@ -254,8 +245,8 @@ fn trim_and_append_view<Tr: Trimmer>(original_view: &u128,) {if let Some(src_str) = src_str_opt {- let (trimmed, offset) = Tr::trim(src_str, pattern);- append_view(views_buf, original_view, trimmed, offset);+ let trimmed = Tr::trim(src_str, pattern);+ views_buf.push(substr_view(*original_view, src_str, trimmed));null_builder.append_non_null();} else {null_builder.append_null();@@ -332,7 +323,7 @@ fn string_trim<T: OffsetSizeTrait, Tr: Trimmer>(args: &[ArrayRef]) -> Result<ArrOk(build_trimmed(string_array,string_array.nulls().cloned(),- |_, s| Tr::trim_ascii_char(s, b' ').0,+ |_, s| Tr::trim_ascii_char(s, b' '),))}2 => {@@ -351,7 +342,7 @@ fn string_trim<T: OffsetSizeTrait, Tr: Trimmer>(args: &[ArrayRef]) -> Result<Arrreturn Ok(build_trimmed(string_array,string_array.nulls().cloned(),- |_, s| Tr::trim(s, &pattern).0,+ |_, s| Tr::trim(s, &pattern),));}@@ -371,7 +362,7 @@ fn string_trim<T: OffsetSizeTrait, Tr: Trimmer>(args: &[ArrayRef]) -> Result<ArrOk(build_trimmed(string_array, nulls, |i, s| {pattern.clear();pattern.extend(characters_array.value(i).chars());- Tr::trim(s, &pattern).0+ Tr::trim(s, &pattern)}))}other => {diff --git a/datafusion/functions/src/string/split_part.rs b/datafusion/functions/src/string/split_part.rsindex 401f248a24..9293574d16 100644--- a/datafusion/functions/src/string/split_part.rs+++ b/datafusion/functions/src/string/split_part.rs@@ -17,11 +17,12 @@use crate::strings::{BulkNullStringArrayBuilder, GenericStringArrayBuilder, StringViewArrayBuilder,+ substr_view,};use crate::utils::utf8_to_str_type;use arrow::array::{- Array, ArrayRef, AsArray, ByteView, Int64Array, StringArrayType, StringViewArray,- make_view, new_null_array,+ Array, ArrayRef, AsArray, Int64Array, StringArrayType, StringViewArray, make_view,+ new_null_array,};use arrow::buffer::{NullBuffer, ScalarBuffer};use arrow::datatypes::DataType;@@ -503,22 +504,6 @@ fn split_part_scalar_view(}}-/// Creates a `StringView` referencing a substring of an existing view's buffer.-/// For substrings ≤ 12 bytes, creates an inline view instead.-#[inline]-fn substr_view(original_view: &u128, substr: &str, start_offset: u32) -> u128 {- if substr.len() > 12 {- let view = ByteView::from(*original_view);- make_view(- substr.as_bytes(),- view.buffer_index,- view.offset + start_offset,- )- } else {- make_view(substr.as_bytes(), 0, 0)- }-}-/// Applies `split_fn` to each non-null string and appends the resulting view to/// `views_buf`.#[inline(always)]@@ -538,10 +523,7 @@ fn split_view_loop<F>(}let string = string_view_array.value(i);match split_fn(string) {- Some(substr) => {- let start_offset = substr.as_ptr() as usize - string.as_ptr() as usize;- views_buf.push(substr_view(raw_view, substr, start_offset as u32));- }+ Some(substr) => views_buf.push(substr_view(*raw_view, string, substr)),None => views_buf.push(empty_view),}}diff --git a/datafusion/functions/src/strings.rs b/datafusion/functions/src/strings.rsindex 96084474ff..ed99680ec7 100644--- a/datafusion/functions/src/strings.rs+++ b/datafusion/functions/src/strings.rs@@ -1181,44 +1181,6 @@ impl BulkNullStringArrayBuilder for StringViewArrayBuilder {}}-/// Append a new view to the views buffer with the given substr.-///-/// Callers are responsible for their own null tracking.-///-/// # Safety-///-/// original_view must be a valid view (the format described on-/// [`GenericByteViewArray`](arrow::array::GenericByteViewArray).-///-/// # Arguments-/// - views_buffer: The buffer to append the new view to-/// - original_view: The original view value-/// - substr: The substring to append. Must be a valid substring of the original view-/// - start_offset: The start offset of the substring in the view-///-/// LLVM is apparently overly eager to inline this function into some hot loops,-/// which bloats them and regresses performance, so we disable inlining for now.-#[inline(never)]-pub(crate) fn append_view(- views_buffer: &mut Vec<u128>,- original_view: &u128,- substr: &str,- start_offset: u32,-) {- let substr_len = substr.len();- let sub_view = if substr_len > 12 {- let view = ByteView::from(*original_view);- make_view(- substr.as_bytes(),- view.buffer_index,- view.offset + start_offset,- )- } else {- make_view(substr.as_bytes(), 0, 0)- };- views_buffer.push(sub_view);-}-/// Values of at most this many bytes are stored inline in their view.pub(crate) const MAX_INLINE_LEN: usize = MAX_INLINE_VIEW_LEN as usize;@@ -1239,9 +1201,23 @@ pub(crate) const MAX_INLINE_LEN: usize = MAX_INLINE_VIEW_LEN as usize;pub(crate) fn sub_view(view: u128, source: &[u8], range: Range<usize>) -> u128 {debug_assert!(range.start <= range.end && range.end <= source.len());- // The substring's first bytes, in the low-order bits. Any bits past the- // end of the substring are masked off by `inline_view`.- let leading_bytes = if source.len() <= MAX_INLINE_LEN {+ let len = range.end - range.start;+ if len > MAX_INLINE_LEN {+ // The substring has more than 12 bytes, so its 4-byte prefix is in bounds.+ let prefix = source[range.start..range.start + 4].try_into().unwrap();+ let original = ByteView::from(view);+ return ByteView {+ length: len as u32,+ prefix: u32::from_le_bytes(prefix),+ offset: original.offset + range.start as u32,+ ..original+ }+ .as_u128();+ }++ // The substring's bytes, in the low-order bits. Any bits past the end of+ // the substring are masked off by `inline_view`.+ let bytes = if source.len() <= MAX_INLINE_LEN {// `source` is stored in `view` itself, after its 4-byte length.(view >> 32) >> (8 * range.start)} else {@@ -1254,20 +1230,15 @@ pub(crate) fn sub_view(view: u128, source: &[u8], range: Range<usize>) -> u128 {.unwrap();read_12_bytes(window) >> (8 * (range.start - window_start))};+ inline_view(bytes, len)+}- let len = range.len();- if len <= MAX_INLINE_LEN {- inline_view(leading_bytes, len)- } else {- let original = ByteView::from(view);- ByteView {- length: len as u32,- prefix: leading_bytes as u32,- offset: original.offset + range.start as u32,- ..original- }- .as_u128()- }+/// Returns the view for `substr`, which must be a slice of `string`, the value+/// `view` refers to. See [`sub_view`].+#[inline]+pub(crate) fn substr_view(view: u128, string: &str, substr: &str) -> u128 {+ let start = substr.as_ptr() as usize - string.as_ptr() as usize;+ sub_view(view, string.as_bytes(), start..start + substr.len())}/// Reads `bytes` as a little-endian integer.diff --git a/datafusion/functions/src/unicode/substr.rs b/datafusion/functions/src/unicode/substr.rsindex 53f6080088..55da0e801a 100644--- a/datafusion/functions/src/unicode/substr.rs+++ b/datafusion/functions/src/unicode/substr.rs@@ -17,7 +17,7 @@use std::sync::Arc;-use crate::strings::append_view;+use crate::strings::sub_view;use crate::utils::make_scalar_function;use arrow::array::{Array, ArrayRef, AsArray, GenericStringArray, Int64Array, OffsetSizeTrait,@@ -297,9 +297,7 @@ fn string_view_substr(let count = count_array_opt.map(|a| a.value(i));let (byte_start, byte_end) = get_true_start_end(string, start, count, is_ascii)?;- let substr = &string[byte_start..byte_end];-- append_view(&mut views_buf, raw_view, substr, byte_start as u32);+ views_buf.push(sub_view(*raw_view, string.as_bytes(), byte_start..byte_end));}let views_buf = ScalarBuffer::from(views_buf);diff --git a/datafusion/functions/src/unicode/substrindex.rs b/datafusion/functions/src/unicode/substrindex.rsindex 33da6e8fc2..ada3141a9b 100644--- a/datafusion/functions/src/unicode/substrindex.rs+++ b/datafusion/functions/src/unicode/substrindex.rs@@ -18,14 +18,14 @@use std::sync::Arc;use arrow::array::{- Array, ArrayRef, AsArray, ByteView, OffsetSizeTrait, PrimitiveArray, StringArrayType,+ Array, ArrayRef, AsArray, OffsetSizeTrait, PrimitiveArray, StringArrayType,StringViewArray, make_view, new_null_array,};use arrow::buffer::ScalarBuffer;use arrow::datatypes::{DataType, Int64Type};use arrow_buffer::NullBuffer;-use crate::strings::GenericStringArrayBuilder;+use crate::strings::{GenericStringArrayBuilder, MAX_INLINE_LEN, substr_view};use crate::utils::make_scalar_function;use datafusion_common::utils::offset_span_len;use datafusion_common::{@@ -324,7 +324,7 @@ fn substr_index_view(// Safety: each appended view is either:// (1) a copied null sentinel,// (2) the original valid input view, or- // (3) built by `append_view` for a contiguous substring of the input row.+ // (3) built by `substr_view` for a contiguous substring of the input row.unsafe {Ok(Arc::new(StringViewArray::new_unchecked(ScalarBuffer::from(views_buf),@@ -457,7 +457,7 @@ fn substr_index_scalar_view(// (1) a copied null sentinel,// (2) the original valid input view,// (3) an inline empty string view, or- // (4) built by `append_view` for a contiguous substring of the input row.+ // (4) built by `substr_view` for a contiguous substring of the input row.unsafe {Ok(Arc::new(StringViewArray::new_unchecked(ScalarBuffer::from(views_buf),@@ -579,20 +579,6 @@ fn substr_index_rslice_finder<'a>(}}-#[inline]-fn substr_view(original_view: &u128, substr: &str, start_offset: u32) -> u128 {- if substr.len() > 12 {- let view = ByteView::from(*original_view);- make_view(- substr.as_bytes(),- view.buffer_index,- view.offset + start_offset,- )- } else {- make_view(substr.as_bytes(), 0, 0)- }-}-#[inline]fn append_substr_view(views_buf: &mut Vec<u128>,@@ -602,7 +588,7 @@ fn append_substr_view() -> bool {if substr.len() == string.len() {views_buf.push(*raw_view);- return substr.len() > 12;+ return substr.len() > MAX_INLINE_LEN;}if substr.is_empty() {@@ -610,11 +596,8 @@ fn append_substr_view(return false;}- let start_offset = substr.as_ptr() as usize - string.as_ptr() as usize;- let start_offset =- u32::try_from(start_offset).expect("string view offsets fit in u32");- views_buf.push(substr_view(raw_view, substr, start_offset));- substr.len() > 12+ views_buf.push(substr_view(*raw_view, string, substr));+ substr.len() > MAX_INLINE_LEN}#[cfg(test)]