Apache DataFusion SQL Query Engine
perf: optimize array_remove for scalar needle (#22390)
linfenga87bdc9a9038
diff --git a/datafusion/functions-nested/src/remove.rs b/datafusion/functions-nested/src/remove.rsindex d0f838ddad..1dde2aa762 100644--- a/datafusion/functions-nested/src/remove.rs+++ b/datafusion/functions-nested/src/remove.rs@@ -18,16 +18,17 @@//! [`ScalarUDFImpl`] definitions for array_remove, array_remove_n, array_remove_all functions.use crate::utils;-use crate::utils::make_scalar_function;use arrow::array::{- Array, ArrayRef, Capacities, GenericListArray, MutableArrayData, OffsetSizeTrait,- cast::AsArray, make_array,+ Array, ArrayRef, Capacities, GenericListArray, MutableArrayData, OffsetBufferBuilder,+ OffsetSizeTrait, Scalar, cast::AsArray, make_array,};use arrow::buffer::{NullBuffer, OffsetBuffer};use arrow::datatypes::{DataType, FieldRef};use datafusion_common::cast::as_int64_array;use datafusion_common::utils::ListCoercion;-use datafusion_common::{Result, exec_err, internal_err, utils::take_function_args};+use datafusion_common::{+ Result, ScalarValue, exec_err, internal_err, utils::take_function_args,+};use datafusion_expr::{ArrayFunctionArgument, ArrayFunctionSignature, ColumnarValue, Documentation,ScalarFunctionArgs, ScalarUDFImpl, Signature, TypeSignature, Volatility,@@ -113,7 +114,24 @@ impl ScalarUDFImpl for ArrayRemove {}fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result<ColumnarValue> {- make_scalar_function(array_remove_inner)(&args.args)+ let [list_arg, element_arg] = take_function_args(self.name(), &args.args)?;+ let num_rows = args.number_rows;+ let list_array = list_arg.to_array(num_rows)?;+ match element_arg {+ ColumnarValue::Scalar(scalar_element)+ if !scalar_element.is_null()+ && !scalar_element.data_type().is_nested() =>+ {+ let result =+ array_remove_with_scalar_args(&list_array, scalar_element, 1i64)?;+ Ok(ColumnarValue::Array(result))+ }+ element_arg => {+ let element_array = element_arg.to_array(num_rows)?;+ let result = array_remove_internal(&list_array, &element_array, &[1])?;+ Ok(ColumnarValue::Array(result))+ }+ }}fn aliases(&self) -> &[String] {@@ -214,7 +232,40 @@ impl ScalarUDFImpl for ArrayRemoveN {}fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result<ColumnarValue> {- make_scalar_function(array_remove_n_inner)(&args.args)+ let [list_arg, element_arg, max_arg] =+ take_function_args(self.name(), &args.args)?;+ let num_rows = args.number_rows;+ let list_array = list_arg.to_array(num_rows)?;+ match (element_arg, max_arg) {+ (+ ColumnarValue::Scalar(scalar_element),+ ColumnarValue::Scalar(scalar_max),+ ) if !scalar_element.is_null() && !scalar_element.data_type().is_nested() => {+ let ScalarValue::Int64(Some(n)) = scalar_max else {+ // null max means no remove+ return Ok(ColumnarValue::Array(list_array));+ };+ let result =+ array_remove_with_scalar_args(&list_array, scalar_element, *n)?;+ Ok(ColumnarValue::Array(result))+ }+ (element_arg, max_arg) => {+ let element_array = element_arg.to_array(num_rows)?;+ let max_array = max_arg.to_array(num_rows)?;+ let max_array = as_int64_array(&max_array)?;+ let arr_n = (0..max_array.len())+ .map(|i| {+ if max_array.is_null(i) {+ 0+ } else {+ max_array.value(i)+ }+ })+ .collect::<Vec<_>>();+ let result = array_remove_internal(&list_array, &element_array, &arr_n)?;+ Ok(ColumnarValue::Array(result))+ }+ }}fn aliases(&self) -> &[String] {@@ -304,7 +355,25 @@ impl ScalarUDFImpl for ArrayRemoveAll {}fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result<ColumnarValue> {- make_scalar_function(array_remove_all_inner)(&args.args)+ let [list_arg, element_arg] = take_function_args(self.name(), &args.args)?;+ let num_rows = args.number_rows;+ let list_array = list_arg.to_array(num_rows)?;+ match element_arg {+ ColumnarValue::Scalar(scalar_element)+ if !scalar_element.is_null()+ && !scalar_element.data_type().is_nested() =>+ {+ let result =+ array_remove_with_scalar_args(&list_array, scalar_element, i64::MAX)?;+ Ok(ColumnarValue::Array(result))+ }+ element_arg => {+ let element_array = element_arg.to_array(num_rows)?;+ let result =+ array_remove_internal(&list_array, &element_array, &[i64::MAX])?;+ Ok(ColumnarValue::Array(result))+ }+ }}fn aliases(&self) -> &[String] {@@ -316,27 +385,6 @@ impl ScalarUDFImpl for ArrayRemoveAll {}}-fn array_remove_inner(args: &[ArrayRef]) -> Result<ArrayRef> {- let [array, element] = take_function_args("array_remove", args)?;-- let arr_n = vec![1; array.len()];- array_remove_internal(array, element, &arr_n)-}--fn array_remove_n_inner(args: &[ArrayRef]) -> Result<ArrayRef> {- let [array, element, max] = take_function_args("array_remove_n", args)?;-- let arr_n = as_int64_array(max)?.values().to_vec();- array_remove_internal(array, element, &arr_n)-}--fn array_remove_all_inner(args: &[ArrayRef]) -> Result<ArrayRef> {- let [array, element] = take_function_args("array_remove_all", args)?;-- let arr_n = vec![i64::MAX; array.len()];- array_remove_internal(array, element, &arr_n)-}-fn array_remove_internal(array: &ArrayRef,element_array: &ArrayRef,@@ -357,6 +405,28 @@ fn array_remove_internal(}}+/// Fast path for `array_remove` when the needle is a non-null, non-nested scalar.+/// Dispatches to the bulk `not_distinct` comparison kernel.+fn array_remove_with_scalar_args(+ array: &ArrayRef,+ scalar_needle: &ScalarValue,+ max_removals: i64,+) -> Result<ArrayRef> {+ match array.data_type() {+ DataType::List(_) => {+ let list_array = array.as_list::<i32>();+ general_remove_with_scalar::<i32>(list_array, scalar_needle, max_removals)+ }+ DataType::LargeList(_) => {+ let list_array = array.as_list::<i64>();+ general_remove_with_scalar::<i64>(list_array, scalar_needle, max_removals)+ }+ array_type => exec_err!(+ "array_remove/array_remove_n/array_remove_all does not support type '{array_type}'."+ ),+ }+}+/// For each element of `list_array[i]`, removed up to `arr_n[i]` occurrences/// of `element_array[i]`.///@@ -411,7 +481,11 @@ fn general_remove<OffsetSize: OffsetSizeTrait>(let start = offset_window[0].to_usize().unwrap();let end = offset_window[1].to_usize().unwrap();// n is the number of elements to remove in this row- let n = arr_n[row_index];+ let n = if arr_n.len() == 1 {+ arr_n[0]+ } else {+ arr_n[row_index]+ };// compare each element in the list, `false` means the element matches and should be removedlet eq_array = utils::compare_element_to_list(@@ -468,6 +542,105 @@ fn general_remove<OffsetSize: OffsetSizeTrait>()?))}+/// For each element of `list_array[i]`, removes up to `max_removals` occurrences+/// of the scalar needle.+///+/// This is a specialized version of `general_remove` for scalar elements that+/// uses bulk comparison for better performance.+fn general_remove_with_scalar<OffsetSize: OffsetSizeTrait>(+ list_array: &GenericListArray<OffsetSize>,+ scalar_needle: &ScalarValue,+ max_removals: i64,+) -> Result<ArrayRef> {+ if max_removals <= 0 {+ return Ok(Arc::new(list_array.clone()));+ }++ let list_field = match list_array.data_type() {+ DataType::List(field) | DataType::LargeList(field) => field,+ _ => {+ return exec_err!(+ "Expected List or LargeList data type, got {:?}",+ list_array.data_type()+ );+ }+ };++ let list_offsets = list_array.offsets();+ let first_offset = list_offsets[0].to_usize().unwrap();+ let last_offset = list_offsets[list_offsets.len() - 1].to_usize().unwrap();+ let values_range_len = last_offset - first_offset;+ let values_slice = list_array.values().slice(first_offset, values_range_len);+ let original_data = values_slice.to_data();+ let mut offsets = OffsetBufferBuilder::<OffsetSize>::new(list_array.len());++ let mut mutable = MutableArrayData::with_capacities(+ vec![&original_data],+ false,+ Capacities::Array(original_data.len()),+ );+ let nulls = list_array.nulls().cloned();+ let needle = scalar_needle.to_array_of_size(1)?;+ let remove_mask = arrow_ord::cmp::not_distinct(&values_slice, &Scalar::new(needle))?;+ let remove_bits = remove_mask.values();++ for (row_index, offset_window) in list_offsets.windows(2).enumerate() {+ if nulls.as_ref().is_some_and(|nulls| nulls.is_null(row_index)) {+ offsets.push_length(0);+ continue;+ }++ let start = offset_window[0].to_usize().unwrap() - first_offset;+ let end = offset_window[1].to_usize().unwrap() - first_offset;+ let row_len = end - start;++ let row_remove_bits = remove_bits.slice(start, row_len);+ let num_to_remove = row_remove_bits.count_set_bits();++ if num_to_remove == 0 {+ mutable.extend(0, start, end);+ offsets.push_length(row_len);+ continue;+ }++ let removals_to_apply = max_removals.min(num_to_remove as i64) as usize;++ // Iterate only over the removal positions via set_indices. This is+ // efficient when the number of removals is small relative to the row+ // length (common case), since it skips over retained elements.+ let mut removed = 0usize;+ let mut copied = 0usize;+ let mut prev_end = start;+ for remove_pos in row_remove_bits.set_indices() {+ let abs_pos = start + remove_pos;+ if abs_pos > prev_end {+ mutable.extend(0, prev_end, abs_pos);+ copied += abs_pos - prev_end;+ }+ prev_end = abs_pos + 1;+ removed += 1;+ if removed == removals_to_apply {+ break;+ }+ }+ // Copy the remaining tail after the last removal+ if prev_end < end {+ mutable.extend(0, prev_end, end);+ copied += end - prev_end;+ }++ offsets.push_length(copied);+ }++ let new_values = make_array(mutable.freeze());+ Ok(Arc::new(GenericListArray::<OffsetSize>::try_new(+ Arc::clone(list_field),+ offsets.finish(),+ new_values,+ nulls,+ )?))+}+#[cfg(test)]mod tests {use crate::remove::{ArrayRemove, ArrayRemoveAll, ArrayRemoveN};diff --git a/datafusion/sqllogictest/test_files/array/array_remove.slt b/datafusion/sqllogictest/test_files/array/array_remove.sltindex c3ce7073ec..195f7a0f33 100644--- a/datafusion/sqllogictest/test_files/array/array_remove.slt+++ b/datafusion/sqllogictest/test_files/array/array_remove.slt@@ -266,6 +266,13 @@ select array_remove_n(make_array(1, 2, 2, 1, 1), NULL, 2),----NULL [1, 1, 1]+# array_remove_n with null max scalar+query ??+select array_remove_n(make_array(1, 2, 2, 1, 1), 2, NULL),+ array_remove_n(arrow_cast(make_array(1, 2, 2, 1, 1), 'LargeList(Int64)'), 2, NULL);+----+[1, 2, 2, 1, 1] [1, 2, 2, 1, 1]+# array_remove_n with null element scalar (LargeList)query ??select array_remove_n(arrow_cast(make_array(1, 2, 2, 1, 1), 'LargeList(Int64)'), NULL, 2),@@ -279,12 +286,14 @@ select array_remove_n(column1, column2, column3) from (values(make_array(1, 2, 2, 1, 1), 2, 2),(make_array(3, 4, 4, 3, 3), null, 2),(make_array(5, 6, 6, 5, 5), 6, 1),+ (make_array(7, 8, 8, 7, 7), 8, null),(null, 1, 1)) as t(column1, column2, column3);----[1, 1, 1]NULL[5, 6, 5, 5]+[7, 8, 8, 7, 7]NULL# array_remove_n with null element from column (LargeList)@@ -292,12 +301,14 @@ query ?select array_remove_n(column1, column2, column3) from (values(arrow_cast(make_array(1, 2, 2, 1, 1), 'LargeList(Int64)'), 2, 2),(arrow_cast(make_array(3, 4, 4, 3, 3), 'LargeList(Int64)'), null, 2),- (arrow_cast(make_array(5, 6, 6, 5, 5), 'LargeList(Int64)'), 6, 1)+ (arrow_cast(make_array(5, 6, 6, 5, 5), 'LargeList(Int64)'), 6, 1),+ (arrow_cast(make_array(7, 8, 8, 7, 7), 'LargeList(Int64)'), 8, null)) as t(column1, column2, column3);----[1, 1, 1]NULL[5, 6, 5, 5]+[7, 8, 8, 7, 7]# array_remove_n scalar function #1query ???@@ -537,4 +548,76 @@ select array_remove_all(make_array([1, 2, 3], [4, 5, 6], [4, 5, 6], [10, 11, 12][[1, 2, 3], [4, 5, 6], [4, 5, 6], [10, 11, 12], [13, 14, 15], [10, 11, 12], [10, 11, 12], [19, 20, 21], [19, 20, 21], [19, 20, 21], [22, 23, 24]] [[28, 29, 30], [31, 32, 33], [34, 35, 36], [28, 29, 30], [31, 32, 33], [34, 35, 36], [28, 29, 30], [31, 32, 33], [34, 35, 36], [28, 29, 30]]+# array_remove scalar arguments over multiple input rows+query ???+select+ array_remove(column1, 2),+ array_remove_n(column1, 2, 2),+ array_remove_all(column1, 2)+from (+ values+ (make_array(1, 2, 2, 3, 2, 1, 4)),+ (make_array(42, 2, 55, 63, 2))+) as t(column1);+----+[1, 2, 3, 2, 1, 4] [1, 3, 2, 1, 4] [1, 3, 1, 4]+[42, 55, 63, 2] [42, 55, 63] [42, 55, 63]++# array_remove with elements containing NULLs — scalar path preserves NULLs+query ???+select+ array_remove(column1, 2),+ array_remove_n(column1, 2, 2),+ array_remove_all(column1, 2)+from (+ values+ (make_array(1, 2, NULL, 3, 2, NULL, 4)),+ (make_array(42, 2, NULL, 63, 2))+) as t(column1);+----+[1, NULL, 3, 2, NULL, 4] [1, NULL, 3, NULL, 4] [1, NULL, 3, NULL, 4]+[42, NULL, 63, 2] [42, NULL, 63] [42, NULL, 63]++# array_remove_n with n exceeding match count+query ?+select array_remove_n(make_array(1, 2, 2, 3), 2, 100);+----+[1, 3]++# array_remove_n with n=0 and n=-1 (no removal)+query ??+select+ array_remove_n(make_array(1, 2, 2, 3), 2, 0),+ array_remove_n(make_array(1, 2, 2, 3), 2, -1);+----+[1, 2, 2, 3] [1, 2, 2, 3]++# array_remove on empty arrays+query ??+select+ array_remove(arrow_cast(make_array(), 'List(Int64)'), 1),+ array_remove_all(arrow_cast(make_array(), 'List(Int64)'), 1);+----+[] []++# array_remove needle not found — array unchanged+query ?+select array_remove_all(make_array(1, 2, 3, 4, 5), 99);+----+[1, 2, 3, 4, 5]++# array_remove all elements match+query ?+select array_remove_all(make_array(7, 7, 7, 7), 7);+----+[]++# LargeList scalar path edge cases+query ??+select+ array_remove_all(arrow_cast(make_array(1, 1, 1), 'LargeList(Int64)'), 1),+ array_remove_n(arrow_cast(make_array(1, 1, 1), 'LargeList(Int64)'), 1, 2);+----+[] [1]+include ./cleanup.slt.part