duckdb 1.0.1-dev21.0 → 1.0.1-dev27.0

package/src/duckdb/src/execution/operator/join/physical_hash_join.cpp

@@ -1,18 +1,22 @@
 #include "duckdb/execution/operator/join/physical_hash_join.hpp"
 
-#include "duckdb/common/vector_operations/vector_operations.hpp"
+#include "duckdb/common/radix_partitioning.hpp"
 #include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/execution/operator/aggregate/ungrouped_aggregate_state.hpp"
 #include "duckdb/function/aggregate/distributive_functions.hpp"
 #include "duckdb/function/function_binder.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/query_profiler.hpp"
 #include "duckdb/parallel/base_pipeline_event.hpp"
+#include "duckdb/parallel/executor_task.hpp"
 #include "duckdb/parallel/interrupt.hpp"
 #include "duckdb/parallel/pipeline.hpp"
 #include "duckdb/parallel/thread_context.hpp"
-#include "duckdb/parallel/executor_task.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
+#include "duckdb/planner/filter/constant_filter.hpp"
+#include "duckdb/planner/filter/null_filter.hpp"
+#include "duckdb/planner/table_filter.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
 #include "duckdb/storage/storage_manager.hpp"
 #include "duckdb/storage/temporary_memory_manager.hpp"
