Skip to content

Apache DataFusion SQL Query Engine

bench: Add IN list benchmarks for non-constant list expressions (#20444)

Zhang Xiaofengbfc012e63852
diff --git a/datafusion/physical-expr/benches/in_list.rs b/datafusion/physical-expr/benches/in_list.rs
index 954715d0e5..021d8259cd 100644
--- a/datafusion/physical-expr/benches/in_list.rs
+++ b/datafusion/physical-expr/benches/in_list.rs
@@ -23,6 +23,7 @@ use arrow::datatypes::{Field, Schema};
use arrow::record_batch::RecordBatch;
use criterion::{Criterion, criterion_group, criterion_main};
use datafusion_common::ScalarValue;
+use datafusion_physical_expr::PhysicalExpr;
use datafusion_physical_expr::expressions::{col, in_list, lit};
use rand::distr::Alphanumeric;
use rand::prelude::*;
@@ -50,7 +51,9 @@ fn random_string(rng: &mut StdRng, len: usize) -> String {
}
const IN_LIST_LENGTHS: [usize; 4] = [3, 8, 28, 100];
+const LIST_WITH_COLUMNS_LENGTHS: [usize; 3] = [3, 8, 28];
const NULL_PERCENTS: [f64; 2] = [0., 0.2];
+const MATCH_PERCENTS: [f64; 3] = [0.0, 0.5, 1.0];
const STRING_LENGTHS: [usize; 3] = [3, 12, 100];
const ARRAY_LENGTH: usize = 8192;
@@ -219,6 +222,165 @@ fn bench_realistic_mixed_strings<A>(
}
}
+/// Benchmarks the column-reference evaluation path (no static filter) by including
+/// a column reference in the IN list, which prevents static filter creation.
+///
+/// This simulates SQL like:
+/// ```sql
+/// CREATE TABLE t (a INT, b0 INT, b1 INT, b2 INT);
+/// SELECT * FROM t WHERE a IN (b0, b1, b2);
+/// ```
+///
+/// - `values`: the "needle" column (`a`)
+/// - `list_cols`: the "haystack" columns (`b0`, `b1`, …)
+fn do_bench_with_columns(
+ c: &mut Criterion,
+ name: &str,
+ values: ArrayRef,
+ list_cols: &[ArrayRef],
+) {
+ let mut fields = vec![Field::new("a", values.data_type().clone(), true)];
+ let mut columns: Vec<ArrayRef> = vec![values];
+
+ // Build list expressions: column refs (forces non-constant evaluation path)
+ let schema_fields: Vec<Field> = list_cols
+ .iter()
+ .enumerate()
+ .map(|(i, col_arr)| {
+ let name = format!("b{i}");
+ fields.push(Field::new(&name, col_arr.data_type().clone(), true));
+ columns.push(Arc::clone(col_arr));
+ Field::new(&name, col_arr.data_type().clone(), true)
+ })
+ .collect();
+
+ let schema = Schema::new(fields);
+ let list_exprs: Vec<Arc<dyn PhysicalExpr>> = schema_fields
+ .iter()
+ .map(|f| col(f.name(), &schema).unwrap())
+ .collect();
+
+ let expr = in_list(col("a", &schema).unwrap(), list_exprs, &false, &schema).unwrap();
+ let batch = RecordBatch::try_new(Arc::new(schema), columns).unwrap();
+
+ c.bench_function(name, |b| {
+ b.iter(|| black_box(expr.evaluate(black_box(&batch)).unwrap()))
+ });
+}
+
+/// Benchmarks the IN list path with column references for Int32 arrays.
+///
+/// Equivalent SQL:
+/// ```sql
+/// CREATE TABLE t (a INT, b0 INT, b1 INT, ...);
+/// SELECT * FROM t WHERE a IN (b0, b1, ...);
+/// ```
+fn bench_with_columns_int32(c: &mut Criterion) {
+ let mut rng = StdRng::seed_from_u64(42);
+
+ for list_size in LIST_WITH_COLUMNS_LENGTHS {
+ for match_percent in MATCH_PERCENTS {
+ for null_percent in NULL_PERCENTS {
+ // Generate the "needle" column
+ let values: Int32Array = (0..ARRAY_LENGTH)
+ .map(|_| {
+ rng.random_bool(1.0 - null_percent)
+ .then(|| rng.random_range(0..1000))
+ })
+ .collect();
+
+ // Generate list columns with controlled match rate
+ let list_cols: Vec<ArrayRef> = (0..list_size)
+ .map(|_| {
+ let col: Int32Array = (0..ARRAY_LENGTH)
+ .map(|row| {
+ if rng.random_bool(1.0 - null_percent) {
+ if rng.random_bool(match_percent) {
+ // Copy from values to create a match
+ if values.is_null(row) {
+ Some(rng.random_range(0..1000))
+ } else {
+ Some(values.value(row))
+ }
+ } else {
+ // Random value (unlikely to match)
+ Some(rng.random_range(1000..2000))
+ }
+ } else {
+ None
+ }
+ })
+ .collect();
+ Arc::new(col) as ArrayRef
+ })
+ .collect();
+
+ do_bench_with_columns(
+ c,
+ &format!(
+ "in_list_cols/Int32/list={}/match={}%/nulls={}%",
+ list_size,
+ (match_percent * 100.0) as u32,
+ (null_percent * 100.0) as u32
+ ),
+ Arc::new(values),
+ &list_cols,
+ );
+ }
+ }
+ }
+}
+
+/// Benchmarks the IN list path with column references for Utf8 arrays.
+///
+/// Equivalent SQL:
+/// ```sql
+/// CREATE TABLE t (a VARCHAR, b0 VARCHAR, b1 VARCHAR, ...);
+/// SELECT * FROM t WHERE a IN (b0, b1, ...);
+/// ```
+fn bench_with_columns_utf8(c: &mut Criterion) {
+ let mut rng = StdRng::seed_from_u64(99);
+
+ for list_size in LIST_WITH_COLUMNS_LENGTHS {
+ for match_percent in MATCH_PERCENTS {
+ // Generate the "needle" column
+ let value_strings: Vec<Option<String>> = (0..ARRAY_LENGTH)
+ .map(|_| rng.random_bool(0.8).then(|| random_string(&mut rng, 12)))
+ .collect();
+ let values: StringArray =
+ value_strings.iter().map(|s| s.as_deref()).collect();
+
+ // Generate list columns with controlled match rate
+ let list_cols: Vec<ArrayRef> = (0..list_size)
+ .map(|_| {
+ let col: StringArray = (0..ARRAY_LENGTH)
+ .map(|row| {
+ if rng.random_bool(match_percent) {
+ // Copy from values to create a match
+ value_strings[row].as_deref()
+ } else {
+ Some("no_match_value_xyz")
+ }
+ })
+ .collect();
+ Arc::new(col) as ArrayRef
+ })
+ .collect();
+
+ do_bench_with_columns(
+ c,
+ &format!(
+ "in_list_cols/Utf8/list={}/match={}%",
+ list_size,
+ (match_percent * 100.0) as u32,
+ ),
+ Arc::new(values),
+ &list_cols,
+ );
+ }
+ }
+}
+
/// Entry point: registers in_list benchmarks for string and numeric array types.
fn criterion_benchmark(c: &mut Criterion) {
let mut rng = StdRng::seed_from_u64(120320);
@@ -266,6 +428,10 @@ fn criterion_benchmark(c: &mut Criterion) {
|rng| rng.random(),
|v| ScalarValue::TimestampNanosecond(Some(v), None),
);
+
+ // Column-reference path benchmarks (non-constant list expressions)
+ bench_with_columns_int32(c);
+ bench_with_columns_utf8(c);
}
criterion_group! {