Skip to content

Apache DataFusion SQL Query Engine

Add extra case_when benchmarks (#18097)

Pepijn Van Eeckhoudt765f2b9eaf26
diff --git a/datafusion/physical-expr/benches/case_when.rs b/datafusion/physical-expr/benches/case_when.rs
index 5a88604716..637d072ab8 100644
--- a/datafusion/physical-expr/benches/case_when.rs
+++ b/datafusion/physical-expr/benches/case_when.rs
@@ -15,31 +15,38 @@
// specific language governing permissions and limitations
// under the License.
-use arrow::array::builder::{Int32Builder, StringBuilder};
-use arrow::datatypes::{DataType, Field, Schema};
+use arrow::array::builder::StringBuilder;
+use arrow::array::{Array, ArrayRef, Int32Array};
+use arrow::datatypes::{Field, Schema};
use arrow::record_batch::RecordBatch;
use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use datafusion_common::ScalarValue;
use datafusion_expr::Operator;
-use datafusion_physical_expr::expressions::{BinaryExpr, CaseExpr, Column, Literal};
+use datafusion_physical_expr::expressions::{case, col, lit, BinaryExpr};
use datafusion_physical_expr_common::physical_expr::PhysicalExpr;
use std::sync::Arc;
-fn make_col(name: &str, index: usize) -> Arc<dyn PhysicalExpr> {
- Arc::new(Column::new(name, index))
+fn make_x_cmp_y(
+ x: &Arc<dyn PhysicalExpr>,
+ op: Operator,
+ y: i32,
+) -> Arc<dyn PhysicalExpr> {
+ Arc::new(BinaryExpr::new(Arc::clone(x), op, lit(y)))
}
-fn make_lit_i32(n: i32) -> Arc<dyn PhysicalExpr> {
- Arc::new(Literal::new(ScalarValue::Int32(Some(n))))
-}
+/// Create a record batch with the given number of rows and columns.
+/// Columns are named `c<i>` where `i` is the column index.
+///
+/// The minimum value for `column_count` is `3`.
+/// `c0` contains incrementing int32 values
+/// `c1` contains strings with one null inserted every 7 rows
+/// `c2` contains strings with one null inserted every 9 rows
+/// `c3` to `cn`, is present, contain unspecified int32 values
+fn make_batch(row_count: usize, column_count: usize) -> RecordBatch {
+ assert!(column_count >= 3);
-fn criterion_benchmark(c: &mut Criterion) {
- // create input data
- let mut c1 = Int32Builder::new();
let mut c2 = StringBuilder::new();
let mut c3 = StringBuilder::new();
- for i in 0..1000 {
- c1.append_value(i);
+ for i in 0..row_count {
if i % 7 == 0 {
c2.append_null();
} else {
@@ -51,72 +58,151 @@ fn criterion_benchmark(c: &mut Criterion) {
c3.append_value(format!("other string {i}"));
}
}
- let c1 = Arc::new(c1.finish());
+ let c1 = Arc::new(Int32Array::from_iter_values(0..row_count as i32));
let c2 = Arc::new(c2.finish());
let c3 = Arc::new(c3.finish());
- let schema = Schema::new(vec![
- Field::new("c1", DataType::Int32, true),
- Field::new("c2", DataType::Utf8, true),
- Field::new("c3", DataType::Utf8, true),
- ]);
- let batch = RecordBatch::try_new(Arc::new(schema), vec![c1, c2, c3]).unwrap();
-
- // use same predicate for all benchmarks
- let predicate = Arc::new(BinaryExpr::new(
- make_col("c1", 0),
- Operator::LtEq,
- make_lit_i32(500),
- ));
+ let mut columns: Vec<ArrayRef> = vec![c1, c2, c3];
+ for _ in 3..column_count {
+ columns.push(Arc::new(Int32Array::from_iter_values(0..row_count as i32)));
+ }
- // CASE WHEN c1 <= 500 THEN 1 ELSE 0 END
- c.bench_function("case_when: scalar or scalar", |b| {
- let expr = Arc::new(
- CaseExpr::try_new(
- None,
- vec![(predicate.clone(), make_lit_i32(1))],
- Some(make_lit_i32(0)),
+ let fields = columns
+ .iter()
+ .enumerate()
+ .map(|(i, c)| {
+ Field::new(
+ format!("c{}", i + 1),
+ c.data_type().clone(),
+ c.is_nullable(),
)
- .unwrap(),
- );
- b.iter(|| black_box(expr.evaluate(black_box(&batch)).unwrap()))
- });
+ })
+ .collect::<Vec<_>>();
- // CASE WHEN c1 <= 500 THEN c2 [ELSE NULL] END
- c.bench_function("case_when: column or null", |b| {
- let expr = Arc::new(
- CaseExpr::try_new(None, vec![(predicate.clone(), make_col("c2", 1))], None)
+ let schema = Arc::new(Schema::new(fields));
+ RecordBatch::try_new(Arc::clone(&schema), columns).unwrap()
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+ run_benchmarks(c, &make_batch(8192, 3));
+ run_benchmarks(c, &make_batch(8192, 50));
+ run_benchmarks(c, &make_batch(8192, 100));
+}
+
+fn run_benchmarks(c: &mut Criterion, batch: &RecordBatch) {
+ let c1 = col("c1", &batch.schema()).unwrap();
+ let c2 = col("c2", &batch.schema()).unwrap();
+ let c3 = col("c3", &batch.schema()).unwrap();
+
+ // No expression, when/then/else, literal values
+ c.bench_function(
+ format!(
+ "case_when {}x{}: CASE WHEN c1 <= 500 THEN 1 ELSE 0 END",
+ batch.num_rows(),
+ batch.num_columns()
+ )
+ .as_str(),
+ |b| {
+ let expr = Arc::new(
+ case(
+ None,
+ vec![(make_x_cmp_y(&c1, Operator::LtEq, 500), lit(1))],
+ Some(lit(0)),
+ )
.unwrap(),
- );
- b.iter(|| black_box(expr.evaluate(black_box(&batch)).unwrap()))
- });
+ );
+ b.iter(|| black_box(expr.evaluate(black_box(batch)).unwrap()))
+ },
+ );
+
+ // No expression, when/then/else, column reference values
+ c.bench_function(
+ format!(
+ "case_when {}x{}: CASE WHEN c1 <= 500 THEN c2 ELSE c3 END",
+ batch.num_rows(),
+ batch.num_columns()
+ )
+ .as_str(),
+ |b| {
+ let expr = Arc::new(
+ case(
+ None,
+ vec![(make_x_cmp_y(&c1, Operator::LtEq, 500), Arc::clone(&c2))],
+ Some(Arc::clone(&c3)),
+ )
+ .unwrap(),
+ );
+ b.iter(|| black_box(expr.evaluate(black_box(batch)).unwrap()))
+ },
+ );
- // CASE WHEN c1 <= 500 THEN c2 ELSE c3 END
- c.bench_function("case_when: expr or expr", |b| {
+ // No expression, when/then, implicit else
+ c.bench_function(
+ format!(
+ "case_when {}x{}: CASE WHEN c1 <= 500 THEN c2 [ELSE NULL] END",
+ batch.num_rows(),
+ batch.num_columns()
+ )
+ .as_str(),
+ |b| {
+ let expr = Arc::new(
+ case(
+ None,
+ vec![(make_x_cmp_y(&c1, Operator::LtEq, 500), Arc::clone(&c2))],
+ None,
+ )
+ .unwrap(),
+ );
+ b.iter(|| black_box(expr.evaluate(black_box(batch)).unwrap()))
+ },
+ );
+
+ // With expression, two when/then branches
+ c.bench_function(
+ format!(
+ "case_when {}x{}: CASE c1 WHEN 1 THEN c2 WHEN 2 THEN c3 END",
+ batch.num_rows(),
+ batch.num_columns()
+ )
+ .as_str(),
+ |b| {
+ let expr = Arc::new(
+ case(
+ Some(Arc::clone(&c1)),
+ vec![(lit(1), Arc::clone(&c2)), (lit(2), Arc::clone(&c3))],
+ None,
+ )
+ .unwrap(),
+ );
+ b.iter(|| black_box(expr.evaluate(black_box(batch)).unwrap()))
+ },
+ );
+
+ // Many when/then branches where all are effectively reachable
+ c.bench_function(format!("case_when {}x{}: CASE WHEN c1 == 0 THEN 0 WHEN c1 == 1 THEN 1 ... WHEN c1 == n THEN n ELSE n + 1 END", batch.num_rows(), batch.num_columns()).as_str(), |b| {
+ let when_thens = (0..batch.num_rows() as i32).map(|i| (make_x_cmp_y(&c1, Operator::Eq, i), lit(i))).collect();
let expr = Arc::new(
- CaseExpr::try_new(
+ case(
None,
- vec![(predicate.clone(), make_col("c2", 1))],
- Some(make_col("c3", 2)),
+ when_thens,
+ Some(lit(batch.num_rows() as i32))
)
- .unwrap(),
+ .unwrap(),
);
- b.iter(|| black_box(expr.evaluate(black_box(&batch)).unwrap()))
+ b.iter(|| black_box(expr.evaluate(black_box(batch)).unwrap()))
});
- // CASE c1 WHEN 1 THEN c2 WHEN 2 THEN c3 END
- c.bench_function("case_when: CASE expr", |b| {
+ // Many when/then branches where all but the first few are effectively unreachable
+ c.bench_function(format!("case_when {}x{}: CASE WHEN c1 < 0 THEN 0 WHEN c1 < 1000 THEN 1 ... WHEN c1 < n * 1000 THEN n ELSE n + 1 END", batch.num_rows(), batch.num_columns()).as_str(), |b| {
+ let when_thens = (0..batch.num_rows() as i32).map(|i| (make_x_cmp_y(&c1, Operator::Eq, i * 1000), lit(i))).collect();
let expr = Arc::new(
- CaseExpr::try_new(
- Some(make_col("c1", 0)),
- vec![
- (make_lit_i32(1), make_col("c2", 1)),
- (make_lit_i32(2), make_col("c3", 2)),
- ],
+ case(
None,
+ when_thens,
+ Some(lit(batch.num_rows() as i32))
)
- .unwrap(),
+ .unwrap(),
);
- b.iter(|| black_box(expr.evaluate(black_box(&batch)).unwrap()))
+ b.iter(|| black_box(expr.evaluate(black_box(batch)).unwrap()))
});
}