Apache DataFusion SQL Query Engine
Apply same sparse routing for range partition dynamic filter as hash partition and restructure `build_filter` (#24417)
Peter Leed7f65a9613f9
diff --git a/datafusion/core/tests/physical_optimizer/filter_pushdown.rs b/datafusion/core/tests/physical_optimizer/filter_pushdown.rsindex 57d7dba295..3c6f554a94 100644--- a/datafusion/core/tests/physical_optimizer/filter_pushdown.rs+++ b/datafusion/core/tests/physical_optimizer/filter_pushdown.rs@@ -1378,7 +1378,7 @@ async fn test_hashjoin_dynamic_filter_pushdown_range_partitioned() {- RepartitionExec: partitioning=Range([a@0 ASC, b@1 ASC], [(aa, bb)], 2), input_partitions=1- DataSourceExec: file_groups={1 group: [[test.parquet]]}, projection=[a, b, c], file_type=test, pushdown_supported=true- RepartitionExec: partitioning=Range([a@0 ASC, b@1 ASC], [(aa, bb)], 2), input_partitions=1- - DataSourceExec: file_groups={1 group: [[test.parquet]]}, projection=[a, b, e], file_type=test, pushdown_supported=true, predicate=DynamicFilter [ CASE range_partition WHEN 0 THEN a@0 >= aa AND a@0 <= aa AND b@1 >= ba AND b@1 <= ba AND struct(a@0, b@1) IN (SET) ([{c0:aa,c1:ba}]) ELSE a@0 >= ab AND a@0 <= ab AND b@1 >= bb AND b@1 <= bb AND struct(a@0, b@1) IN (SET) ([{c0:ab,c1:bb}]) END ]+ - DataSourceExec: file_groups={1 group: [[test.parquet]]}, projection=[a, b, e], file_type=test, pushdown_supported=true, predicate=DynamicFilter [ CASE range_partition WHEN 0 THEN a@0 >= aa AND a@0 <= aa AND b@1 >= ba AND b@1 <= ba AND struct(a@0, b@1) IN (SET) ([{c0:aa,c1:ba}]) WHEN 1 THEN a@0 >= ab AND a@0 <= ab AND b@1 >= bb AND b@1 <= bb AND struct(a@0, b@1) IN (SET) ([{c0:ab,c1:bb}]) ELSE false END ]");diff --git a/datafusion/physical-plan/src/joins/hash_join/shared_bounds.rs b/datafusion/physical-plan/src/joins/hash_join/shared_bounds.rsindex 77b327accf..1564ca115e 100644--- a/datafusion/physical-plan/src/joins/hash_join/shared_bounds.rs+++ b/datafusion/physical-plan/src/joins/hash_join/shared_bounds.rs@@ -611,188 +611,190 @@ impl SharedBuildAccumulator {fn build_filter(&self, finalize_input: FinalizeInput) -> Result<()> {match finalize_input {- FinalizeInput::CollectLeft(partition) => match partition {- PartitionStatus::Reported(partition_data) => {+ FinalizeInput::CollectLeft(partition) => {+ self.build_collect_left_filter(partition)+ }+ FinalizeInput::Partitioned(partitions) => {+ self.build_partitioned_filter(partitions)+ }+ }+ }++ /// Builds the single global filter used by a collect-left join.+ fn build_collect_left_filter(&self, partition: PartitionStatus) -> Result<()> {+ match partition {+ PartitionStatus::Reported(PartitionData {+ bounds,+ pushdown,+ keys_have_null,+ }) => {+ let membership_expr = create_membership_predicate(+ &self.on_right,+ pushdown,+ &HASH_JOIN_SEED,+ self.probe_schema.as_ref(),+ )?;+ let bounds_expr = create_bounds_predicate(&self.on_right, &bounds);++ if let Some(filter_expr) =+ combine_membership_and_bounds(membership_expr, bounds_expr)+ {+ self.dynamic_filter.update(+ self.preserve_probe_nulls(filter_expr, keys_have_null)?,+ )?;+ }+ Ok(())+ }+ PartitionStatus::Pending => datafusion_common::internal_err!(+ "attempted to finalize collect-left dynamic filter without reported build data"+ ),+ PartitionStatus::CanceledUnknown => datafusion_common::internal_err!(+ "collect-left dynamic filter cannot finalize with canceled build data"+ ),+ }+ }++ /// Builds one routed probe-side filter from finalized partitioned build data.+ /// Empty partitions reject their routed rows, while canceled partitions stay+ /// permissive because their build contents are unknown.+ fn build_partitioned_filter(&self, partitions: Vec<PartitionStatus>) -> Result<()> {+ let mut partition_filters = Vec::with_capacity(partitions.len());+ let mut real_partition_ids = Vec::new();+ let mut empty_partition_ids = Vec::new();+ let mut has_canceled_unknown = false;+ let mut keys_have_null = false;++ for (partition_id, partition) in partitions.into_iter().enumerate() {+ match partition {+ PartitionStatus::Reported(PartitionData {+ pushdown: PushdownStrategy::Empty,+ ..+ }) => {+ empty_partition_ids.push(partition_id);+ partition_filters.push(lit(false));+ }+ PartitionStatus::Reported(PartitionData {+ bounds,+ pushdown,+ keys_have_null: partition_keys_have_null,+ }) => {+ real_partition_ids.push(partition_id);+ keys_have_null |= partition_keys_have_null;let membership_expr = create_membership_predicate(&self.on_right,- partition_data.pushdown.clone(),+ pushdown,&HASH_JOIN_SEED,self.probe_schema.as_ref(),)?;- let bounds_expr =- create_bounds_predicate(&self.on_right, &partition_data.bounds);-- if let Some(filter_expr) =+ let bounds_expr = create_bounds_predicate(&self.on_right, &bounds);+ let then_expr =combine_membership_and_bounds(membership_expr, bounds_expr)- {- self.dynamic_filter.update(self.preserve_probe_nulls(- filter_expr,- partition_data.keys_have_null,- )?)?;- }- }- PartitionStatus::Pending => {- return datafusion_common::internal_err!(- "attempted to finalize collect-left dynamic filter without reported build data"- );+ .unwrap_or_else(|| lit(true));+ partition_filters.push(then_expr);}PartitionStatus::CanceledUnknown => {+ has_canceled_unknown = true;+ partition_filters.push(lit(true));+ // A canceled partition's build content is unknown, so it+ // may hold a NULL key.+ keys_have_null = true;+ }+ PartitionStatus::Pending => {return datafusion_common::internal_err!(- "collect-left dynamic filter cannot finalize with canceled build data"+ "attempted to finalize dynamic filter with pending partition");}- },- FinalizeInput::Partitioned(partitions) => {- let num_partitions = partitions.len();- let mut partition_filters = Vec::with_capacity(num_partitions);- let mut real_partition_ids = Vec::new();- let mut empty_partition_ids = Vec::new();- let mut has_canceled_unknown = false;- let mut keys_have_null = false;-- for (partition_id, partition) in partitions.iter().enumerate() {- match partition {- PartitionStatus::Reported(partition)- if matches!(partition.pushdown, PushdownStrategy::Empty) =>- {- empty_partition_ids.push(partition_id);- partition_filters.push(lit(false));- }- PartitionStatus::Reported(partition) => {- real_partition_ids.push(partition_id);- keys_have_null |= partition.keys_have_null;- let membership_expr = create_membership_predicate(- &self.on_right,- partition.pushdown.clone(),- &HASH_JOIN_SEED,- self.probe_schema.as_ref(),- )?;- let bounds_expr = create_bounds_predicate(- &self.on_right,- &partition.bounds,- );- let then_expr = combine_membership_and_bounds(- membership_expr,- bounds_expr,- )- .unwrap_or_else(|| lit(true));- partition_filters.push(then_expr);- }- PartitionStatus::CanceledUnknown => {- has_canceled_unknown = true;- partition_filters.push(lit(true));- // A canceled partition's build content is unknown, so it- // may hold a NULL key.- keys_have_null = true;- }- PartitionStatus::Pending => {- return datafusion_common::internal_err!(- "attempted to finalize dynamic filter with pending partition"- );- }- }- }-- let filter_expr = if has_canceled_unknown- && real_partition_ids.is_empty()- && empty_partition_ids.is_empty()- {- lit(true)- } else if !has_canceled_unknown && real_partition_ids.is_empty() {- lit(false)- } else if !has_canceled_unknown- && real_partition_ids.len() == 1- && empty_partition_ids.len() + 1 == num_partitions- {- Arc::clone(&partition_filters[real_partition_ids[0]])- } else if let Some(range_partitioning) = &self.probe_range_partitioning {- // Range partitioning- assert_or_internal_err!(- partition_filters.len() == range_partitioning.partition_count(),- "Dynamic filter partition count {} does not match Range partition count {}",- partition_filters.len(),- range_partitioning.partition_count()- );- let routing_range_expr = Arc::new(RangeExpr::try_new(- self.on_right.clone(),- range_partitioning,- )?)- as Arc<dyn PhysicalExpr>;- let else_expr = partition_filters- .pop()- .expect("Range partitioning always has at least one partition");-- // CASE range_partition(key)- // WHEN 0 THEN F0- // WHEN 1 THEN F1- // ...- // ELSE Fn- // END- let when_then_expr = partition_filters- .into_iter()- .enumerate()- .map(|(partition_id, then_expr)| {- (- lit(ScalarValue::UInt64(Some(partition_id as u64))),- then_expr,- )- })- .collect();-- Arc::new(CaseExpr::try_new(- Some(routing_range_expr),- when_then_expr,- Some(else_expr),- )?) as Arc<dyn PhysicalExpr>- } else {- // Hash partitioning- let routing_hash_expr = Arc::new(HashExpr::new(- self.on_right.clone(),- self.repartition_random_state.clone(),- "hash_repartition".to_string(),- ))- as Arc<dyn PhysicalExpr>;- let modulo_expr = Arc::new(BinaryExpr::new(- routing_hash_expr,- Operator::Modulo,- lit(ScalarValue::UInt64(Some(num_partitions as u64))),- )) as Arc<dyn PhysicalExpr>;-- let mut when_then_branches = if has_canceled_unknown {- empty_partition_ids- .into_iter()- .map(|partition_id| {- (- lit(ScalarValue::UInt64(Some(partition_id as u64))),- lit(false),- )- })- .collect::<Vec<_>>()- } else {- vec![]- };- when_then_branches.extend(real_partition_ids.into_iter().map(- |partition_id| {- (- lit(ScalarValue::UInt64(Some(partition_id as u64))),- Arc::clone(&partition_filters[partition_id]),- )- },- ));-- Arc::new(CaseExpr::try_new(- Some(modulo_expr),- when_then_branches,- Some(lit(has_canceled_unknown)),- )?) as Arc<dyn PhysicalExpr>- };-- self.dynamic_filter- .update(self.preserve_probe_nulls(filter_expr, keys_have_null)?)?;}}- Ok(())+ let all_partitions_canceled = has_canceled_unknown+ && real_partition_ids.is_empty()+ && empty_partition_ids.is_empty();+ let all_partitions_empty = !has_canceled_unknown && real_partition_ids.is_empty();+ let one_non_empty_partition =+ !has_canceled_unknown && real_partition_ids.len() == 1;++ let filter_expr = if all_partitions_canceled {+ // No build data is known, so filtering any probe row could discard a match.+ lit(true)+ } else if all_partitions_empty {+ // No build row exists, so no probe row can match.+ lit(false)+ } else if one_non_empty_partition {+ // Only one build partition contains rows, so its filter covers every+ // possible probe match without routing.+ Arc::clone(&partition_filters[real_partition_ids[0]])+ } else {+ // Builds the shared sparse `CASE` for partition filter routing.+ // Without cancellation, omitted branches are known empty and safely fall+ // through to `ELSE false`. With cancellation, omitted canceled partitions+ // have unknown contents and must fall through to `ELSE true`, so known-empty+ // partitions are emitted explicitly as false branches.+ let mut branches = if has_canceled_unknown {+ empty_partition_ids+ .iter()+ .map(|&partition_id| (lit(partition_id as u64), lit(false)))+ .collect::<Vec<_>>()+ } else {+ vec![]+ };+ branches.extend(real_partition_ids.iter().map(|&partition_id| {+ (+ lit(partition_id as u64),+ Arc::clone(&partition_filters[partition_id]),+ )+ }));++ let routing_expr = if let Some(range_partitioning) =+ &self.probe_range_partitioning+ {+ // Routes probe rows with the partition id selected by [`RangeExpr`].+ // CASE range_partition(keys)+ // WHEN empty_partition_id THEN false -- only when cancellation exists+ // WHEN real_partition_id THEN F(real_partition_id)+ // ...+ // ELSE has_canceled_unknown+ // END+ assert_or_internal_err!(+ partition_filters.len() == range_partitioning.partition_count(),+ "Dynamic filter partition count {} does not match Range partition count {}",+ partition_filters.len(),+ range_partitioning.partition_count()+ );+ Arc::new(RangeExpr::try_new(+ self.on_right.clone(),+ range_partitioning,+ )?) as Arc<dyn PhysicalExpr>+ } else {+ // Routes probe rows with the same `hash(keys) % partition_count` expression used+ // by Hash repartitioning.+ // CASE hash(keys) % partition_count+ // WHEN empty_partition_id THEN false -- only when cancellation exists+ // WHEN real_partition_id THEN F(real_partition_id)+ // ...+ // ELSE has_canceled_unknown+ // END+ let routing_hash_expr = Arc::new(HashExpr::new(+ self.on_right.clone(),+ self.repartition_random_state.clone(),+ "hash_repartition".to_string(),+ )) as Arc<dyn PhysicalExpr>;+ Arc::new(BinaryExpr::new(+ routing_hash_expr,+ Operator::Modulo,+ lit(partition_filters.len() as u64),+ )) as Arc<dyn PhysicalExpr>+ };++ Arc::new(CaseExpr::try_new(+ Some(routing_expr),+ branches,+ Some(lit(has_canceled_unknown)),+ )?)+ };++ self.dynamic_filter+ .update(self.preserve_probe_nulls(filter_expr, keys_have_null)?)}/// Keeps probe rows with a NULL key when the join semantics need them.@@ -1180,6 +1182,11 @@ mod tests {"Range routing must use RangeExpr");assert_eq!(case.when_then_expr().len(), 3);+ assert_literal_bool(&case.when_then_expr()[0].1, false);+ assert_literal_bool(+ case.else_expr().expect("expected permissive fallback"),+ true,+ );let batch = RecordBatch::try_new(test_probe_schema(),@@ -1253,7 +1260,11 @@ mod tests {let expr = current_expr(&acc);let case = case_expr(&expr);assert!(case.expr().is_some());- assert_eq!(case.when_then_expr().len(), 3);+ assert_eq!(case.when_then_expr().len(), 2);+ assert_literal_bool(+ case.else_expr().expect("expected permissive fallback"),+ true,+ );let batch = RecordBatch::try_new(probe_schema,diff --git a/datafusion/sqllogictest/test_files/range_partitioning.slt b/datafusion/sqllogictest/test_files/range_partitioning.sltindex 326856a352..dd80fded93 100644--- a/datafusion/sqllogictest/test_files/range_partitioning.slt+++ b/datafusion/sqllogictest/test_files/range_partitioning.slt@@ -1840,8 +1840,8 @@ SELECT range_key, SUM(value) FROM (# TEST 48: Hash Join Dynamic Filter Pushdown on Compatible Range Inputs# The Parquet-backed probe accepts the partition-routed dynamic filter. Matching# Range split points keep build filter i aligned with probe partition i. The-# build has rows only in partitions 0 and 2, so the runtime filter must route-# with a four-way CASE rather than collapse to a single filter.+# build has rows only in partitions 0 and 2, so the sparse runtime CASE includes+# only those branches and lets empty partitions fall through to false.##########statement ok@@ -1882,7 +1882,7 @@ JOIN range_partitioned p ON b.range_key = p.range_key;Plan with Metrics01)HashJoinExec: mode=Partitioned<slt:ignore>metrics=[output_rows=2,<slt:ignore>]02)--DataSourceExec: <slt:ignore>file_type=parquet, predicate=range_key@0 = 5 OR range_key@0 = 20<slt:ignore>metrics=[output_rows=2,<slt:ignore>]-03)--DataSourceExec: <slt:ignore>file_type=parquet, predicate=DynamicFilter [ CASE range_partition WHEN 0 THEN range_key@0 >= 5 AND range_key@0 <= 5 AND range_key@0 IN (SET) ([5]) WHEN 1 THEN false WHEN 2 THEN range_key@0 >= 20 AND range_key@0 <= 20 AND range_key@0 IN (SET) ([20]) ELSE false END ]<slt:ignore>metrics=[output_rows=2,<slt:ignore>]+03)--DataSourceExec: <slt:ignore>file_type=parquet, predicate=DynamicFilter [ CASE range_partition WHEN 0 THEN range_key@0 >= 5 AND range_key@0 <= 5 AND range_key@0 IN (SET) ([5]) WHEN 2 THEN range_key@0 >= 20 AND range_key@0 <= 20 AND range_key@0 IN (SET) ([20]) ELSE false END ]<slt:ignore>metrics=[output_rows=2,<slt:ignore>]query IIISELECT b.range_key, b.value, p.value