Apache DataFusion SQL Query Engine
Perf: Optimize `substring_index` via single-byte fast path and direct indexing (#19590)
lyne166ef8112152
diff --git a/datafusion/functions/benches/substr_index.rs b/datafusion/functions/benches/substr_index.rsindex 88600317c9..28ce6e444e 100644--- a/datafusion/functions/benches/substr_index.rs+++ b/datafusion/functions/benches/substr_index.rs@@ -50,7 +50,10 @@ where}}-fn data() -> (StringArray, StringArray, Int64Array) {+fn data(+ batch_size: usize,+ single_char_delimiter: bool,+) -> (StringArray, StringArray, Int64Array) {let dist = Filter {dist: Uniform::new(-4, 5),test: |x: &i64| x != &0,@@ -60,19 +63,39 @@ fn data() -> (StringArray, StringArray, Int64Array) {let mut delimiters: Vec<String> = vec![];let mut counts: Vec<i64> = vec![];- for _ in 0..1000 {+ for _ in 0..batch_size {let length = rng.random_range(20..50);- let text: String = (&mut rng)+ let base: String = (&mut rng).sample_iter(&Alphanumeric).take(length).map(char::from).collect();- let char = rng.random_range(0..text.len());- let delimiter = &text.chars().nth(char).unwrap();++ let (string_value, delimiter): (String, String) = if single_char_delimiter {+ let char_idx = rng.random_range(0..base.chars().count());+ let delimiter = base.chars().nth(char_idx).unwrap().to_string();+ (base, delimiter)+ } else {+ let long_delimiters = ["|||", "***", "&&&", "###", "@@@", "$$$"];+ let delimiter =+ long_delimiters[rng.random_range(0..long_delimiters.len())].to_string();++ let delimiter_count = rng.random_range(1..4);+ let mut result = String::new();++ for i in 0..delimiter_count {+ result.push_str(&base);+ if i < delimiter_count - 1 {+ result.push_str(&delimiter);+ }+ }+ (result, delimiter)+ };+let count = rng.sample(dist.dist.unwrap());- strings.push(text);- delimiters.push(delimiter.to_string());+ strings.push(string_value);+ delimiters.push(delimiter);counts.push(count);}@@ -83,38 +106,63 @@ fn data() -> (StringArray, StringArray, Int64Array) {)}-fn criterion_benchmark(c: &mut Criterion) {- c.bench_function("substr_index_array_array_1000", |b| {- let (strings, delimiters, counts) = data();- let batch_len = counts.len();- let strings = ColumnarValue::Array(Arc::new(strings) as ArrayRef);- let delimiters = ColumnarValue::Array(Arc::new(delimiters) as ArrayRef);- let counts = ColumnarValue::Array(Arc::new(counts) as ArrayRef);-- let args = vec![strings, delimiters, counts];- 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());-- b.iter(|| {- black_box(- substr_index()- .invoke_with_args(ScalarFunctionArgs {- args: args.clone(),- arg_fields: arg_fields.clone(),- number_rows: batch_len,- return_field: Field::new("f", DataType::Utf8, true).into(),- config_options: Arc::clone(&config_options),- })- .expect("substr_index should work on valid values"),- )+fn run_benchmark(+ b: &mut criterion::Bencher,+ strings: StringArray,+ delimiters: StringArray,+ counts: Int64Array,+ batch_size: usize,+) {+ let strings = ColumnarValue::Array(Arc::new(strings) as ArrayRef);+ let delimiters = ColumnarValue::Array(Arc::new(delimiters) as ArrayRef);+ let counts = ColumnarValue::Array(Arc::new(counts) as ArrayRef);++ let args = vec![strings, delimiters, counts];+ let arg_fields = args+ .iter()+ .enumerate()+ .map(|(idx, arg)| {+ Field::new(format!("arg_{idx}"), arg.data_type().clone(), true).into()})- });+ .collect::<Vec<_>>();+ let config_options = Arc::new(ConfigOptions::default());++ b.iter(|| {+ black_box(+ substr_index()+ .invoke_with_args(ScalarFunctionArgs {+ args: args.clone(),+ arg_fields: arg_fields.clone(),+ number_rows: batch_size,+ return_field: Field::new("f", DataType::Utf8, true).into(),+ config_options: Arc::clone(&config_options),+ })+ .expect("substr_index should work on valid values"),+ )+ })+}++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 {+ group.bench_function(+ format!("substr_index_{batch_size}_single_delimiter"),+ |b| {+ let (strings, delimiters, counts) = data(batch_size, true);+ run_benchmark(b, strings, delimiters, counts, batch_size);+ },+ );++ group.bench_function(format!("substr_index_{batch_size}_long_delimiter"), |b| {+ let (strings, delimiters, counts) = data(batch_size, false);+ run_benchmark(b, strings, delimiters, counts, batch_size);+ });+ }++ group.finish();}criterion_group!(benches, criterion_benchmark);diff --git a/datafusion/functions/src/unicode/substrindex.rs b/datafusion/functions/src/unicode/substrindex.rsindex cd9d0702b4..6389dc92c2 100644--- a/datafusion/functions/src/unicode/substrindex.rs+++ b/datafusion/functions/src/unicode/substrindex.rs@@ -19,8 +19,8 @@ use std::any::Any;use std::sync::Arc;use arrow::array::{- ArrayAccessor, ArrayIter, ArrayRef, ArrowPrimitiveType, AsArray, OffsetSizeTrait,- PrimitiveArray, StringBuilder,+ ArrayAccessor, ArrayIter, ArrayRef, ArrowPrimitiveType, AsArray,+ GenericStringBuilder, OffsetSizeTrait, PrimitiveArray,};use arrow::datatypes::{DataType, Int32Type, Int64Type};@@ -182,7 +182,8 @@ fn substr_index_general<whereT::Native: OffsetSizeTrait,{- let mut builder = StringBuilder::new();+ let num_rows = string_array.len();+ let mut builder = GenericStringBuilder::<T::Native>::with_capacity(num_rows, 0);let string_iter = ArrayIter::new(string_array);let delimiter_array_iter = ArrayIter::new(delimiter_array);let count_array_iter = ArrayIter::new(count_array);@@ -198,31 +199,49 @@ where}let occurrences = usize::try_from(n.unsigned_abs()).unwrap_or(usize::MAX);- let length = if n > 0 {- let split = string.split(delimiter);- split- .take(occurrences)- .map(|s| s.len() + delimiter.len())- .sum::<usize>()- - delimiter.len()- } else {- let split = string.rsplit(delimiter);- split- .take(occurrences)- .map(|s| s.len() + delimiter.len())- .sum::<usize>()- - delimiter.len()- };- if n > 0 {- match string.get(..length) {- Some(substring) => builder.append_value(substring),- None => builder.append_null(),+ let result_idx = if delimiter.len() == 1 {+ // Fast path: use byte-level search for single-character delimiters+ let d_byte = delimiter.as_bytes()[0];+ let bytes = string.as_bytes();++ if n > 0 {+ bytes+ .iter()+ .enumerate()+ .filter(|&(_, &b)| b == d_byte)+ .nth(occurrences - 1)+ .map(|(idx, _)| idx)+ } else {+ bytes+ .iter()+ .enumerate()+ .rev()+ .filter(|&(_, &b)| b == d_byte)+ .nth(occurrences - 1)+ .map(|(idx, _)| idx + 1)}+ } else if n > 0 {+ // Multi-byte path: forward search for n-th occurrence+ string+ .match_indices(delimiter)+ .nth(occurrences - 1)+ .map(|(idx, _)| idx)} else {- match string.get(string.len().saturating_sub(length)..) {- Some(substring) => builder.append_value(substring),- None => builder.append_null(),+ // Multi-byte path: backward search for n-th occurrence from the right+ string+ .rmatch_indices(delimiter)+ .nth(occurrences - 1)+ .map(|(idx, _)| idx + delimiter.len())+ };+ match result_idx {+ Some(idx) => {+ if n > 0 {+ builder.append_value(&string[..idx]);+ } else {+ builder.append_value(&string[idx..]);+ }}+ None => builder.append_value(string),}}_ => builder.append_null(),@@ -328,7 +347,6 @@ mod tests {Utf8,StringArray);-Ok(())}}