Apache DataFusion SQL Query Engine
Skip probe-side consumption when hash join build side is empty (#21068)
kosiew6c5e241e6298
diff --git a/datafusion/common/src/join_type.rs b/datafusion/common/src/join_type.rsindex 8855e993f2..d517844db4 100644--- a/datafusion/common/src/join_type.rs+++ b/datafusion/common/src/join_type.rs@@ -142,6 +142,20 @@ impl JoinType {| JoinType::RightMark)}++ /// Returns true when an empty build side necessarily produces an empty+ /// result for this join type.+ pub fn empty_build_side_produces_empty_result(self) -> bool {+ matches!(+ self,+ JoinType::Inner+ | JoinType::Left+ | JoinType::LeftSemi+ | JoinType::LeftAnti+ | JoinType::LeftMark+ | JoinType::RightSemi+ )+ }}impl Display for JoinType {diff --git a/datafusion/physical-plan/src/joins/hash_join/exec.rs b/datafusion/physical-plan/src/joins/hash_join/exec.rsindex 9667069a09..d064f5ce6c 100644--- a/datafusion/physical-plan/src/joins/hash_join/exec.rs+++ b/datafusion/physical-plan/src/joins/hash_join/exec.rs@@ -2270,6 +2270,110 @@ mod tests {)}+ fn empty_build_with_probe_error_inputs()+ -> (Arc<dyn ExecutionPlan>, Arc<dyn ExecutionPlan>, JoinOn) {+ let left_batch =+ build_table_i32(("a1", &vec![]), ("b1", &vec![]), ("c1", &vec![]));+ let left_schema = left_batch.schema();+ let left: Arc<dyn ExecutionPlan> = TestMemoryExec::try_new_exec(+ &[vec![left_batch]],+ Arc::clone(&left_schema),+ None,+ )+ .unwrap();++ let err = exec_err!("bad data error");+ let right_batch =+ build_table_i32(("a2", &vec![]), ("b1", &vec![]), ("c2", &vec![]));+ let right_schema = right_batch.schema();+ let on = vec![(+ Arc::new(Column::new_with_schema("b1", &left_schema).unwrap()) as _,+ Arc::new(Column::new_with_schema("b1", &right_schema).unwrap()) as _,+ )];+ let right: Arc<dyn ExecutionPlan> = Arc::new(+ MockExec::new(vec![Ok(right_batch), err], right_schema).with_use_task(false),+ );++ (left, right, on)+ }++ async fn assert_empty_build_probe_behavior(+ join_types: &[JoinType],+ expect_probe_error: bool,+ with_filter: bool,+ ) {+ let (left, right, on) = empty_build_with_probe_error_inputs();+ let filter = prepare_join_filter();++ for join_type in join_types {+ let join = if with_filter {+ join_with_filter(+ Arc::clone(&left),+ Arc::clone(&right),+ on.clone(),+ filter.clone(),+ join_type,+ NullEquality::NullEqualsNothing,+ )+ .unwrap()+ } else {+ join(+ Arc::clone(&left),+ Arc::clone(&right),+ on.clone(),+ join_type,+ NullEquality::NullEqualsNothing,+ )+ .unwrap()+ };++ let result = common::collect(+ join.execute(0, Arc::new(TaskContext::default())).unwrap(),+ )+ .await;++ if expect_probe_error {+ let result_string = result.unwrap_err().to_string();+ assert!(+ result_string.contains("bad data error"),+ "actual: {result_string}"+ );+ } else {+ let batches = result.unwrap();+ assert!(+ batches.is_empty(),+ "expected no output batches for {join_type}, got {batches:?}"+ );+ }+ }+ }++ fn hash_join_with_dynamic_filter(+ left: Arc<dyn ExecutionPlan>,+ right: Arc<dyn ExecutionPlan>,+ on: JoinOn,+ join_type: JoinType,+ ) -> Result<(HashJoinExec, Arc<DynamicFilterPhysicalExpr>)> {+ let dynamic_filter = HashJoinExec::create_dynamic_filter(&on);+ let mut join = HashJoinExec::try_new(+ left,+ right,+ on,+ None,+ &join_type,+ None,+ PartitionMode::CollectLeft,+ NullEquality::NullEqualsNothing,+ false,+ )?;+ join.dynamic_filter = Some(HashJoinExecDynamicFilter {+ filter: Arc::clone(&dynamic_filter),+ build_accumulator: OnceLock::new(),+ });++ Ok((join, dynamic_filter))+ }+async fn join_collect(left: Arc<dyn ExecutionPlan>,right: Arc<dyn ExecutionPlan>,@@ -4978,6 +5082,70 @@ mod tests {}}+ #[tokio::test]+ async fn join_does_not_consume_probe_when_empty_build_fixes_output() {+ assert_empty_build_probe_behavior(+ &[+ JoinType::Inner,+ JoinType::Left,+ JoinType::LeftSemi,+ JoinType::LeftAnti,+ JoinType::LeftMark,+ JoinType::RightSemi,+ ],+ false,+ false,+ )+ .await;+ }++ #[tokio::test]+ async fn join_does_not_consume_probe_when_empty_build_fixes_output_with_filter() {+ assert_empty_build_probe_behavior(+ &[+ JoinType::Inner,+ JoinType::Left,+ JoinType::LeftSemi,+ JoinType::LeftAnti,+ JoinType::LeftMark,+ JoinType::RightSemi,+ ],+ false,+ true,+ )+ .await;+ }++ #[tokio::test]+ async fn join_still_consumes_probe_when_empty_build_needs_probe_rows() {+ assert_empty_build_probe_behavior(+ &[+ JoinType::Right,+ JoinType::Full,+ JoinType::RightAnti,+ JoinType::RightMark,+ ],+ true,+ false,+ )+ .await;+ }++ #[tokio::test]+ async fn join_still_consumes_probe_when_empty_build_needs_probe_rows_with_filter() {+ assert_empty_build_probe_behavior(+ &[+ JoinType::Right,+ JoinType::Full,+ JoinType::RightAnti,+ JoinType::RightMark,+ ],+ true,+ true,+ )+ .await;+ }+#[tokio::test]async fn join_split_batch() {let left = build_table(@@ -5421,26 +5589,8 @@ mod tests {Arc::new(Column::new_with_schema("b1", &right.schema())?) as _,)];- // Create a dynamic filter manually- let dynamic_filter = HashJoinExec::create_dynamic_filter(&on);- let dynamic_filter_clone = Arc::clone(&dynamic_filter);-- // Create HashJoinExec with the dynamic filter- let mut join = HashJoinExec::try_new(- left,- right,- on,- None,- &JoinType::Inner,- None,- PartitionMode::CollectLeft,- NullEquality::NullEqualsNothing,- false,- )?;- join.dynamic_filter = Some(HashJoinExecDynamicFilter {- filter: dynamic_filter,- build_accumulator: OnceLock::new(),- });+ let (join, dynamic_filter) =+ hash_join_with_dynamic_filter(left, right, on, JoinType::Inner)?;// Execute the joinlet stream = join.execute(0, task_ctx)?;@@ -5448,7 +5598,7 @@ mod tests {// After the join completes, the dynamic filter should be marked as complete// wait_complete() should return immediately- dynamic_filter_clone.wait_complete().await;+ dynamic_filter.wait_complete().await;Ok(())}@@ -5470,26 +5620,8 @@ mod tests {Arc::new(Column::new_with_schema("b1", &right.schema())?) as _,)];- // Create a dynamic filter manually- let dynamic_filter = HashJoinExec::create_dynamic_filter(&on);- let dynamic_filter_clone = Arc::clone(&dynamic_filter);-- // Create HashJoinExec with the dynamic filter- let mut join = HashJoinExec::try_new(- left,- right,- on,- None,- &JoinType::Inner,- None,- PartitionMode::CollectLeft,- NullEquality::NullEqualsNothing,- false,- )?;- join.dynamic_filter = Some(HashJoinExecDynamicFilter {- filter: dynamic_filter,- build_accumulator: OnceLock::new(),- });+ let (join, dynamic_filter) =+ hash_join_with_dynamic_filter(left, right, on, JoinType::Inner)?;// Execute the joinlet stream = join.execute(0, task_ctx)?;@@ -5497,7 +5629,28 @@ mod tests {// Even with empty build side, the dynamic filter should be marked as complete// wait_complete() should return immediately- dynamic_filter_clone.wait_complete().await;+ dynamic_filter.wait_complete().await;++ Ok(())+ }++ #[tokio::test]+ async fn test_hash_join_skips_probe_on_empty_build_after_partition_bounds_report()+ -> Result<()> {+ let task_ctx = Arc::new(TaskContext::default());+ let (left, right, on) = empty_build_with_probe_error_inputs();++ // Keep an extra consumer reference so execute() enables dynamic filter pushdown+ // and enters the WaitPartitionBoundsReport path before deciding whether to poll+ // the probe side.+ let (join, dynamic_filter) =+ hash_join_with_dynamic_filter(left, right, on, JoinType::Inner)?;++ let stream = join.execute(0, task_ctx)?;+ let batches = common::collect(stream).await?;+ assert!(batches.is_empty());++ dynamic_filter.wait_complete().await;Ok(())}diff --git a/datafusion/physical-plan/src/joins/hash_join/stream.rs b/datafusion/physical-plan/src/joins/hash_join/stream.rsindex ab63092018..1004fba3d4 100644--- a/datafusion/physical-plan/src/joins/hash_join/stream.rs+++ b/datafusion/physical-plan/src/joins/hash_join/stream.rs@@ -406,6 +406,21 @@ impl HashJoinStream {}}+ /// Returns the next state after the build side has been fully collected+ /// and any required build-side coordination has completed.+ fn state_after_build_ready(+ join_type: JoinType,+ left_data: &JoinLeftData,+ ) -> HashJoinStreamState {+ if left_data.map().is_empty()+ && join_type.empty_build_side_produces_empty_result()+ {+ HashJoinStreamState::Completed+ } else {+ HashJoinStreamState::FetchProbeBatch+ }+ }+/// Separate implementation function that unpins the [`HashJoinStream`] so/// that partial borrows work correctlyfn poll_next_impl(@@ -469,7 +484,9 @@ impl HashJoinStream {if let Some(ref mut fut) = self.build_waiter {ready!(fut.get_shared(cx))?;}- self.state = HashJoinStreamState::FetchProbeBatch;+ let build_side = self.build_side.try_as_ready()?;+ self.state =+ Self::state_after_build_ready(self.join_type, build_side.left_data.as_ref());Poll::Ready(Ok(StatefulStreamResult::Continue))}@@ -540,7 +557,8 @@ impl HashJoinStream {}));self.state = HashJoinStreamState::WaitPartitionBoundsReport;} else {- self.state = HashJoinStreamState::FetchProbeBatch;+ self.state =+ Self::state_after_build_ready(self.join_type, left_data.as_ref());}self.build_side = BuildSide::Ready(BuildSideReadyState { left_data });@@ -643,10 +661,14 @@ impl HashJoinStream {}}- // if the left side is empty, we can skip the (potentially expensive) join operation+ // If the build side is empty, this stream only reaches ProcessProbeBatch for+ // join types whose output still depends on probe rows.let is_empty = build_side.left_data.map().is_empty();- if is_empty && self.filter.is_none() {+ if is_empty {+ // Invariant: state_after_build_ready should have already completed+ // join types whose result is fixed to empty when the build side is empty.+ debug_assert!(!self.join_type.empty_build_side_produces_empty_result());let result = build_batch_empty_build_side(&self.schema,build_side.left_data.batch(),diff --git a/datafusion/physical-plan/src/joins/utils.rs b/datafusion/physical-plan/src/joins/utils.rsindex ffe8cf4a9e..d3c8ccc11b 100644--- a/datafusion/physical-plan/src/joins/utils.rs+++ b/datafusion/physical-plan/src/joins/utils.rs@@ -1062,47 +1062,35 @@ pub(crate) fn build_batch_empty_build_side(column_indices: &[ColumnIndex],join_type: JoinType,) -> Result<RecordBatch> {- match join_type {- // these join types only return data if the left side is not empty, so we return an- // empty RecordBatch- JoinType::Inner- | JoinType::Left- | JoinType::LeftSemi- | JoinType::RightSemi- | JoinType::LeftAnti- | JoinType::LeftMark => Ok(RecordBatch::new_empty(Arc::new(schema.clone()))),+ if join_type.empty_build_side_produces_empty_result() {+ // These join types only return data if the left side is not empty.+ return Ok(RecordBatch::new_empty(Arc::new(schema.clone())));+ }- // the remaining joins will return data for the right columns and null for the left ones- JoinType::Right | JoinType::Full | JoinType::RightAnti | JoinType::RightMark => {- let num_rows = probe_batch.num_rows();- if schema.fields().is_empty() {- return new_empty_schema_batch(schema, num_rows);- }- let mut columns: Vec<Arc<dyn Array>> =- Vec::with_capacity(schema.fields().len());-- for column_index in column_indices {- let array = match column_index.side {- // left -> null array- JoinSide::Left => new_null_array(- build_batch.column(column_index.index).data_type(),- num_rows,- ),- // right -> respective right array- JoinSide::Right => Arc::clone(probe_batch.column(column_index.index)),- // right mark -> unset boolean array as there are no matches on the left side- JoinSide::None => Arc::new(BooleanArray::new(- BooleanBuffer::new_unset(num_rows),- None,- )),- };+ // The remaining joins return right-side rows and nulls for the left side.+ let num_rows = probe_batch.num_rows();+ if schema.fields().is_empty() {+ return new_empty_schema_batch(schema, num_rows);+ }- columns.push(array);+ let columns = column_indices+ .iter()+ .map(|column_index| match column_index.side {+ // left -> null array+ JoinSide::Left => new_null_array(+ build_batch.column(column_index.index).data_type(),+ num_rows,+ ),+ // right -> respective right array+ JoinSide::Right => Arc::clone(probe_batch.column(column_index.index)),+ // right mark -> unset boolean array as there are no matches on the left side+ JoinSide::None => {+ Arc::new(BooleanArray::new(BooleanBuffer::new_unset(num_rows), None))}+ })+ .collect();- Ok(RecordBatch::try_new(Arc::new(schema.clone()), columns)?)- }- }+ Ok(RecordBatch::try_new(Arc::new(schema.clone()), columns)?)}/// The input is the matched indices for left and right and