Apache DataFusion SQL Query Engine
perf: Use batched row conversion for `array_has_any`, `array_has_all` (#20588)
Neil Conway3c56e5d77fd7
diff --git a/datafusion/functions-nested/src/array_has.rs b/datafusion/functions-nested/src/array_has.rsindex 76cf786c95..5e945cfe1d 100644--- a/datafusion/functions-nested/src/array_has.rs+++ b/datafusion/functions-nested/src/array_has.rs@@ -42,6 +42,7 @@ use crate::utils::make_scalar_function;use hashbrown::HashSet;use std::any::Any;+use std::ops::Range;use std::sync::Arc;// Create static instances of ScalarUDFs for each function@@ -422,30 +423,66 @@ fn array_has_all_inner(args: &[ArrayRef]) -> Result<ArrayRef> {array_has_all_and_any_inner(args, ComparisonType::All)}+/// Number of rows to process at a time when doing batched row conversion. This+/// amortizes the row conversion overhead over more rows, but making this too+/// large can cause cache pressure for large arrays. See+/// <https://github.com/apache/datafusion/pull/20588> for context.+const ROW_CONVERSION_CHUNK_SIZE: usize = 512;+// General row comparison for array_has_all and array_has_anyfn general_array_has_for_all_and_any<'a>(haystack: ArrayWrapper<'a>,needle: ArrayWrapper<'a>,comparison_type: ComparisonType,) -> Result<ArrayRef> {- let mut boolean_builder = BooleanArray::builder(haystack.len());+ let num_rows = haystack.len();let converter = RowConverter::new(vec![SortField::new(haystack.value_type())])?;- for (arr, sub_arr) in haystack.iter().zip(needle.iter()) {- if let (Some(arr), Some(sub_arr)) = (arr, sub_arr) {- let arr_values = converter.convert_columns(&[arr])?;- let sub_arr_values = converter.convert_columns(&[sub_arr])?;- boolean_builder.append_value(general_array_has_all_and_any_kernel(- &arr_values,- &sub_arr_values,+ let h_offsets: Vec<usize> = haystack.offsets().collect();+ let n_offsets: Vec<usize> = needle.offsets().collect();++ let h_nulls = haystack.nulls();+ let n_nulls = needle.nulls();+ let mut builder = BooleanArray::builder(num_rows);++ for chunk_start in (0..num_rows).step_by(ROW_CONVERSION_CHUNK_SIZE) {+ let chunk_end = (chunk_start + ROW_CONVERSION_CHUNK_SIZE).min(num_rows);++ // For efficiency with sliced arrays, only process the visible elements,+ // not the entire underlying buffer.+ let h_elem_start = h_offsets[chunk_start];+ let h_elem_end = h_offsets[chunk_end];+ let n_elem_start = n_offsets[chunk_start];+ let n_elem_end = n_offsets[chunk_end];++ let h_vals = haystack+ .values()+ .slice(h_elem_start, h_elem_end - h_elem_start);+ let n_vals = needle+ .values()+ .slice(n_elem_start, n_elem_end - n_elem_start);++ let chunk_h_rows = converter.convert_columns(&[h_vals])?;+ let chunk_n_rows = converter.convert_columns(&[n_vals])?;++ for i in chunk_start..chunk_end {+ if h_nulls.is_some_and(|n| n.is_null(i))+ || n_nulls.is_some_and(|n| n.is_null(i))+ {+ builder.append_null();+ continue;+ }+ builder.append_value(general_array_has_all_and_any_kernel(+ &chunk_h_rows,+ (h_offsets[i] - h_elem_start)..(h_offsets[i + 1] - h_elem_start),+ &chunk_n_rows,+ (n_offsets[i] - n_elem_start)..(n_offsets[i + 1] - n_elem_start),comparison_type,));- } else {- boolean_builder.append_null();}}- Ok(Arc::new(boolean_builder.finish()))+ Ok(Arc::new(builder.finish()))}// String comparison for array_has_all and array_has_any@@ -454,25 +491,53 @@ fn array_has_all_and_any_string_internal<'a>(needle: ArrayWrapper<'a>,comparison_type: ComparisonType,) -> Result<ArrayRef> {- let mut boolean_builder = BooleanArray::builder(haystack.len());- for (arr, sub_arr) in haystack.iter().zip(needle.iter()) {- match (arr, sub_arr) {- (Some(arr), Some(sub_arr)) => {- let haystack_array = string_array_to_vec(&arr);- let needle_array = string_array_to_vec(&sub_arr);- boolean_builder.append_value(array_has_string_kernel(- &haystack_array,- &needle_array,- comparison_type,- ));- }- (_, _) => {- boolean_builder.append_null();+ let num_rows = haystack.len();++ let h_offsets: Vec<usize> = haystack.offsets().collect();+ let n_offsets: Vec<usize> = needle.offsets().collect();++ let h_nulls = haystack.nulls();+ let n_nulls = needle.nulls();+ let mut builder = BooleanArray::builder(num_rows);++ for chunk_start in (0..num_rows).step_by(ROW_CONVERSION_CHUNK_SIZE) {+ let chunk_end = (chunk_start + ROW_CONVERSION_CHUNK_SIZE).min(num_rows);++ let h_elem_start = h_offsets[chunk_start];+ let h_elem_end = h_offsets[chunk_end];+ let n_elem_start = n_offsets[chunk_start];+ let n_elem_end = n_offsets[chunk_end];++ let h_vals = haystack+ .values()+ .slice(h_elem_start, h_elem_end - h_elem_start);+ let n_vals = needle+ .values()+ .slice(n_elem_start, n_elem_end - n_elem_start);++ let chunk_h_strings = string_array_to_vec(h_vals.as_ref());+ let chunk_n_strings = string_array_to_vec(n_vals.as_ref());++ for i in chunk_start..chunk_end {+ if h_nulls.is_some_and(|n| n.is_null(i))+ || n_nulls.is_some_and(|n| n.is_null(i))+ {+ builder.append_null();+ continue;}+ let h_start = h_offsets[i] - h_elem_start;+ let h_end = h_offsets[i + 1] - h_elem_start;+ let n_start = n_offsets[i] - n_elem_start;+ let n_end = n_offsets[i + 1] - n_elem_start;+ builder.append_value(array_has_string_kernel(+ &chunk_h_strings[h_start..h_end],+ &chunk_n_strings[n_start..n_end],+ comparison_type,+ ));}}- Ok(Arc::new(boolean_builder.finish()))+ Ok(Arc::new(builder.finish()))}fn array_has_all_and_any_dispatch<'a>(@@ -905,19 +970,22 @@ fn array_has_string_kernel(fn general_array_has_all_and_any_kernel(haystack_rows: &Rows,+ h_range: Range<usize>,needle_rows: &Rows,+ mut n_range: Range<usize>,comparison_type: ComparisonType,) -> bool {+ let h_start = h_range.start;+ let h_end = h_range.end;+match comparison_type {- ComparisonType::All => needle_rows.iter().all(|needle_row| {- haystack_rows- .iter()- .any(|haystack_row| haystack_row == needle_row)+ ComparisonType::All => n_range.all(|ni| {+ let needle_row = needle_rows.row(ni);+ (h_start..h_end).any(|hi| haystack_rows.row(hi) == needle_row)}),- ComparisonType::Any => needle_rows.iter().any(|needle_row| {- haystack_rows- .iter()- .any(|haystack_row| haystack_row == needle_row)+ ComparisonType::Any => n_range.any(|ni| {+ let needle_row = needle_rows.row(ni);+ (h_start..h_end).any(|hi| haystack_rows.row(hi) == needle_row)}),}}@@ -928,7 +996,10 @@ mod tests {use arrow::datatypes::Int32Type;use arrow::{- array::{Array, ArrayRef, AsArray, Int32Array, ListArray, create_array},+ array::{+ Array, ArrayRef, AsArray, FixedSizeListArray, Int32Array, ListArray,+ create_array,+ },buffer::OffsetBuffer,datatypes::{DataType, Field},};@@ -943,7 +1014,7 @@ mod tests {use crate::expr_fn::make_array;- use super::ArrayHas;+ use super::{ArrayHas, ArrayHasAll, ArrayHasAny};#[test]fn test_simplify_array_has_to_in_list() {@@ -1153,4 +1224,112 @@ mod tests {Ok(())}++ /// Invoke a two-argument list UDF with the given arrays and assert the+ /// boolean output matches `expected`.+ fn invoke_and_assert(+ udf: &dyn ScalarUDFImpl,+ haystack: &ArrayRef,+ needle: ArrayRef,+ expected: &[Option<bool>],+ ) {+ let num_rows = haystack.len();+ let list_type = haystack.data_type();+ let result = udf+ .invoke_with_args(ScalarFunctionArgs {+ args: vec![+ ColumnarValue::Array(Arc::clone(haystack)),+ ColumnarValue::Array(needle),+ ],+ arg_fields: vec![+ Arc::new(Field::new("haystack", list_type.clone(), false)),+ Arc::new(Field::new("needle", list_type.clone(), false)),+ ],+ number_rows: num_rows,+ return_field: Arc::new(Field::new("return", DataType::Boolean, true)),+ config_options: Arc::new(ConfigOptions::default()),+ })+ .unwrap();+ let output = result.into_array(num_rows).unwrap();+ assert_eq!(output.as_boolean().iter().collect::<Vec<_>>(), expected);+ }++ #[test]+ fn test_sliced_list_offsets() {+ // Full rows:+ // row 0: [1, 2] (not visible after slicing)+ // row 1: [11, 12] (visible row 0)+ // row 2: [21, 22] (visible row 1)+ // row 3: [31, 32] (not visible after slicing)+ let field: Arc<Field> = Arc::new(Field::new("item", DataType::Int32, false));+ let full_values = Arc::new(Int32Array::from(vec![1, 2, 11, 12, 21, 22, 31, 32]));+ let full_offsets = OffsetBuffer::new(vec![0, 2, 4, 6, 8].into());+ let full = ListArray::new(Arc::clone(&field), full_offsets, full_values, None);+ let sliced_haystack: ArrayRef = Arc::new(full.slice(1, 2));++ // array_has_all: needle row 0 = [11], row 1 = [21]+ let needle_all: ArrayRef = Arc::new(ListArray::new(+ Arc::clone(&field),+ OffsetBuffer::new(vec![0, 1, 2].into()),+ Arc::new(Int32Array::from(vec![11, 21])),+ None,+ ));+ invoke_and_assert(+ &ArrayHasAll::new(),+ &sliced_haystack,+ needle_all,+ &[Some(true), Some(true)],+ );++ // array_has_any: needle row 0 = [99, 11], row 1 = [99, 21]+ let needle_any: ArrayRef = Arc::new(ListArray::new(+ field,+ OffsetBuffer::new(vec![0, 2, 4].into()),+ Arc::new(Int32Array::from(vec![99, 11, 99, 21])),+ None,+ ));+ invoke_and_assert(+ &ArrayHasAny::new(),+ &sliced_haystack,+ needle_any,+ &[Some(true), Some(true)],+ );+ }++ #[test]+ fn test_sliced_fixed_size_list_offsets() {+ // Same logical data as test_sliced_list_offsets, but using FixedSizeListArray.+ let field = Arc::new(Field::new("item", DataType::Int32, false));+ let full_values = Arc::new(Int32Array::from(vec![1, 2, 11, 12, 21, 22, 31, 32]));+ let full = FixedSizeListArray::new(Arc::clone(&field), 2, full_values, None);+ let sliced_haystack: ArrayRef = Arc::new(full.slice(1, 2));++ // array_has_all: needle row 0 = [11, 12], row 1 = [21, 22]+ let needle_all: ArrayRef = Arc::new(FixedSizeListArray::new(+ Arc::clone(&field),+ 2,+ Arc::new(Int32Array::from(vec![11, 12, 21, 22])),+ None,+ ));+ invoke_and_assert(+ &ArrayHasAll::new(),+ &sliced_haystack,+ needle_all,+ &[Some(true), Some(true)],+ );++ // array_has_any: needle row 0 = [99, 12], row 1 = [99, 22]+ let needle_any: ArrayRef = Arc::new(FixedSizeListArray::new(+ field,+ 2,+ Arc::new(Int32Array::from(vec![99, 12, 99, 22])),+ None,+ ));+ invoke_and_assert(+ &ArrayHasAny::new(),+ &sliced_haystack,+ needle_any,+ &[Some(true), Some(true)],+ );+ }}