@@ -23,11 +27,14 @@ PhysicalHashJoin::PhysicalHashJoin(LogicalOperator &op, unique_ptr<PhysicalOpera
                                    unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond, JoinType join_type,
                                    const vector<idx_t> &left_projection_map, const vector<idx_t> &right_projection_map,
                                    vector<LogicalType> delim_types, idx_t estimated_cardinality,
-                                   PerfectHashJoinStats perfect_join_stats)
+                                   PerfectHashJoinStats perfect_join_stats,
+                                   unique_ptr<JoinFilterPushdownInfo> pushdown_info_p)
     : PhysicalComparisonJoin(op, PhysicalOperatorType::HASH_JOIN, std::move(cond), join_type, estimated_cardinality),
       delim_types(std::move(delim_types)), perfect_join_statistics(std::move(perfect_join_stats)) {
 	D_ASSERT(left_projection_map.empty());
 
+	filter_pushdown = std::move(pushdown_info_p);
+
 	children.push_back(std::move(left));
 	children.push_back(std::move(right));
 
@@ -79,30 +86,51 @@ PhysicalHashJoin::PhysicalHashJoin(LogicalOperator &op, unique_ptr<PhysicalOpera
                                    unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond, JoinType join_type,
                                    idx_t estimated_cardinality, PerfectHashJoinStats perfect_join_state)
     : PhysicalHashJoin(op, std::move(left), std::move(right), std::move(cond), join_type, {}, {}, {},
-                       estimated_cardinality, std::move(perfect_join_state)) {
+                       estimated_cardinality, std::move(perfect_join_state), nullptr) {
 }
 
 //===--------------------------------------------------------------------===//
 // Sink
 //===--------------------------------------------------------------------===//
+JoinFilterGlobalState::~JoinFilterGlobalState() {
+}
+
+JoinFilterLocalState::~JoinFilterLocalState() {
+}
+
+unique_ptr<JoinFilterGlobalState> JoinFilterPushdownInfo::GetGlobalState(ClientContext &context,
+                                                                         const PhysicalOperator &op) const {
+	// clear any previously set filters
+	// we can have previous filters for this operator in case of e.g. recursive CTEs
+	dynamic_filters->ClearFilters(op);
+	auto result = make_uniq<JoinFilterGlobalState>();
+	result->global_aggregate_state =
+	    make_uniq<GlobalUngroupedAggregateState>(BufferAllocator::Get(context), min_max_aggregates);
+	return result;
+}
+
 class HashJoinGlobalSinkState : public GlobalSinkState {
 public:
-	HashJoinGlobalSinkState(const PhysicalHashJoin &op, ClientContext &context_p)
-	    : context(context_p), num_threads(NumericCast<idx_t>(TaskScheduler::GetScheduler(context).NumberOfThreads())),
-	      temporary_memory_update_count(0),
+	HashJoinGlobalSinkState(const PhysicalHashJoin &op_p, ClientContext &context_p)
+	    : context(context_p), op(op_p),
+	      num_threads(NumericCast<idx_t>(TaskScheduler::GetScheduler(context).NumberOfThreads())),
 	      temporary_memory_state(TemporaryMemoryManager::Get(context).Register(context)), finalized(false),
-	      scanned_data(false) {
+	      active_local_states(0), total_size(0), max_partition_size(0), max_partition_count(0), scanned_data(false) {
 		hash_table = op.InitializeHashTable(context);
 
-		// for perfect hash join
+		// For perfect hash join
 		perfect_join_executor = make_uniq<PerfectHashJoinExecutor>(op, *hash_table, op.perfect_join_statistics);
-		// for external hash join
+		// For external hash join
 		external = ClientConfig::GetConfig(context).force_external;
 		// Set probe types
 		const auto &payload_types = op.children[0]->types;
 		probe_types.insert(probe_types.end(), op.condition_types.begin(), op.condition_types.end());
 		probe_types.insert(probe_types.end(), payload_types.begin(), payload_types.end());
 		probe_types.emplace_back(LogicalType::HASH);
+
+		if (op.filter_pushdown) {
+			global_filter_state = op.filter_pushdown->GetGlobalState(context, op);
+		}
 	}
 
 	void ScheduleFinalize(Pipeline &pipeline, Event &event);
@@ -110,9 +138,9 @@ public:
 
 public:
 	ClientContext &context;
+	const PhysicalHashJoin &op;
 
 	const idx_t num_threads;
-	atomic<idx_t> temporary_memory_update_count;
 	//! Temporary memory state for managing this operator's memory usage
 	unique_ptr<TemporaryMemoryState> temporary_memory_state;
 
@@ -121,13 +149,17 @@ public:
 	//! The perfect hash join executor (if any)
 	unique_ptr<PerfectHashJoinExecutor> perfect_join_executor;
 	//! Whether or not the hash table has been finalized
-	bool finalized = false;
+	bool finalized;
+	//! The number of active local states
+	atomic<idx_t> active_local_states;
 
-	//! Whether we are doing an external join
+	//! Whether we are doing an external + some sizes
 	bool external;
+	idx_t total_size;
+	idx_t max_partition_size;
+	idx_t max_partition_count;
 
 	//! Hash tables built by each thread
-	mutex lock;
 	vector<unique_ptr<JoinHashTable>> local_hash_tables;
 
 	//! Excess probe data gathered during Sink
@@ -136,12 +168,20 @@ public:
 
 	//! Whether or not we have started scanning data using GetData
 	atomic<bool> scanned_data;
+
+	unique_ptr<JoinFilterGlobalState> global_filter_state;
 };
 
+unique_ptr<JoinFilterLocalState> JoinFilterPushdownInfo::GetLocalState(JoinFilterGlobalState &gstate) const {
+	auto result = make_uniq<JoinFilterLocalState>();
+	result->local_aggregate_state = make_uniq<LocalUngroupedAggregateState>(*gstate.global_aggregate_state);
+	return result;
+}
+
 class HashJoinLocalSinkState : public LocalSinkState {
 public:
-	HashJoinLocalSinkState(const PhysicalHashJoin &op, ClientContext &context)
-	    : join_key_executor(context), chunk_count(0) {
+	HashJoinLocalSinkState(const PhysicalHashJoin &op, ClientContext &context, HashJoinGlobalSinkState &gstate)
+	    : join_key_executor(context) {
 		auto &allocator = BufferAllocator::Get(context);
 
 		for (auto &cond : op.conditions) {
@@ -155,6 +195,12 @@ public:
 
 		hash_table = op.InitializeHashTable(context);
 		hash_table->GetSinkCollection().InitializeAppendState(append_state);
+
+		gstate.active_local_states++;
+
+		if (op.filter_pushdown) {
+			local_filter_state = op.filter_pushdown->GetLocalState(*gstate.global_filter_state);
+		}
 	}
 
 public:
@@ -168,14 +214,11 @@ public:
 	//! Thread-local HT
 	unique_ptr<JoinHashTable> hash_table;
 
-	//! For updating the temporary memory state
-	idx_t chunk_count;
-	static constexpr const idx_t CHUNK_COUNT_UPDATE_INTERVAL = 60;
+	unique_ptr<JoinFilterLocalState> local_filter_state;
 };
 
 unique_ptr<JoinHashTable> PhysicalHashJoin::InitializeHashTable(ClientContext &context) const {
-	auto result = make_uniq<JoinHashTable>(BufferManager::GetBufferManager(context), conditions, payload_types,
-	                                       join_type, rhs_output_columns);
+	auto result = make_uniq<JoinHashTable>(context, conditions, payload_types, join_type, rhs_output_columns);
 	if (!delim_types.empty() && join_type == JoinType::MARK) {
 		// correlated MARK join
 		if (delim_types.size() + 1 == conditions.size()) {
@@ -229,7 +272,19 @@ unique_ptr<GlobalSinkState> PhysicalHashJoin::GetGlobalSinkState(ClientContext &
 }
 
 unique_ptr<LocalSinkState> PhysicalHashJoin::GetLocalSinkState(ExecutionContext &context) const {
-	return make_uniq<HashJoinLocalSinkState>(*this, context.client);
+	auto &gstate = sink_state->Cast<HashJoinGlobalSinkState>();
+	return make_uniq<HashJoinLocalSinkState>(*this, context.client, gstate);
+}
+
+void JoinFilterPushdownInfo::Sink(DataChunk &chunk, JoinFilterLocalState &lstate) const {
+	// if we are pushing any filters into a probe-side, compute the min/max over the columns that we are pushing
+	for (idx_t pushdown_idx = 0; pushdown_idx < filters.size(); pushdown_idx++) {
+		auto &pushdown = filters[pushdown_idx];
+		for (idx_t i = 0; i < 2; i++) {
+			idx_t aggr_idx = pushdown_idx * 2 + i;
+			lstate.local_aggregate_state->Sink(chunk, pushdown.join_condition, aggr_idx);
+		}
+	}
 }
 
 SinkResultType PhysicalHashJoin::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
@@ -239,6 +294,10 @@ SinkResultType PhysicalHashJoin::Sink(ExecutionContext &context, DataChunk &chun
 	lstate.join_keys.Reset();
 	lstate.join_key_executor.Execute(chunk, lstate.join_keys);
 
+	if (filter_pushdown) {
+		filter_pushdown->Sink(lstate.join_keys, *lstate.local_filter_state);
+	}
+
 	// build the HT
 	auto &ht = *lstate.hash_table;
 	if (payload_types.empty()) {
@@ -255,29 +314,31 @@ SinkResultType PhysicalHashJoin::Sink(ExecutionContext &context, DataChunk &chun
 		ht.Build(lstate.append_state, lstate.join_keys, lstate.payload_chunk);
 	}
 
-	if (++lstate.chunk_count % HashJoinLocalSinkState::CHUNK_COUNT_UPDATE_INTERVAL == 0) {
-		auto &gstate = input.global_state.Cast<HashJoinGlobalSinkState>();
-		if (++gstate.temporary_memory_update_count % gstate.num_threads == 0) {
-			auto &sink_collection = lstate.hash_table->GetSinkCollection();
-			auto ht_size = sink_collection.SizeInBytes() + JoinHashTable::PointerTableSize(sink_collection.Count());
-			gstate.temporary_memory_state->SetRemainingSize(context.client, gstate.num_threads * ht_size);
-		}
-	}
-
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
+void JoinFilterPushdownInfo::Combine(JoinFilterGlobalState &gstate, JoinFilterLocalState &lstate) const {
+	gstate.global_aggregate_state->Combine(*lstate.local_aggregate_state);
+}
+
 SinkCombineResultType PhysicalHashJoin::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
 	auto &gstate = input.global_state.Cast<HashJoinGlobalSinkState>();
 	auto &lstate = input.local_state.Cast<HashJoinLocalSinkState>();
-	if (lstate.hash_table) {
-		lstate.hash_table->GetSinkCollection().FlushAppendState(lstate.append_state);
-		lock_guard<mutex> local_ht_lock(gstate.lock);
-		gstate.local_hash_tables.push_back(std::move(lstate.hash_table));
+
+	lstate.hash_table->GetSinkCollection().FlushAppendState(lstate.append_state);
+	auto guard = gstate.Lock();
+	gstate.local_hash_tables.push_back(std::move(lstate.hash_table));
+	if (gstate.local_hash_tables.size() == gstate.active_local_states) {
+		// Set to 0 until PrepareFinalize
+		gstate.temporary_memory_state->SetZero();
 	}
+
 	auto &client_profiler = QueryProfiler::Get(context.client);
-	context.thread.profiler.Flush(*this, lstate.join_key_executor, "join_key_executor", 1);
+	context.thread.profiler.Flush(*this);
 	client_profiler.Flush(context.thread.profiler);
+	if (filter_pushdown) {
+		filter_pushdown->Combine(*gstate.global_filter_state, *lstate.local_filter_state);
+	}
 
 	return SinkCombineResultType::FINISHED;
 }
@@ -285,11 +346,48 @@ SinkCombineResultType PhysicalHashJoin::Combine(ExecutionContext &context, Opera
 //===--------------------------------------------------------------------===//
 // Finalize
 //===--------------------------------------------------------------------===//
+static idx_t GetTupleWidth(const vector<LogicalType> &types, bool &all_constant) {
+	idx_t tuple_width = 0;
+	all_constant = true;
+	for (auto &type : types) {
+		tuple_width += GetTypeIdSize(type.InternalType());
+		all_constant &= TypeIsConstantSize(type.InternalType());
+	}
+	return tuple_width + AlignValue(types.size()) / 8 + GetTypeIdSize(PhysicalType::UINT64);
+}
+
+static idx_t GetPartitioningSpaceRequirement(ClientContext &context, const vector<LogicalType> &types,
+                                             const idx_t radix_bits, const idx_t num_threads) {
+	auto &buffer_manager = BufferManager::GetBufferManager(context);
+	bool all_constant;
+	idx_t tuple_width = GetTupleWidth(types, all_constant);
+
+	auto tuples_per_block = buffer_manager.GetBlockSize() / tuple_width;
+	auto blocks_per_chunk = (STANDARD_VECTOR_SIZE + tuples_per_block) / tuples_per_block + 1;
+	if (!all_constant) {
+		blocks_per_chunk += 2;
+	}
+	auto size_per_partition = blocks_per_chunk * buffer_manager.GetBlockAllocSize();
+	auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
+
+	return num_threads * num_partitions * size_per_partition;
+}
+
+void PhysicalHashJoin::PrepareFinalize(ClientContext &context, GlobalSinkState &global_state) const {
+	auto &gstate = global_state.Cast<HashJoinGlobalSinkState>();
+	auto &ht = *gstate.hash_table;
+	gstate.total_size =
+	    ht.GetTotalSize(gstate.local_hash_tables, gstate.max_partition_size, gstate.max_partition_count);
+	bool all_constant;
+	gstate.temporary_memory_state->SetMaterializationPenalty(GetTupleWidth(children[0]->types, all_constant));
+	gstate.temporary_memory_state->SetRemainingSize(gstate.total_size);
+}
+
 class HashJoinFinalizeTask : public ExecutorTask {
 public:
 	HashJoinFinalizeTask(shared_ptr<Event> event_p, ClientContext &context, HashJoinGlobalSinkState &sink_p,
-	                     idx_t chunk_idx_from_p, idx_t chunk_idx_to_p, bool parallel_p)
-	    : ExecutorTask(context, std::move(event_p)), sink(sink_p), chunk_idx_from(chunk_idx_from_p),
+	                     idx_t chunk_idx_from_p, idx_t chunk_idx_to_p, bool parallel_p, const PhysicalOperator &op_p)
+	    : ExecutorTask(context, std::move(event_p), op_p), sink(sink_p), chunk_idx_from(chunk_idx_from_p),
 	      chunk_idx_to(chunk_idx_to_p), parallel(parallel_p) {
 	}
 
@@ -321,11 +419,11 @@ public:
 		vector<shared_ptr<Task>> finalize_tasks;
 		auto &ht = *sink.hash_table;
 		const auto chunk_count = ht.GetDataCollection().ChunkCount();
-		const auto num_threads = NumericCast<idx_t>(TaskScheduler::GetScheduler(context).NumberOfThreads());
+		const auto num_threads = NumericCast<idx_t>(sink.num_threads);
 		if (num_threads == 1 || (ht.Count() < PARALLEL_CONSTRUCT_THRESHOLD && !context.config.verify_parallelism)) {
 			// Single-threaded finalize
 			finalize_tasks.push_back(
-			    make_uniq<HashJoinFinalizeTask>(shared_from_this(), context, sink, 0U, chunk_count, false));
+			    make_uniq<HashJoinFinalizeTask>(shared_from_this(), context, sink, 0U, chunk_count, false, sink.op));
 		} else {
 			// Parallel finalize
 			auto chunks_per_thread = MaxValue<idx_t>((chunk_count + num_threads - 1) / num_threads, 1);
@@ -335,7 +433,7 @@ public:
 				auto chunk_idx_from = chunk_idx;
 				auto chunk_idx_to = MinValue<idx_t>(chunk_idx_from + chunks_per_thread, chunk_count);
 				finalize_tasks.push_back(make_uniq<HashJoinFinalizeTask>(shared_from_this(), context, sink,
-				                                                         chunk_idx_from, chunk_idx_to, true));
+				                                                         chunk_idx_from, chunk_idx_to, true, sink.op));
 				chunk_idx = chunk_idx_to;
 				if (chunk_idx == chunk_count) {
 					break;
@@ -364,7 +462,7 @@ void HashJoinGlobalSinkState::ScheduleFinalize(Pipeline &pipeline, Event &event)
 }
 
 void HashJoinGlobalSinkState::InitializeProbeSpill() {
-	lock_guard<mutex> guard(lock);
+	auto guard = Lock();
 	if (!probe_spill) {
 		probe_spill = make_uniq<JoinHashTable::ProbeSpill>(*hash_table, context, probe_types);
 	}
@@ -373,8 +471,8 @@ void HashJoinGlobalSinkState::InitializeProbeSpill() {
 class HashJoinRepartitionTask : public ExecutorTask {
 public:
 	HashJoinRepartitionTask(shared_ptr<Event> event_p, ClientContext &context, JoinHashTable &global_ht,
-	                        JoinHashTable &local_ht)
-	    : ExecutorTask(context, std::move(event_p)), global_ht(global_ht), local_ht(local_ht) {
+	                        JoinHashTable &local_ht, const PhysicalOperator &op_p)
+	    : ExecutorTask(context, std::move(event_p), op_p), global_ht(global_ht), local_ht(local_ht) {
 	}
 
 	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
@@ -390,17 +488,19 @@ private:
 
 class HashJoinRepartitionEvent : public BasePipelineEvent {
 public:
-	HashJoinRepartitionEvent(Pipeline &pipeline_p, HashJoinGlobalSinkState &sink,
+	HashJoinRepartitionEvent(Pipeline &pipeline_p, const PhysicalHashJoin &op_p, HashJoinGlobalSinkState &sink,
 	                         vector<unique_ptr<JoinHashTable>> &local_hts)
-	    : BasePipelineEvent(pipeline_p), sink(sink), local_hts(local_hts) {
+	    : BasePipelineEvent(pipeline_p), op(op_p), sink(sink), local_hts(local_hts) {
 	}
 
+	const PhysicalHashJoin &op;
 	HashJoinGlobalSinkState &sink;
 	vector<unique_ptr<JoinHashTable>> &local_hts;
 
 public:
 	void Schedule() override {
 		D_ASSERT(sink.hash_table->GetRadixBits() > JoinHashTable::INITIAL_RADIX_BITS);
+		auto block_size = sink.hash_table->buffer_manager.GetBlockSize();
 
 		idx_t total_size = 0;
 		idx_t total_count = 0;
@@ -409,14 +509,14 @@ public:
 			total_size += sink_collection.SizeInBytes();
 			total_count += sink_collection.Count();
 		}
-		auto total_blocks = NumericCast<idx_t>((double(total_size) + Storage::BLOCK_SIZE - 1) / Storage::BLOCK_SIZE);
+		auto total_blocks = (total_size + block_size - 1) / block_size;
 		auto count_per_block = total_count / total_blocks;
 		auto blocks_per_vector = MaxValue<idx_t>(STANDARD_VECTOR_SIZE / count_per_block, 2);
 
 		// Assume 8 blocks per partition per thread (4 input, 4 output)
 		auto partition_multiplier =
 		    RadixPartitioning::NumberOfPartitions(sink.hash_table->GetRadixBits() - JoinHashTable::INITIAL_RADIX_BITS);
-		auto thread_memory = 2 * blocks_per_vector * partition_multiplier * Storage::BLOCK_SIZE;
+		auto thread_memory = 2 * blocks_per_vector * partition_multiplier * block_size;
 		auto repartition_threads = MaxValue<idx_t>(sink.temporary_memory_state->GetReservation() / thread_memory, 1);
 
 		if (repartition_threads < local_hts.size()) {
@@ -433,7 +533,7 @@ public:
 		partition_tasks.reserve(local_hts.size());
 		for (auto &local_ht : local_hts) {
 			partition_tasks.push_back(
-			    make_uniq<HashJoinRepartitionTask>(shared_from_this(), context, *sink.hash_table, *local_ht));
+			    make_uniq<HashJoinRepartitionTask>(shared_from_this(), context, *sink.hash_table, *local_ht, op));
 		}
 		SetTasks(std::move(partition_tasks));
 	}
@@ -445,40 +545,88 @@ public:
 		const auto num_partitions = RadixPartitioning::NumberOfPartitions(sink.hash_table->GetRadixBits());
 		vector<idx_t> partition_sizes(num_partitions, 0);
 		vector<idx_t> partition_counts(num_partitions, 0);
-		idx_t max_partition_size;
-		idx_t max_partition_count;
-		sink.hash_table->GetTotalSize(partition_sizes, partition_counts, max_partition_size, max_partition_count);
-		sink.temporary_memory_state->SetMinimumReservation(max_partition_size +
-		                                                   JoinHashTable::PointerTableSize(max_partition_count));
+		sink.total_size = sink.hash_table->GetTotalSize(partition_sizes, partition_counts, sink.max_partition_size,
+		                                                sink.max_partition_count);
+		const auto probe_side_requirement =
+		    GetPartitioningSpaceRequirement(sink.context, op.types, sink.hash_table->GetRadixBits(), sink.num_threads);
+
+		sink.temporary_memory_state->SetMinimumReservation(sink.max_partition_size +
+		                                                   JoinHashTable::PointerTableSize(sink.max_partition_count) +
+		                                                   probe_side_requirement);
+		sink.temporary_memory_state->UpdateReservation(executor.context);
+
 		sink.hash_table->PrepareExternalFinalize(sink.temporary_memory_state->GetReservation());
 		sink.ScheduleFinalize(*pipeline, *this);
 	}
 };
 
+void JoinFilterPushdownInfo::PushFilters(JoinFilterGlobalState &gstate, const PhysicalOperator &op) const {
+	// finalize the min/max aggregates
+	vector<LogicalType> min_max_types;
+	for (auto &aggr_expr : min_max_aggregates) {
+		min_max_types.push_back(aggr_expr->return_type);
+	}
+	DataChunk final_min_max;
+	final_min_max.Initialize(Allocator::DefaultAllocator(), min_max_types);
+
+	gstate.global_aggregate_state->Finalize(final_min_max);
+
+	// create a filter for each of the aggregates
+	for (idx_t filter_idx = 0; filter_idx < filters.size(); filter_idx++) {
+		auto &filter = filters[filter_idx];
+		auto filter_col_idx = filter.probe_column_index.column_index;
+		auto min_idx = filter_idx * 2;
+		auto max_idx = min_idx + 1;
+
+		auto min_val = final_min_max.data[min_idx].GetValue(0);
+		auto max_val = final_min_max.data[max_idx].GetValue(0);
+		if (min_val.IsNull() || max_val.IsNull()) {
+			// min/max is NULL
+			// this can happen in case all values in the RHS column are NULL, but they are still pushed into the hash
+			// table e.g. because they are part of a RIGHT join
+			continue;
+		}
+		if (Value::NotDistinctFrom(min_val, max_val)) {
+			// min = max - generate an equality filter
+			auto constant_filter = make_uniq<ConstantFilter>(ExpressionType::COMPARE_EQUAL, std::move(min_val));
+			dynamic_filters->PushFilter(op, filter_col_idx, std::move(constant_filter));
+		} else {
+			// min != max - generate a range filter
+			auto greater_equals =
+			    make_uniq<ConstantFilter>(ExpressionType::COMPARE_GREATERTHANOREQUALTO, std::move(min_val));
+			dynamic_filters->PushFilter(op, filter_col_idx, std::move(greater_equals));
+			auto less_equals = make_uniq<ConstantFilter>(ExpressionType::COMPARE_LESSTHANOREQUALTO, std::move(max_val));
+			dynamic_filters->PushFilter(op, filter_col_idx, std::move(less_equals));
+		}
+		// not null filter
+		dynamic_filters->PushFilter(op, filter_col_idx, make_uniq<IsNotNullFilter>());
+	}
+}
+
 SinkFinalizeType PhysicalHashJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
                                             OperatorSinkFinalizeInput &input) const {
 	auto &sink = input.global_state.Cast<HashJoinGlobalSinkState>();
 	auto &ht = *sink.hash_table;
 
-	idx_t max_partition_size;
-	idx_t max_partition_count;
-	auto const total_size = ht.GetTotalSize(sink.local_hash_tables, max_partition_size, max_partition_count);
-	sink.temporary_memory_state->SetRemainingSize(context, total_size);
-
-	sink.external = sink.temporary_memory_state->GetReservation() < total_size;
+	sink.temporary_memory_state->UpdateReservation(context);
+	sink.external = sink.temporary_memory_state->GetReservation() < sink.total_size;
 	if (sink.external) {
-		const auto max_partition_ht_size = max_partition_size + JoinHashTable::PointerTableSize(max_partition_count);
 		// External Hash Join
 		sink.perfect_join_executor.reset();
+
+		const auto max_partition_ht_size =
+		    sink.max_partition_size + JoinHashTable::PointerTableSize(sink.max_partition_count);
 		if (max_partition_ht_size > sink.temporary_memory_state->GetReservation()) {
 			// We have to repartition
-			ht.SetRepartitionRadixBits(sink.local_hash_tables, sink.temporary_memory_state->GetReservation(),
-			                           max_partition_size, max_partition_count);
-			auto new_event = make_shared_ptr<HashJoinRepartitionEvent>(pipeline, sink, sink.local_hash_tables);
+			ht.SetRepartitionRadixBits(sink.temporary_memory_state->GetReservation(), sink.max_partition_size,
+			                           sink.max_partition_count);
+			auto new_event = make_shared_ptr<HashJoinRepartitionEvent>(pipeline, *this, sink, sink.local_hash_tables);
 			event.InsertEvent(std::move(new_event));
 		} else {
-			// No repartitioning!
-			sink.temporary_memory_state->SetMinimumReservation(max_partition_ht_size);
+			// No repartitioning! We do need some space for partitioning the probe-side, though
+			const auto probe_side_requirement =
+			    GetPartitioningSpaceRequirement(context, children[0]->types, ht.GetRadixBits(), sink.num_threads);
+			sink.temporary_memory_state->SetMinimumReservation(max_partition_ht_size + probe_side_requirement);
 			for (auto &local_ht : sink.local_hash_tables) {
 				ht.Merge(*local_ht);
 			}
@@ -488,13 +636,17 @@ SinkFinalizeType PhysicalHashJoin::Finalize(Pipeline &pipeline, Event &event, Cl
 		}
 		sink.finalized = true;
 		return SinkFinalizeType::READY;
-	} else {
-		// In-memory Hash Join
-		for (auto &local_ht : sink.local_hash_tables) {
-			ht.Merge(*local_ht);
-		}
-		sink.local_hash_tables.clear();
-		ht.Unpartition();
+	}
+
+	// In-memory Hash Join
+	for (auto &local_ht : sink.local_hash_tables) {
+		ht.Merge(*local_ht);
+	}
+	sink.local_hash_tables.clear();
+	ht.Unpartition();
+
+	if (filter_pushdown && ht.Count() > 0) {
+		filter_pushdown->PushFilters(*sink.global_filter_state, *this);
 	}
 
 	// check for possible perfect hash table
@@ -521,31 +673,32 @@ SinkFinalizeType PhysicalHashJoin::Finalize(Pipeline &pipeline, Event &event, Cl
 //===--------------------------------------------------------------------===//
 class HashJoinOperatorState : public CachingOperatorState {
 public:
-	explicit HashJoinOperatorState(ClientContext &context) : probe_executor(context), initialized(false) {
+	explicit HashJoinOperatorState(ClientContext &context, HashJoinGlobalSinkState &sink)
+	    : probe_executor(context), scan_structure(*sink.hash_table, join_key_state) {
 	}
 
 	DataChunk join_keys;
 	TupleDataChunkState join_key_state;
 
 	ExpressionExecutor probe_executor;
-	unique_ptr<JoinHashTable::ScanStructure> scan_structure;
+	JoinHashTable::ScanStructure scan_structure;
 	unique_ptr<OperatorState> perfect_hash_join_state;
 
-	bool initialized;
 	JoinHashTable::ProbeSpillLocalAppendState spill_state;
+	JoinHashTable::ProbeState probe_state;
 	//! Chunk to sink data into for external join
 	DataChunk spill_chunk;
 
 public:
 	void Finalize(const PhysicalOperator &op, ExecutionContext &context) override {
-		context.thread.profiler.Flush(op, probe_executor, "probe_executor", 0);
+		context.thread.profiler.Flush(op);
 	}
 };
 
 unique_ptr<OperatorState> PhysicalHashJoin::GetOperatorState(ExecutionContext &context) const {
 	auto &allocator = BufferAllocator::Get(context.client);
 	auto &sink = sink_state->Cast<HashJoinGlobalSinkState>();
-	auto state = make_uniq<HashJoinOperatorState>(context.client);
+	auto state = make_uniq<HashJoinOperatorState>(context.client, sink);
 	if (sink.perfect_join_executor) {
 		state->perfect_hash_join_state = sink.perfect_join_executor->GetOperatorState(context);
 	} else {
@@ -570,17 +723,12 @@ OperatorResultType PhysicalHashJoin::ExecuteInternal(ExecutionContext &context,
 	D_ASSERT(sink.finalized);
 	D_ASSERT(!sink.scanned_data);
 
-	// some initialization for external hash join
-	if (sink.external && !state.initialized) {
-		if (!sink.probe_spill) {
-			sink.InitializeProbeSpill();
+	if (sink.hash_table->Count() == 0) {
+		if (EmptyResultIfRHSIsEmpty()) {
+			return OperatorResultType::FINISHED;
 		}
-		state.spill_state = sink.probe_spill->RegisterThread();
-		state.initialized = true;
-	}
-
-	if (sink.hash_table->Count() == 0 && EmptyResultIfRHSIsEmpty()) {
-		return OperatorResultType::FINISHED;
+		ConstructEmptyJoinResult(sink.hash_table->join_type, sink.hash_table->has_null, input, chunk);
+		return OperatorResultType::NEED_MORE_INPUT;
 	}
 
 	if (sink.perfect_join_executor) {
@@ -588,34 +736,35 @@ OperatorResultType PhysicalHashJoin::ExecuteInternal(ExecutionContext &context,
 		return sink.perfect_join_executor->ProbePerfectHashTable(context, input, chunk, *state.perfect_hash_join_state);
 	}
 
-	if (state.scan_structure) {
-		// still have elements remaining (i.e. we got >STANDARD_VECTOR_SIZE elements in the previous probe)
-		state.scan_structure->Next(state.join_keys, input, chunk);
-		if (!state.scan_structure->PointersExhausted() || chunk.size() > 0) {
-			return OperatorResultType::HAVE_MORE_OUTPUT;
+	if (sink.external && !state.initialized) {
+		// some initialization for external hash join
+		if (!sink.probe_spill) {
+			sink.InitializeProbeSpill();
 		}
-		state.scan_structure = nullptr;
-		return OperatorResultType::NEED_MORE_INPUT;
+		state.spill_state = sink.probe_spill->RegisterThread();
+		state.initialized = true;
 	}
 
-	// probe the HT
-	if (sink.hash_table->Count() == 0) {
-		ConstructEmptyJoinResult(sink.hash_table->join_type, sink.hash_table->has_null, input, chunk);
-		return OperatorResultType::NEED_MORE_INPUT;
-	}
+	if (state.scan_structure.is_null) {
+		// probe the HT, start by resolving the join keys for the left chunk
+		state.join_keys.Reset();
+		state.probe_executor.Execute(input, state.join_keys);
 
-	// resolve the join keys for the left chunk
-	state.join_keys.Reset();
-	state.probe_executor.Execute(input, state.join_keys);
+		// perform the actual probe
+		if (sink.external) {
+			sink.hash_table->ProbeAndSpill(state.scan_structure, state.join_keys, state.join_key_state,
+			                               state.probe_state, input, *sink.probe_spill, state.spill_state,
+			                               state.spill_chunk);
+		} else {
+			sink.hash_table->Probe(state.scan_structure, state.join_keys, state.join_key_state, state.probe_state);
+		}
+	}
+	state.scan_structure.Next(state.join_keys, input, chunk);
 
-	// perform the actual probe
-	if (sink.external) {
-		state.scan_structure = sink.hash_table->ProbeAndSpill(state.join_keys, state.join_key_state, input,
-		                                                      *sink.probe_spill, state.spill_state, state.spill_chunk);
-	} else {
-		state.scan_structure = sink.hash_table->Probe(state.join_keys, state.join_key_state);
+	if (state.scan_structure.PointersExhausted() && chunk.size() == 0) {
+		state.scan_structure.is_null = true;
+		return OperatorResultType::NEED_MORE_INPUT;
 	}
-	state.scan_structure->Next(state.join_keys, input, chunk);
 	return OperatorResultType::HAVE_MORE_OUTPUT;
 }
 
@@ -628,7 +777,7 @@ class HashJoinLocalSourceState;
 
 class HashJoinGlobalSourceState : public GlobalSourceState {
 public:
-	HashJoinGlobalSourceState(const PhysicalHashJoin &op, ClientContext &context);
+	HashJoinGlobalSourceState(const PhysicalHashJoin &op, const ClientContext &context);
 
 	//! Initialize this source state using the info in the sink
 	void Initialize(HashJoinGlobalSinkState &sink);
@@ -661,13 +810,12 @@ public:
 
 	//! For synchronizing the external hash join
 	atomic<HashJoinSourceStage> global_stage;
-	mutex lock;
 
 	//! For HT build synchronization
-	idx_t build_chunk_idx;
+	idx_t build_chunk_idx = DConstants::INVALID_INDEX;
 	idx_t build_chunk_count;
 	idx_t build_chunk_done;
-	idx_t build_chunks_per_thread;
+	idx_t build_chunks_per_thread = DConstants::INVALID_INDEX;
 
 	//! For probe synchronization
 	atomic<idx_t> probe_chunk_count;
@@ -678,22 +826,22 @@ public:
 	idx_t parallel_scan_chunk_count;
 
 	//! For full/outer synchronization
-	idx_t full_outer_chunk_idx;
+	idx_t full_outer_chunk_idx = DConstants::INVALID_INDEX;
 	atomic<idx_t> full_outer_chunk_count;
 	atomic<idx_t> full_outer_chunk_done;
-	idx_t full_outer_chunks_per_thread;
+	idx_t full_outer_chunks_per_thread = DConstants::INVALID_INDEX;
 
 	vector<InterruptState> blocked_tasks;
 };
 
 class HashJoinLocalSourceState : public LocalSourceState {
 public:
-	HashJoinLocalSourceState(const PhysicalHashJoin &op, Allocator &allocator);
+	HashJoinLocalSourceState(const PhysicalHashJoin &op, const HashJoinGlobalSinkState &sink, Allocator &allocator);
 
 	//! Do the work this thread has been assigned
 	void ExecuteTask(HashJoinGlobalSinkState &sink, HashJoinGlobalSourceState &gstate, DataChunk &chunk);
 	//! Whether this thread has finished the work it has been assigned
-	bool TaskFinished();
+	bool TaskFinished() const;
 	//! Build, probe and scan for external hash join
 	void ExternalBuild(HashJoinGlobalSinkState &sink, HashJoinGlobalSourceState &gstate);
 	void ExternalProbe(HashJoinGlobalSinkState &sink, HashJoinGlobalSourceState &gstate, DataChunk &chunk);
@@ -706,8 +854,8 @@ public:
 	Vector addresses;
 
 	//! Chunks assigned to this thread for building the pointer table
-	idx_t build_chunk_idx_from;
-	idx_t build_chunk_idx_to;
+	idx_t build_chunk_idx_from = DConstants::INVALID_INDEX;
+	idx_t build_chunk_idx_to = DConstants::INVALID_INDEX;
 
 	//! Local scan state for probe spill
 	ColumnDataConsumerScanState probe_local_scan;
@@ -716,16 +864,18 @@ public:
 	DataChunk join_keys;
 	DataChunk payload;
 	TupleDataChunkState join_key_state;
+
 	//! Column indices to easily reference the join keys/payload columns in probe_chunk
 	vector<idx_t> join_key_indices;
 	vector<idx_t> payload_indices;
 	//! Scan structure for the external probe
-	unique_ptr<JoinHashTable::ScanStructure> scan_structure;
-	bool empty_ht_probe_in_progress;
+	JoinHashTable::ScanStructure scan_structure;
+	JoinHashTable::ProbeState probe_state;
+	bool empty_ht_probe_in_progress = false;
 
 	//! Chunks assigned to this thread for a full/outer scan
-	idx_t full_outer_chunk_idx_from;
-	idx_t full_outer_chunk_idx_to;
+	idx_t full_outer_chunk_idx_from = DConstants::INVALID_INDEX;
+	idx_t full_outer_chunk_idx_to = DConstants::INVALID_INDEX;
 	unique_ptr<JoinHTScanState> full_outer_scan_state;
 };
 
@@ -735,17 +885,18 @@ unique_ptr<GlobalSourceState> PhysicalHashJoin::GetGlobalSourceState(ClientConte
 
 unique_ptr<LocalSourceState> PhysicalHashJoin::GetLocalSourceState(ExecutionContext &context,
                                                                    GlobalSourceState &gstate) const {
-	return make_uniq<HashJoinLocalSourceState>(*this, BufferAllocator::Get(context.client));
+	return make_uniq<HashJoinLocalSourceState>(*this, sink_state->Cast<HashJoinGlobalSinkState>(),
+	                                           BufferAllocator::Get(context.client));
 }
 
-HashJoinGlobalSourceState::HashJoinGlobalSourceState(const PhysicalHashJoin &op, ClientContext &context)
+HashJoinGlobalSourceState::HashJoinGlobalSourceState(const PhysicalHashJoin &op, const ClientContext &context)
     : op(op), global_stage(HashJoinSourceStage::INIT), build_chunk_count(0), build_chunk_done(0), probe_chunk_count(0),
       probe_chunk_done(0), probe_count(op.children[0]->estimated_cardinality),
       parallel_scan_chunk_count(context.config.verify_parallelism ? 1 : 120) {
 }
 
 void HashJoinGlobalSourceState::Initialize(HashJoinGlobalSinkState &sink) {
-	lock_guard<mutex> init_lock(lock);
+	auto guard = Lock();
 	if (global_stage != HashJoinSourceStage::INIT) {
 		// Another thread initialized
 		return;
@@ -797,12 +948,12 @@ void HashJoinGlobalSourceState::PrepareBuild(HashJoinGlobalSinkState &sink) {
 	auto &ht = *sink.hash_table;
 
 	// Update remaining size
-	sink.temporary_memory_state->SetRemainingSize(sink.context, ht.GetRemainingSize());
+	sink.temporary_memory_state->SetRemainingSizeAndUpdateReservation(sink.context, ht.GetRemainingSize());
 
 	// Try to put the next partitions in the block collection of the HT
 	if (!sink.external || !ht.PrepareExternalFinalize(sink.temporary_memory_state->GetReservation())) {
 		global_stage = HashJoinSourceStage::DONE;
-		sink.temporary_memory_state->SetRemainingSize(sink.context, 0);
+		sink.temporary_memory_state->SetZero();
 		return;
 	}
 
@@ -816,8 +967,7 @@ void HashJoinGlobalSourceState::PrepareBuild(HashJoinGlobalSinkState &sink) {
 	build_chunk_count = data_collection.ChunkCount();
 	build_chunk_done = 0;
 
-	auto num_threads = NumericCast<idx_t>(TaskScheduler::GetScheduler(sink.context).NumberOfThreads());
-	build_chunks_per_thread = MaxValue<idx_t>((build_chunk_count + num_threads - 1) / num_threads, 1);
+	build_chunks_per_thread = MaxValue<idx_t>((build_chunk_count + sink.num_threads - 1) / sink.num_threads, 1);
 
 	ht.InitializePointerTable();
 
@@ -847,8 +997,8 @@ void HashJoinGlobalSourceState::PrepareScanHT(HashJoinGlobalSinkState &sink) {
 	full_outer_chunk_count = data_collection.ChunkCount();
 	full_outer_chunk_done = 0;
 
-	auto num_threads = NumericCast<idx_t>(TaskScheduler::GetScheduler(sink.context).NumberOfThreads());
-	full_outer_chunks_per_thread = MaxValue<idx_t>((full_outer_chunk_count + num_threads - 1) / num_threads, 1);
+	full_outer_chunks_per_thread =
+	    MaxValue<idx_t>((full_outer_chunk_count + sink.num_threads - 1) / sink.num_threads, 1);
 
 	global_stage = HashJoinSourceStage::SCAN_HT;
 }
@@ -856,7 +1006,7 @@ void HashJoinGlobalSourceState::PrepareScanHT(HashJoinGlobalSinkState &sink) {
 bool HashJoinGlobalSourceState::AssignTask(HashJoinGlobalSinkState &sink, HashJoinLocalSourceState &lstate) {
 	D_ASSERT(lstate.TaskFinished());
 
-	lock_guard<mutex> guard(lock);
+	auto guard = Lock();
 	switch (global_stage.load()) {
 	case HashJoinSourceStage::BUILD:
 		if (build_chunk_idx != build_chunk_count) {
@@ -892,12 +1042,13 @@ bool HashJoinGlobalSourceState::AssignTask(HashJoinGlobalSinkState &sink, HashJo
 	return false;
 }
 
-HashJoinLocalSourceState::HashJoinLocalSourceState(const PhysicalHashJoin &op, Allocator &allocator)
-    : local_stage(HashJoinSourceStage::INIT), addresses(LogicalType::POINTER) {
+HashJoinLocalSourceState::HashJoinLocalSourceState(const PhysicalHashJoin &op, const HashJoinGlobalSinkState &sink,
+                                                   Allocator &allocator)
+    : local_stage(HashJoinSourceStage::INIT), addresses(LogicalType::POINTER),
+      scan_structure(*sink.hash_table, join_key_state) {
 	auto &chunk_state = probe_local_scan.current_chunk_state;
 	chunk_state.properties = ColumnDataScanProperties::ALLOW_ZERO_COPY;
 
-	auto &sink = op.sink_state->Cast<HashJoinGlobalSinkState>();
 	probe_chunk.Initialize(allocator, sink.probe_types);
 	join_keys.Initialize(allocator, op.condition_types);
 	payload.Initialize(allocator, op.children[0]->types);
@@ -930,13 +1081,13 @@ void HashJoinLocalSourceState::ExecuteTask(HashJoinGlobalSinkState &sink, HashJo
 	}
 }
 
-bool HashJoinLocalSourceState::TaskFinished() {
+bool HashJoinLocalSourceState::TaskFinished() const {
 	switch (local_stage) {
 	case HashJoinSourceStage::INIT:
 	case HashJoinSourceStage::BUILD:
 		return true;
 	case HashJoinSourceStage::PROBE:
-		return scan_structure == nullptr && !empty_ht_probe_in_progress;
+		return scan_structure.is_null && !empty_ht_probe_in_progress;
 	case HashJoinSourceStage::SCAN_HT:
 		return full_outer_scan_state == nullptr;
 	default:
@@ -950,7 +1101,7 @@ void HashJoinLocalSourceState::ExternalBuild(HashJoinGlobalSinkState &sink, Hash
 	auto &ht = *sink.hash_table;
 	ht.Finalize(build_chunk_idx_from, build_chunk_idx_to, true);
 
-	lock_guard<mutex> guard(gstate.lock);
+	auto guard = gstate.Lock();
 	gstate.build_chunk_done += build_chunk_idx_to - build_chunk_idx_from;
 }
 
@@ -958,20 +1109,20 @@ void HashJoinLocalSourceState::ExternalProbe(HashJoinGlobalSinkState &sink, Hash
                                              DataChunk &chunk) {
 	D_ASSERT(local_stage == HashJoinSourceStage::PROBE && sink.hash_table->finalized);
 
-	if (scan_structure) {
+	if (!scan_structure.is_null) {
 		// Still have elements remaining (i.e. we got >STANDARD_VECTOR_SIZE elements in the previous probe)
-		scan_structure->Next(join_keys, payload, chunk);
-		if (chunk.size() != 0 || !scan_structure->PointersExhausted()) {
+		scan_structure.Next(join_keys, payload, chunk);
+		if (chunk.size() != 0 || !scan_structure.PointersExhausted()) {
 			return;
 		}
 	}
 
-	if (scan_structure || empty_ht_probe_in_progress) {
+	if (!scan_structure.is_null || empty_ht_probe_in_progress) {
 		// Previous probe is done
-		scan_structure = nullptr;
+		scan_structure.is_null = true;
 		empty_ht_probe_in_progress = false;
 		sink.probe_spill->consumer->FinishChunk(probe_local_scan);
-		lock_guard<mutex> lock(gstate.lock);
+		auto guard = gstate.Lock();
 		gstate.probe_chunk_done++;
 		return;
 	}
@@ -991,8 +1142,8 @@ void HashJoinLocalSourceState::ExternalProbe(HashJoinGlobalSinkState &sink, Hash
 	}
 
 	// Perform the probe
-	scan_structure = sink.hash_table->Probe(join_keys, join_key_state, precomputed_hashes);
-	scan_structure->Next(join_keys, payload, chunk);
+	sink.hash_table->Probe(scan_structure, join_keys, join_key_state, probe_state, precomputed_hashes);
+	scan_structure.Next(join_keys, payload, chunk);
 }
 
 void HashJoinLocalSourceState::ExternalScanHT(HashJoinGlobalSinkState &sink, HashJoinGlobalSourceState &gstate,
@@ -1007,7 +1158,7 @@ void HashJoinLocalSourceState::ExternalScanHT(HashJoinGlobalSinkState &sink, Has
 
 	if (chunk.size() == 0) {
 		full_outer_scan_state = nullptr;
-		lock_guard<mutex> guard(gstate.lock);
+		auto guard = gstate.Lock();
 		gstate.full_outer_chunk_done += full_outer_chunk_idx_to - full_outer_chunk_idx_from;
 	}
 }
@@ -1020,10 +1171,11 @@ SourceResultType PhysicalHashJoin::GetData(ExecutionContext &context, DataChunk
 	sink.scanned_data = true;
 
 	if (!sink.external && !PropagatesBuildSide(join_type)) {
-		lock_guard<mutex> guard(gstate.lock);
+		auto guard = gstate.Lock();
 		if (gstate.global_stage != HashJoinSourceStage::DONE) {
 			gstate.global_stage = HashJoinSourceStage::DONE;
-			sink.temporary_memory_state->SetRemainingSize(context.client, 0);
+			sink.hash_table->Reset();
+			sink.temporary_memory_state->SetZero();
 		}
 		return SourceResultType::FINISHED;
 	}
@@ -1038,15 +1190,11 @@ SourceResultType PhysicalHashJoin::GetData(ExecutionContext &context, DataChunk
 		if (!lstate.TaskFinished() || gstate.AssignTask(sink, lstate)) {
 			lstate.ExecuteTask(sink, gstate, chunk);
 		} else {
-			lock_guard<mutex> guard(gstate.lock);
+			auto guard = gstate.Lock();
 			if (gstate.TryPrepareNextStage(sink) || gstate.global_stage == HashJoinSourceStage::DONE) {
-				for (auto &state : gstate.blocked_tasks) {
-					state.Callback();
-				}
-				gstate.blocked_tasks.clear();
+				gstate.UnblockTasks(guard);
 			} else {
-				gstate.blocked_tasks.push_back(input.interrupt_state);
-				return SourceResultType::BLOCKED;
+				return gstate.BlockSource(guard, input.interrupt_state);
 			}
 		}
 	}
@@ -1060,23 +1208,24 @@ double PhysicalHashJoin::GetProgress(ClientContext &context, GlobalSourceState &
 
 	if (!sink.external) {
 		if (PropagatesBuildSide(join_type)) {
-			return double(gstate.full_outer_chunk_done) / double(gstate.full_outer_chunk_count) * 100.0;
+			return static_cast<double>(gstate.full_outer_chunk_done) /
+			       static_cast<double>(gstate.full_outer_chunk_count) * 100.0;
 		}
 		return 100.0;
 	}
 
-	double num_partitions = RadixPartitioning::NumberOfPartitions(sink.hash_table->GetRadixBits());
-	double partition_start = sink.hash_table->GetPartitionStart();
-	double partition_end = sink.hash_table->GetPartitionEnd();
+	auto num_partitions = static_cast<double>(RadixPartitioning::NumberOfPartitions(sink.hash_table->GetRadixBits()));
+	auto partition_start = static_cast<double>(sink.hash_table->GetPartitionStart());
+	auto partition_end = static_cast<double>(sink.hash_table->GetPartitionEnd());
 
 	// This many partitions are fully done
-	auto progress = partition_start / double(num_partitions);
+	auto progress = partition_start / num_partitions;
 
-	double probe_chunk_done = gstate.probe_chunk_done;
-	double probe_chunk_count = gstate.probe_chunk_count;
+	auto probe_chunk_done = static_cast<double>(gstate.probe_chunk_done);
+	auto probe_chunk_count = static_cast<double>(gstate.probe_chunk_count);
 	if (probe_chunk_count != 0) {
 		// Progress of the current round of probing, weighed by the number of partitions
-		auto probe_progress = double(probe_chunk_done) / double(probe_chunk_count);
+		auto probe_progress = probe_chunk_done / probe_chunk_count;
 		// Add it to the progress, weighed by the number of partitions in the current round
 		progress += (partition_end - partition_start) / num_partitions * probe_progress;
 	}
@@ -1084,20 +1233,28 @@ double PhysicalHashJoin::GetProgress(ClientContext &context, GlobalSourceState &
 	return progress * 100.0;
 }
 
-string PhysicalHashJoin::ParamsToString() const {
-	string result = EnumUtil::ToString(join_type) + "\n";
-	for (auto &it : conditions) {
-		string op = ExpressionTypeToOperator(it.comparison);
-		result += it.left->GetName() + " " + op + " " + it.right->GetName() + "\n";
+InsertionOrderPreservingMap<string> PhysicalHashJoin::ParamsToString() const {
+	InsertionOrderPreservingMap<string> result;
+	result["Join Type"] = EnumUtil::ToString(join_type);
+
+	string condition_info;
+	for (idx_t i = 0; i < conditions.size(); i++) {
+		auto &join_condition = conditions[i];
+		if (i > 0) {
+			condition_info += "\n";
+		}
+		condition_info +=
+		    StringUtil::Format("%s %s %s", join_condition.left->GetName(),
+		                       ExpressionTypeToOperator(join_condition.comparison), join_condition.right->GetName());
 	}
-	result += "\n[INFOSEPARATOR]\n";
+	result["Conditions"] = condition_info;
+
 	if (perfect_join_statistics.is_build_small) {
 		// perfect hash join
-		result += "Build Min: " + perfect_join_statistics.build_min.ToString() + "\n";
-		result += "Build Max: " + perfect_join_statistics.build_max.ToString() + "\n";
-		result += "\n[INFOSEPARATOR]\n";
+		result["Build Min"] = perfect_join_statistics.build_min.ToString();
+		result["Build Max"] = perfect_join_statistics.build_max.ToString();
 	}
-	result += StringUtil::Format("EC: %llu\n", estimated_cardinality);
+	SetEstimatedCardinality(result, estimated_cardinality);
 	return result;
 }