Apache DataFusion SQL Query Engine
fix: keep the hash join build map reserved while the dynamic filter holds it (#26994)
Filip Wojciechowskib6b2e0e5d5f1
diff --git a/datafusion/physical-plan/src/joins/hash_join/exec.rs b/datafusion/physical-plan/src/joins/hash_join/exec.rsindex 9410280e4f..e22cf6dc2d 100644--- a/datafusion/physical-plan/src/joins/hash_join/exec.rs+++ b/datafusion/physical-plan/src/joins/hash_join/exec.rs@@ -33,7 +33,7 @@ use crate::joins::utils::{OnceAsync, OnceFut, asymmetric_join_output_partitioning, emits_unmatched_left_rows,is_existence_join, reorder_output_after_swap, swap_join_projection, update_hash,};-use crate::joins::{JoinOn, JoinOnRef, PartitionMode, SharedBitmapBuilder};+use crate::joins::{JoinOn, JoinOnRef, PartitionMode, ReservedMap, SharedBitmapBuilder};use crate::metrics::{Count, MetricBuilder, MetricCategory};use crate::projection::{EmbeddedProjection, JoinData, ProjectionExec, try_embed_projection,@@ -191,8 +191,9 @@ fn array_map_key_range(/// Immutable build buffers and their durable reservation.struct JoinBuildData {- /// Hash table with row indices into `batch`, also shared with dynamic filters.- map: Arc<Map>,+ /// Hash table with row indices into `batch`, charged to its own+ /// reservation because it is also shared with dynamic filters.+ map: Arc<ReservedMap>,/// The input rows for the build side.batch: RecordBatch,/// Evaluated build-side key expressions, with float `-0.0` rewritten to@@ -3189,13 +3190,16 @@ fn build_in_memory() -> Result<JoinLeftData> {let is_phj_candidate = is_perfect_hash_join_candidate(on_left, schema)?;+ // Bound before the map so error paths release the map before its charge.+ let mut map_reservation = reservation.new_empty();+let (join_hash_map, batch, left_values) = if let Some((min_val, max_val)) =array_map_key_range(bounds.as_ref(),schema,batches,on_left,- &mut reservation,+ &mut map_reservation,config.execution.perfect_hash_join_small_build_threshold,config.execution.perfect_hash_join_min_key_density,null_equality,@@ -3218,7 +3222,7 @@ fn build_in_memory(// Use `u32` indices for the JoinHashMap when num_rows ≤ u32::MAX, otherwise use the// `u64` indice variant// Arc is used instead of Box to allow sharing with SharedBuildAccumulator for hash map pushdown- let mut hashmap = new_join_hashmap(num_rows, &mut reservation, metrics)?;+ let mut hashmap = new_join_hashmap(num_rows, &mut map_reservation, metrics)?;let scratch_reservation = reservation.new_empty();if prepared {@@ -3314,7 +3318,7 @@ fn build_in_memory(}).transpose()?;- let map = Arc::new(join_hash_map);+ let map = Arc::new(ReservedMap::new(join_hash_map, map_reservation));// For an ordinary build, nothing reads the strategy unless this join's own// dynamic filter accumulator exists. A prepared build is shared with joins@@ -3358,10 +3362,10 @@ fn build_in_memory(.map(Arc::new),_ => None,};- // Held for the join's lifetime, so charge it like the maps; it is- // optional, so skip it rather than fail when the pool is full.+ // Shared with the map, so charge it with the map; it is optional,+ // so skip it rather than fail when the pool is full.let pruning_bitmap = pruning_bitmap.filter(|bitmap| {- let ok = reservation.try_grow(bitmap.size()).is_ok();+ let ok = map.try_grow(bitmap.size()).is_ok();if ok {metrics.build_mem_used.add(bitmap.size());}@@ -3541,14 +3545,21 @@ mod tests {Ok(())}- /// Runs a join whose 200 keys spread over 2M would size a pruning bitmap- /// at the 128 KiB cap, and reports the bytes the build side reserved.- ///- /// Forces the IN-list threshold off: under `force_hash_collisions` every- /// key hashes to the same bucket, so `num_of_distinct_key()` no longer- /// reflects the real 200 distinct keys and would otherwise take the- /// IN-list branch instead of the one under test.- async fn build_mem_used(limit: usize, dynamic_filters: bool) -> Result<usize> {+ /// 200 keys spread over 2M: sparse enough for a hash map rather than an+ /// array map, and sizing a pruning bitmap at the 128 KiB cap.+ fn sparse_keys() -> Vec<i64> {+ (0..200).map(|i| i * 10_000).collect()+ }++ /// A build side of [`sparse_keys`], a probe side with three of them, and+ /// the join keys.+ struct SparseKeyJoinInputs {+ build: Arc<dyn ExecutionPlan>,+ probe: Arc<dyn ExecutionPlan>,+ on: JoinOn,+ }++ fn sparse_key_join_inputs() -> Result<SparseKeyJoinInputs> {let schema = Arc::new(Schema::new(vec![Field::new("k", DataType::Int64, false)]));let batch = |keys: Vec<i64>| {let column = Arc::new(Int64Array::from(keys)) as ArrayRef;@@ -3559,8 +3570,22 @@ mod tests {Arc::new(Column::new_with_schema("k", &schema)?) as _,Arc::new(Column::new_with_schema("k", &schema)?) as _,)];- let build = batch((0..200).map(|i| i * 10_000).collect())?;- let probe = batch(vec![0, 500_000, 1_500_000])?;+ Ok(SparseKeyJoinInputs {+ build: batch(sparse_keys())?,+ probe: batch(vec![0, 500_000, 1_500_000])?,+ on,+ })+ }++ /// Runs a join over [`sparse_key_join_inputs`] and reports the bytes the+ /// build side reserved.+ ///+ /// Forces the IN-list threshold off: under `force_hash_collisions` every+ /// key hashes to the same bucket, so `num_of_distinct_key()` no longer+ /// reflects the real 200 distinct keys and would otherwise take the+ /// IN-list branch instead of the one under test.+ async fn build_mem_used(limit: usize, dynamic_filters: bool) -> Result<usize> {+ let SparseKeyJoinInputs { build, probe, on } = sparse_key_join_inputs()?;let join = if dynamic_filters {hash_join_with_dynamic_filter(build, probe, on, JoinType::Inner)?.0} else {@@ -3606,6 +3631,180 @@ mod tests {Ok(())}+ /// The dynamic filter shares the build map and can outlive the join's+ /// stream and plan, so the map stays reserved until the last holder drops+ /// it, not only until the partition's stream ends.+ #[rstest]+ #[tokio::test]+ async fn build_map_stays_reserved_with_dynamic_filter(+ #[values(PartitionMode::CollectLeft, PartitionMode::Partitioned)]+ mode: PartitionMode,+ ) -> Result<()> {+ let SparseKeyJoinInputs { build, probe, on } = sparse_key_join_inputs()?;+ let (join, filter) = hash_join_with_dynamic_filter_and_mode(+ build,+ probe,+ on,+ JoinType::Inner,+ mode,+ )?;+ let join: Arc<dyn ExecutionPlan> = Arc::new(join);++ let pool: Arc<dyn MemoryPool> = Arc::new(GreedyMemoryPool::new(1 << 20));+ let runtime = RuntimeEnvBuilder::new()+ .with_memory_pool(Arc::clone(&pool))+ .build_arc()?;+ let mut config = SessionConfig::new();+ config+ .options_mut()+ .optimizer+ .hash_join_inlist_pushdown_max_size = 0;+ let task_ctx = Arc::new(+ TaskContext::default()+ .with_runtime(runtime)+ .with_session_config(config),+ );+ let batches = common::collect(join.execute(0, task_ctx)?).await?;+ assert_eq!(batches.iter().map(|b| b.num_rows()).sum::<usize>(), 3);++ let build_mem_used = join+ .metrics()+ .unwrap()+ .sum_by_name("build_mem_used")+ .unwrap()+ .as_usize();+ let keys = sparse_keys();+ let map_bytes =+ estimate_memory_size::<(u32, u64)>(keys.len(), size_of::<JoinHashMapU32>())?+ + keys.len() * size_of::<u32>();+ let keys_array: ArrayRef = Arc::new(Int64Array::from(keys.clone()));+ let bitmap_bytes = KeyRangeBitmap::try_new(+ &keys_array,+ &ScalarValue::Int64(Some(0)),+ &ScalarValue::Int64(Some(keys[keys.len() - 1])),+ keys.len(),+ )+ .map_or(0, |bitmap| bitmap.size());+ let expected = match mode {+ // The stream is gone; only the map and its bitmap are still held.+ PartitionMode::Partitioned => map_bytes + bitmap_bytes,+ PartitionMode::CollectLeft => build_mem_used,+ PartitionMode::Auto => unreachable!(),+ };+ assert_eq!(pool.reserved(), expected);++ // The filter is the last holder.+ drop(join);+ assert_eq!(pool.reserved(), map_bytes + bitmap_bytes);+ drop(filter);+ assert_eq!(pool.reserved(), 0);+ Ok(())+ }++ /// Dense keys build an `ArrayMap`, which is charged to the map's own+ /// reservation in `array_map_key_range` rather than the build's.+ #[rstest]+ #[tokio::test]+ async fn array_map_stays_reserved_with_dynamic_filter(+ #[values(PartitionMode::CollectLeft, PartitionMode::Partitioned)]+ mode: PartitionMode,+ ) -> Result<()> {+ let schema = Arc::new(Schema::new(vec![Field::new("k", DataType::Int64, false)]));+ let batch = |keys: Vec<i64>| {+ let column = Arc::new(Int64Array::from(keys)) as ArrayRef;+ let batch = RecordBatch::try_new(Arc::clone(&schema), vec![column])?;+ TestMemoryExec::try_new_exec(&[vec![batch]], Arc::clone(&schema), None)+ };+ let on = vec![(+ Arc::new(Column::new_with_schema("k", &schema)?) as _,+ Arc::new(Column::new_with_schema("k", &schema)?) as _,+ )];+ let (join, filter) = hash_join_with_dynamic_filter_and_mode(+ batch((0..20_000).collect())?,+ batch(vec![0, 5, 15])?,+ on,+ JoinType::Inner,+ mode,+ )?;+ let join: Arc<dyn ExecutionPlan> = Arc::new(join);++ let pool: Arc<dyn MemoryPool> = Arc::new(GreedyMemoryPool::new(1 << 22));+ let runtime = RuntimeEnvBuilder::new()+ .with_memory_pool(Arc::clone(&pool))+ .build_arc()?;+ let mut config = SessionConfig::new();+ config+ .options_mut()+ .optimizer+ .hash_join_inlist_pushdown_max_size = 0;+ let task_ctx = Arc::new(+ TaskContext::default()+ .with_runtime(runtime)+ .with_session_config(config),+ );+ let batches = common::collect(join.execute(0, task_ctx)?).await?;+ assert_eq!(batches.iter().map(|b| b.num_rows()).sum::<usize>(), 3);+ assert_phj_used(&join.metrics().unwrap(), true);++ drop(join);+ assert_eq!(+ pool.reserved(),+ ArrayMap::estimate_memory_size(0, 19_999, 20_000)+ );+ drop(filter);+ assert_eq!(pool.reserved(), 0);+ Ok(())+ }++ /// With rows in more than one build partition, the filter is a routed lookup+ /// that holds every partition's map, so the maps stay reserved until it is+ /// dropped.+ #[cfg(not(feature = "force_hash_collisions"))]+ #[tokio::test]+ async fn routed_maps_stay_reserved_with_dynamic_filter() -> Result<()> {+ let SparseKeyJoinInputs { build, probe, on } = sparse_key_join_inputs()?;+ let repartition = |input: Arc<dyn ExecutionPlan>, key: &PhysicalExprRef| {+ let partitioning = Partitioning::Hash(vec![Arc::clone(key)], 2);+ RepartitionExec::try_new(input, partitioning)+ };+ let (join, filter) = hash_join_with_dynamic_filter_and_mode(+ Arc::new(repartition(build, &on[0].0)?),+ Arc::new(repartition(probe, &on[0].1)?),+ on,+ JoinType::Inner,+ PartitionMode::Partitioned,+ )?;+ let join: Arc<dyn ExecutionPlan> = Arc::new(join);++ let pool: Arc<dyn MemoryPool> = Arc::new(GreedyMemoryPool::new(1 << 20));+ let runtime = RuntimeEnvBuilder::new()+ .with_memory_pool(Arc::clone(&pool))+ .build_arc()?;+ let mut config = SessionConfig::new();+ config+ .options_mut()+ .optimizer+ .hash_join_inlist_pushdown_max_size = 0;+ let task_ctx = Arc::new(+ TaskContext::default()+ .with_runtime(runtime)+ .with_session_config(config),+ );+ let batches = crate::execution_plan::collect(Arc::clone(&join), task_ctx).await?;+ assert_eq!(batches.iter().map(|b| b.num_rows()).sum::<usize>(), 3);+ assert!(format!("{:?}", filter.current()?).contains("routed by"));++ // Every stream is gone; only the maps and their bitmaps are still held.+ let reserved = pool.reserved();+ assert!(reserved > 0);+ // The filter is the last holder.+ drop(join);+ assert_eq!(pool.reserved(), reserved);+ drop(filter);+ assert_eq!(pool.reserved(), 0);+ Ok(())+ }+#[derive(Debug)]struct PartitionedTestExec {cache: Arc<PlanProperties>,diff --git a/datafusion/physical-plan/src/joins/hash_join/exec/prepared.rs b/datafusion/physical-plan/src/joins/hash_join/exec/prepared.rsindex 602d6a5193..d20e1431e5 100644--- a/datafusion/physical-plan/src/joins/hash_join/exec/prepared.rs+++ b/datafusion/physical-plan/src/joins/hash_join/exec/prepared.rs@@ -45,7 +45,7 @@ impl fmt::Debug for PreparedHashJoinBuild {impl PreparedHashJoinBuild {/// Return the retained build reservation, excluding all per-probe state.pub fn reserved_bytes(&self) -> usize {- self.build.reservation.size()+ self.build.reservation.size() + self.build.map.reserved_bytes()}/// Return the complete build row count, including duplicate and null keys.@@ -290,8 +290,8 @@ impl HashJoinExecBuilder {/// executions. An existing expression handle is preserved for its probe/// consumers, while the build-report accumulator is reset./// * Retain a prepared-build lease if a dynamic-filter expression outlives- /// this plan. Its array/map references preserve allocation lifetime, but- /// the lease is what preserves the corresponding memory charge.+ /// this plan. The map carries its own charge, but the IN-list arrays+ /// share the build batch, and the lease is what preserves their charge./// * Attach after physical optimizations that rewrite the build child./// Probe-only rewrites must preserve the attached join's `left()`; replacing/// it or making incompatible key, mode, or join-type changes fails.diff --git a/datafusion/physical-plan/src/joins/hash_join/partitioned_hash_eval.rs b/datafusion/physical-plan/src/joins/hash_join/partitioned_hash_eval.rsindex 66c7c75f61..ad52f23a52 100644--- a/datafusion/physical-plan/src/joins/hash_join/partitioned_hash_eval.rs+++ b/datafusion/physical-plan/src/joins/hash_join/partitioned_hash_eval.rs@@ -18,8 +18,8 @@ use datafusion_expr::ColumnarValue;use datafusion_expr_common::dyn_eq::DynHash;use datafusion_physical_expr_common::physical_expr::{PhysicalExpr, PhysicalExprRef};-use crate::joins::Map;use crate::joins::key_range_bitmap::KeyRangeBitmap;+use crate::joins::{Map, ReservedMap};use crate::repartition::RangeExpr;/// RandomState wrapper that preserves the seed used to create it.@@ -267,7 +267,7 @@ pub struct HashTableLookupExpr {on_columns: Vec<PhysicalExprRef>,/// Random state for hashing (with seeds preserved for serialization)random_state: SeededRandomState,- /// Map(s) to check against+ /// Map(s) to check against, with their reservationslookup: Lookup,/// Description for displaydescription: String,@@ -279,14 +279,14 @@ pub struct HashTableLookupExpr {#[derive(Clone)]enum Lookup {/// One map holding every build key, probed directly with no routing.- Single(Arc<Map>),+ Single(Arc<ReservedMap>),/// One hash table per build partition of a `Partitioned` join, `None` where/// the partition is empty. A key is only ever built into the partition its/// key routes to, so each probe row is looked up in that partition's table/// alone: no `CASE` over per-partition filters, and no merged table.Routed {router: PartitionRouter,- maps: Arc<[Option<Arc<Map>>]>,+ maps: Arc<[Option<Arc<ReservedMap>>]>,},}@@ -366,6 +366,30 @@ impl HashTableLookupExpr {maps: Vec<Option<Arc<Map>>>,description: String,pruning_bitmap: Option<Arc<KeyRangeBitmap>>,+ ) -> Result<Self> {+ let maps = maps+ .into_iter()+ .map(|map| map.map(ReservedMap::unreserved).map(Arc::new))+ .collect();+ Self::new_reserved(+ on_columns,+ random_state,+ router,+ maps,+ description,+ pruning_bitmap,+ )+ }++ /// [`Self::new`] for a join's maps, whose memory stays reserved while the+ /// lookup holds them.+ pub(crate) fn new_reserved(+ on_columns: Vec<PhysicalExprRef>,+ random_state: SeededRandomState,+ router: Option<PartitionRouter>,+ maps: Vec<Option<Arc<ReservedMap>>>,+ description: String,+ pruning_bitmap: Option<Arc<KeyRangeBitmap>>,) -> Result<Self> {let lookup = match (router, maps.as_slice()) {// Every row routes to the only partition, so skip routing.@@ -376,11 +400,10 @@ impl HashTableLookupExpr {);}(Some(router), _) => {- if maps- .iter()- .flatten()- .any(|map| !matches!(map.as_ref(), Map::HashMap(_)))- {+ if maps.iter().flatten().any(|map| {+ let map: &Map = map;+ !matches!(map, Map::HashMap(_))+ }) {return internal_err!("routed lookups only support hash table partitions");@@ -410,7 +433,7 @@ impl HashTableLookupExpr {&self,keys: &[ArrayRef],router: &PartitionRouter,- maps: &[Option<Arc<Map>>],+ maps: &[Option<Arc<ReservedMap>>],) -> Result<BooleanArray> {let num_rows = keys[0].len();let mut partition_ids = Vec::with_capacity(num_rows);@@ -441,7 +464,8 @@ impl HashTableLookupExpr {for (partition, map) in maps.iter().enumerate() {// An empty partition holds no key, so its rows stay unmatched.let Some(map) = map else { continue };- let Map::HashMap(map) = map.as_ref() else {+ let map: &Map = map;+ let Map::HashMap(map) = map else {return internal_err!("routed lookups only support hash table partitions");@@ -514,7 +538,7 @@ impl Lookup {/// created together with its maps, so the maps identify it as well.fn identity(&self) -> *const () {match self {- Lookup::Single(map) => Arc::as_ptr(map).cast(),+ Lookup::Single(map) => std::ptr::from_ref::<Map>(map).cast(),Lookup::Routed { maps, .. } => Arc::as_ptr(maps).cast(),}}@@ -557,18 +581,23 @@ impl PhysicalExpr for HashTableLookupExpr {let join_keys = evaluate_columns(&self.on_columns, batch)?;match &self.lookup {- Lookup::Single(map) => match map.as_ref() {- Map::HashMap(map) => {- with_hashes(&join_keys, self.random_state.random_state(), |hashes| {- let array = map.contain_hashes(hashes);+ Lookup::Single(map) => {+ let map: &Map = map;+ match map {+ Map::HashMap(map) => with_hashes(+ &join_keys,+ self.random_state.random_state(),+ |hashes| {+ let array = map.contain_hashes(hashes);+ Ok(ColumnarValue::Array(Arc::new(array)))+ },+ ),+ Map::ArrayMap(map) => {+ let array = map.contain_keys(&join_keys)?;Ok(ColumnarValue::Array(Arc::new(array)))- })- }- Map::ArrayMap(map) => {- let array = map.contain_keys(&join_keys)?;- Ok(ColumnarValue::Array(Arc::new(array)))+ }}- },+ }Lookup::Routed { router, maps } => {let array = self.evaluate_routed(&join_keys, router, maps)?;Ok(ColumnarValue::Array(Arc::new(array)))diff --git a/datafusion/physical-plan/src/joins/hash_join/shared_bounds.rs b/datafusion/physical-plan/src/joins/hash_join/shared_bounds.rsindex 321ca4b10d..395e8c92f8 100644--- a/datafusion/physical-plan/src/joins/hash_join/shared_bounds.rs+++ b/datafusion/physical-plan/src/joins/hash_join/shared_bounds.rs@@ -13,6 +13,7 @@ use crate::ExecutionPlanProperties;use crate::Partitioning;use crate::joins::Map;use crate::joins::PartitionMode;+use crate::joins::ReservedMap;use crate::joins::hash_join::exec::HASH_JOIN_SEED;use crate::joins::hash_join::inlist_builder::build_struct_fields;use crate::joins::hash_join::not_in::NotIn;@@ -160,7 +161,7 @@ fn create_membership_predicate(}// Use hash table lookup for large build sidesPushdownStrategy::Map(hash_map, pruning_bitmap) => {- Ok(Some(Arc::new(HashTableLookupExpr::new(+ Ok(Some(Arc::new(HashTableLookupExpr::new_reserved(on_right.to_vec(),random_state.clone(),None,@@ -312,7 +313,7 @@ pub(crate) enum PushdownStrategy {InList(ArrayRef),/// Use map lookup for large build sides. If `Some` the second field/// represents the build side's keys using a bucket bitmap.- Map(Arc<Map>, Option<Arc<KeyRangeBitmap>>),+ Map(Arc<ReservedMap>, Option<Arc<KeyRangeBitmap>>),/// There was no data in this partition, do not build a dynamic filter for itEmpty,}@@ -723,7 +724,8 @@ impl SharedBuildAccumulator {keys_have_null |= partition_keys_have_null;let mergeable = match &pushdown {PushdownStrategy::Map(map, _) => {- matches!(map.as_ref(), Map::HashMap(_))+ let map: &Map = map;+ matches!(map, Map::HashMap(_))}PushdownStrategy::InList(_) => true,PushdownStrategy::Empty => false,@@ -914,7 +916,7 @@ impl SharedBuildAccumulator {}});}- Arc::new(HashTableLookupExpr::new(+ Arc::new(HashTableLookupExpr::new_reserved(self.on_right.clone(),HASH_JOIN_SEED,Some(self.partition_router(num_partitions)?),@@ -953,7 +955,10 @@ impl SharedBuildAccumulator {/// A hash table of an IN list partition's keys, hashed as the probe side/// hashes its join keys: one column per join key.- fn in_list_hash_map(&self, values: &ArrayRef) -> Result<Arc<Map>> {+ ///+ /// The table is not reserved, same as the IN list it is built from. Its+ /// size follows that list, which `hash_join_inlist_pushdown_max_size` caps.+ fn in_list_hash_map(&self, values: &ArrayRef) -> Result<Arc<ReservedMap>> {let columns = match values.as_struct_opt() {Some(columns) if self.on_right.len() > 1 => columns.columns(),_ => std::slice::from_ref(values),@@ -962,7 +967,8 @@ impl SharedBuildAccumulator {create_hashes(columns, HASH_JOIN_SEED.random_state(), &mut hashes)?;let mut map = JoinHashMapU32::with_capacity(hashes.len());map.update_from_iter(Box::new(hashes.iter().enumerate()), 0);- Ok(Arc::new(Map::HashMap(Box::new(map))))+ let map = Arc::new(Map::HashMap(Box::new(map)));+ Ok(Arc::new(ReservedMap::unreserved(map)))}/// Container pruning reads one bitmap, so merge the partitions' key ranges:@@ -1341,10 +1347,8 @@ mod tests {}fn hash_map() -> PushdownStrategy {- PushdownStrategy::Map(- Arc::new(Map::HashMap(Box::new(JoinHashMapU32::with_capacity(1)))),- None,- )+ let map = Arc::new(Map::HashMap(Box::new(JoinHashMapU32::with_capacity(1))));+ PushdownStrategy::Map(Arc::new(ReservedMap::unreserved(map)), None)}#[test]@@ -1375,7 +1379,8 @@ mod tests {create_hashes([&keys], HASH_JOIN_SEED.random_state(), &mut hashes).unwrap();let mut map = JoinHashMapU32::with_capacity(keys.len());map.update_from_iter(Box::new(hashes.iter().enumerate()), 0);- PushdownStrategy::Map(Arc::new(Map::HashMap(Box::new(map))), None)+ let map = Arc::new(Map::HashMap(Box::new(map)));+ PushdownStrategy::Map(Arc::new(ReservedMap::unreserved(map)), None)}/// Splits `keys` across `num_partitions` build partitions as hashdiff --git a/datafusion/physical-plan/src/joins/mod.rs b/datafusion/physical-plan/src/joins/mod.rsindex a6bc4e6317..c4549d847f 100644--- a/datafusion/physical-plan/src/joins/mod.rs+++ b/datafusion/physical-plan/src/joins/mod.rs@@ -6,10 +6,14 @@use core::fmt;use std::fmt::{Display, Formatter};+use std::ops::Deref;+use std::sync::Arc;use arrow::array::BooleanBufferBuilder;pub use asof_join::{AsOfJoinExec, AsOfMatchExpr};pub use cross_join::CrossJoinExec;+use datafusion_common::{Result, internal_err};+use datafusion_execution::memory_pool::MemoryReservation;use datafusion_physical_expr::PhysicalExprRef;/// # Public Only for Internal Use:///@@ -94,6 +98,56 @@ impl Map {}}+/// A [`Map`] and the reservation for its memory, which the dynamic filter+/// shares for as long as the plan lives. Held together, the memory stays+/// reserved until the last holder drops the map.+pub(crate) struct ReservedMap {+ /// Shared, as [`HashTableLookupExpr::new`] takes one and compares by it.+ map: Arc<Map>,+ /// Also charged for data kept with the map, such as the pruning bitmap.+ /// `None` for a map built outside a join; see [`HashTableLookupExpr::new`].+ // Keep the reservation after the map it accounts for.+ reservation: Option<MemoryReservation>,+}++impl ReservedMap {+ /// Wraps `map` with the reservation it was charged to.+ pub(crate) fn new(map: Map, reservation: MemoryReservation) -> Self {+ Self {+ map: Arc::new(map),+ reservation: Some(reservation),+ }+ }++ /// Wraps a map that was not charged to a pool.+ pub(crate) fn unreserved(map: Arc<Map>) -> Self {+ Self {+ map,+ reservation: None,+ }+ }++ /// Charges `bytes` for data kept with the map.+ pub(crate) fn try_grow(&self, bytes: usize) -> Result<()> {+ match &self.reservation {+ Some(reservation) => reservation.try_grow(bytes),+ None => internal_err!("ReservedMap has no reservation to grow"),+ }+ }++ pub(crate) fn reserved_bytes(&self) -> usize {+ self.reservation.as_ref().map_or(0, MemoryReservation::size)+ }+}++impl Deref for ReservedMap {+ type Target = Map;++ fn deref(&self) -> &Map {+ &self.map+ }+}+#[cfg(test)]pub mod test_utils;