duckdb 0.9.3-dev2.0 → 0.10.0

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

@@ -7,35 +7,70 @@
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/query_profiler.hpp"
 #include "duckdb/parallel/base_pipeline_event.hpp"
+#include "duckdb/parallel/interrupt.hpp"
 #include "duckdb/parallel/pipeline.hpp"
 #include "duckdb/parallel/thread_context.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
 #include "duckdb/storage/storage_manager.hpp"
+#include "duckdb/storage/temporary_memory_manager.hpp"
 
 namespace duckdb {
 
 PhysicalHashJoin::PhysicalHashJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left,
                                    unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond, JoinType join_type,
-                                   const vector<idx_t> &left_projection_map,
-                                   const vector<idx_t> &right_projection_map_p, vector<LogicalType> delim_types,
-                                   idx_t estimated_cardinality, PerfectHashJoinStats perfect_join_stats)
+                                   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)
     : PhysicalComparisonJoin(op, PhysicalOperatorType::HASH_JOIN, std::move(cond), join_type, estimated_cardinality),
-      right_projection_map(right_projection_map_p), delim_types(std::move(delim_types)),
-      perfect_join_statistics(std::move(perfect_join_stats)) {
+      delim_types(std::move(delim_types)), perfect_join_statistics(std::move(perfect_join_stats)) {
+	D_ASSERT(left_projection_map.empty());
 
 	children.push_back(std::move(left));
 	children.push_back(std::move(right));
 
-	D_ASSERT(left_projection_map.empty());
-	for (auto &condition : conditions) {
+	// Collect condition types, and which conditions are just references (so we won't duplicate them in the payload)
+	unordered_map<idx_t, idx_t> build_columns_in_conditions;
+	for (idx_t cond_idx = 0; cond_idx < conditions.size(); cond_idx++) {
+		auto &condition = conditions[cond_idx];
 		condition_types.push_back(condition.left->return_type);
+		if (condition.right->GetExpressionClass() == ExpressionClass::BOUND_REF) {
+			build_columns_in_conditions.emplace(condition.right->Cast<BoundReferenceExpression>().index, cond_idx);
+		}
+	}
+
+	// For ANTI, SEMI and MARK join, we only need to store the keys, so for these the payload/RHS types are empty
+	if (join_type == JoinType::ANTI || join_type == JoinType::SEMI || join_type == JoinType::MARK) {
+		return;
 	}
 
-	// for ANTI, SEMI and MARK join, we only need to store the keys, so for these the build types are empty
-	if (join_type != JoinType::ANTI && join_type != JoinType::SEMI && join_type != JoinType::MARK) {
-		build_types = LogicalOperator::MapTypes(children[1]->GetTypes(), right_projection_map);
+	auto &rhs_input_types = children[1]->GetTypes();
+
+	// Create a projection map for the RHS (if it was empty), for convenience
+	auto right_projection_map_copy = right_projection_map;
+	if (right_projection_map_copy.empty()) {
+		right_projection_map_copy.reserve(rhs_input_types.size());
+		for (idx_t i = 0; i < rhs_input_types.size(); i++) {
+			right_projection_map_copy.emplace_back(i);
+		}
+	}
+
+	// Now fill payload expressions/types and RHS columns/types
+	for (auto &rhs_col : right_projection_map_copy) {
+		auto &rhs_col_type = rhs_input_types[rhs_col];
+
+		auto it = build_columns_in_conditions.find(rhs_col);
+		if (it == build_columns_in_conditions.end()) {
+			// This rhs column is not a join key
+			payload_column_idxs.push_back(rhs_col);
+			payload_types.push_back(rhs_col_type);
+			rhs_output_columns.push_back(condition_types.size() + payload_types.size() - 1);
+		} else {
+			// This rhs column is a join key
+			rhs_output_columns.push_back(it->second);
+		}
+		rhs_output_types.push_back(rhs_col_type);
 	}
 }
 
@@ -52,7 +87,10 @@ PhysicalHashJoin::PhysicalHashJoin(LogicalOperator &op, unique_ptr<PhysicalOpera
 class HashJoinGlobalSinkState : public GlobalSinkState {
 public:
 	HashJoinGlobalSinkState(const PhysicalHashJoin &op, ClientContext &context_p)
-	    : context(context_p), finalized(false), scanned_data(false) {
+	    : context(context_p), num_threads(TaskScheduler::GetScheduler(context).NumberOfThreads()),
+	      temporary_memory_update_count(0),
+	      temporary_memory_state(TemporaryMemoryManager::Get(context).Register(context)), finalized(false),
+	      scanned_data(false) {
 		hash_table = op.InitializeHashTable(context);
 
 		// for perfect hash join
@@ -71,6 +109,12 @@ public:
 
 public:
 	ClientContext &context;
+
+	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;
+
 	//! Global HT used by the join
 	unique_ptr<JoinHashTable> hash_table;
 	//! The perfect hash join executor (if any)
@@ -95,36 +139,42 @@ public:
 
 class HashJoinLocalSinkState : public LocalSinkState {
 public:
-	HashJoinLocalSinkState(const PhysicalHashJoin &op, ClientContext &context) : build_executor(context) {
+	HashJoinLocalSinkState(const PhysicalHashJoin &op, ClientContext &context)
+	    : join_key_executor(context), chunk_count(0) {
 		auto &allocator = BufferAllocator::Get(context);
-		if (!op.right_projection_map.empty()) {
-			build_chunk.Initialize(allocator, op.build_types);
-		}
+
 		for (auto &cond : op.conditions) {
-			build_executor.AddExpression(*cond.right);
+			join_key_executor.AddExpression(*cond.right);
 		}
 		join_keys.Initialize(allocator, op.condition_types);
 
-		hash_table = op.InitializeHashTable(context);
+		if (!op.payload_types.empty()) {
+			payload_chunk.Initialize(allocator, op.payload_types);
+		}
 
+		hash_table = op.InitializeHashTable(context);
 		hash_table->GetSinkCollection().InitializeAppendState(append_state);
 	}
 
 public:
 	PartitionedTupleDataAppendState append_state;
 
-	DataChunk build_chunk;
+	ExpressionExecutor join_key_executor;
 	DataChunk join_keys;
-	ExpressionExecutor build_executor;
+
+	DataChunk payload_chunk;
 
 	//! 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<JoinHashTable> PhysicalHashJoin::InitializeHashTable(ClientContext &context) const {
-	auto result =
-	    make_uniq<JoinHashTable>(BufferManager::GetBufferManager(context), conditions, build_types, join_type);
-	result->max_ht_size = double(0.6) * BufferManager::GetBufferManager(context).GetMaxMemory();
+	auto result = make_uniq<JoinHashTable>(BufferManager::GetBufferManager(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()) {
@@ -138,7 +188,7 @@ unique_ptr<JoinHashTable> PhysicalHashJoin::InitializeHashTable(ClientContext &c
 			// - (2) the group containing a NULL value [in which case FALSE becomes NULL]
 			auto &info = result->correlated_mark_join_info;
 
-			vector<LogicalType> payload_types;
+			vector<LogicalType> delim_payload_types;
 			vector<BoundAggregateExpression *> correlated_aggregates;
 			unique_ptr<BoundAggregateExpression> aggr;
 
@@ -149,7 +199,7 @@ unique_ptr<JoinHashTable> PhysicalHashJoin::InitializeHashTable(ClientContext &c
 			aggr = function_binder.BindAggregateFunction(CountStarFun::GetFunction(), {}, nullptr,
 			                                             AggregateType::NON_DISTINCT);
 			correlated_aggregates.push_back(&*aggr);
-			payload_types.push_back(aggr->return_type);
+			delim_payload_types.push_back(aggr->return_type);
 			info.correlated_aggregates.push_back(std::move(aggr));
 
 			auto count_fun = CountFun::GetFunction();
@@ -159,15 +209,15 @@ unique_ptr<JoinHashTable> PhysicalHashJoin::InitializeHashTable(ClientContext &c
 			aggr = function_binder.BindAggregateFunction(count_fun, std::move(children), nullptr,
 			                                             AggregateType::NON_DISTINCT);
 			correlated_aggregates.push_back(&*aggr);
-			payload_types.push_back(aggr->return_type);
+			delim_payload_types.push_back(aggr->return_type);
 			info.correlated_aggregates.push_back(std::move(aggr));
 
 			auto &allocator = BufferAllocator::Get(context);
 			info.correlated_counts = make_uniq<GroupedAggregateHashTable>(context, allocator, delim_types,
-			                                                              payload_types, correlated_aggregates);
+			                                                              delim_payload_types, correlated_aggregates);
 			info.correlated_types = delim_types;
 			info.group_chunk.Initialize(allocator, delim_types);
-			info.result_chunk.Initialize(allocator, payload_types);
+			info.result_chunk.Initialize(allocator, delim_payload_types);
 		}
 	}
 	return result;
@@ -186,25 +236,31 @@ SinkResultType PhysicalHashJoin::Sink(ExecutionContext &context, DataChunk &chun
 
 	// resolve the join keys for the right chunk
 	lstate.join_keys.Reset();
-	lstate.build_executor.Execute(chunk, lstate.join_keys);
+	lstate.join_key_executor.Execute(chunk, lstate.join_keys);
 
 	// build the HT
 	auto &ht = *lstate.hash_table;
-	if (!right_projection_map.empty()) {
-		// there is a projection map: fill the build chunk with the projected columns
-		lstate.build_chunk.Reset();
-		lstate.build_chunk.SetCardinality(chunk);
-		for (idx_t i = 0; i < right_projection_map.size(); i++) {
-			lstate.build_chunk.data[i].Reference(chunk.data[right_projection_map[i]]);
-		}
-		ht.Build(lstate.append_state, lstate.join_keys, lstate.build_chunk);
-	} else if (!build_types.empty()) {
-		// there is not a projected map: place the entire right chunk in the HT
-		ht.Build(lstate.append_state, lstate.join_keys, chunk);
-	} else {
+	if (payload_types.empty()) {
 		// there are only keys: place an empty chunk in the payload
-		lstate.build_chunk.SetCardinality(chunk.size());
-		ht.Build(lstate.append_state, lstate.join_keys, lstate.build_chunk);
+		lstate.payload_chunk.SetCardinality(chunk.size());
+		ht.Build(lstate.append_state, lstate.join_keys, lstate.payload_chunk);
+	} else {
+		// there are payload columns
+		lstate.payload_chunk.Reset();
+		lstate.payload_chunk.SetCardinality(chunk);
+		for (idx_t i = 0; i < payload_column_idxs.size(); i++) {
+			lstate.payload_chunk.data[i].Reference(chunk.data[payload_column_idxs[i]]);
+		}
+		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;
@@ -219,7 +275,7 @@ SinkCombineResultType PhysicalHashJoin::Combine(ExecutionContext &context, Opera
 		gstate.local_hash_tables.push_back(std::move(lstate.hash_table));
 	}
 	auto &client_profiler = QueryProfiler::Get(context.client);
-	context.thread.profiler.Flush(*this, lstate.build_executor, "build_executor", 1);
+	context.thread.profiler.Flush(*this, lstate.join_key_executor, "join_key_executor", 1);
 	client_profiler.Flush(context.thread.profiler);
 
 	return SinkCombineResultType::FINISHED;
@@ -322,7 +378,7 @@ public:
 	}
 
 	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
-		local_ht.Partition(global_ht);
+		local_ht.Repartition(global_ht);
 		event->FinishTask();
 		return TaskExecutionResult::TASK_FINISHED;
 	}
@@ -334,10 +390,10 @@ private:
 	JoinHashTable &local_ht;
 };
 
-class HashJoinPartitionEvent : public BasePipelineEvent {
+class HashJoinRepartitionEvent : public BasePipelineEvent {
 public:
-	HashJoinPartitionEvent(Pipeline &pipeline_p, HashJoinGlobalSinkState &sink,
-	                       vector<unique_ptr<JoinHashTable>> &local_hts)
+	HashJoinRepartitionEvent(Pipeline &pipeline_p, HashJoinGlobalSinkState &sink,
+	                         vector<unique_ptr<JoinHashTable>> &local_hts)
 	    : BasePipelineEvent(pipeline_p), sink(sink), local_hts(local_hts) {
 	}
 
@@ -346,7 +402,35 @@ public:
 
 public:
 	void Schedule() override {
+		D_ASSERT(sink.hash_table->GetRadixBits() > JoinHashTable::INITIAL_RADIX_BITS);
+
+		idx_t total_size = 0;
+		idx_t total_count = 0;
+		for (auto &local_ht : local_hts) {
+			auto &sink_collection = local_ht->GetSinkCollection();
+			total_size += sink_collection.SizeInBytes();
+			total_count += sink_collection.Count();
+		}
+		auto total_blocks = (double(total_size) + Storage::BLOCK_SIZE - 1) / Storage::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 repartition_threads = MaxValue<idx_t>(sink.temporary_memory_state->GetReservation() / thread_memory, 1);
+
+		if (repartition_threads < local_hts.size()) {
+			// Limit the number of threads working on repartitioning based on our memory reservation
+			for (idx_t thread_idx = repartition_threads; thread_idx < local_hts.size(); thread_idx++) {
+				local_hts[thread_idx % repartition_threads]->Merge(*local_hts[thread_idx]);
+			}
+			local_hts.resize(repartition_threads);
+		}
+
 		auto &context = pipeline->GetClientContext();
+
 		vector<shared_ptr<Task>> partition_tasks;
 		partition_tasks.reserve(local_hts.size());
 		for (auto &local_ht : local_hts) {
@@ -358,7 +442,17 @@ public:
 
 	void FinishEvent() override {
 		local_hts.clear();
-		sink.hash_table->PrepareExternalFinalize();
+
+		// Minimum reservation is now the new smallest partition size
+		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.hash_table->PrepareExternalFinalize(sink.temporary_memory_state->GetReservation());
 		sink.ScheduleFinalize(*pipeline, *this);
 	}
 };
@@ -368,23 +462,36 @@ SinkFinalizeType PhysicalHashJoin::Finalize(Pipeline &pipeline, Event &event, Cl
 	auto &sink = input.global_state.Cast<HashJoinGlobalSinkState>();
 	auto &ht = *sink.hash_table;
 
-	sink.external = ht.RequiresExternalJoin(context.config, sink.local_hash_tables);
+	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;
 	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();
-		if (ht.RequiresPartitioning(context.config, sink.local_hash_tables)) {
-			auto new_event = make_shared<HashJoinPartitionEvent>(pipeline, sink, sink.local_hash_tables);
+		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<HashJoinRepartitionEvent>(pipeline, sink, sink.local_hash_tables);
 			event.InsertEvent(std::move(new_event));
 		} else {
+			// No repartitioning!
+			sink.temporary_memory_state->SetMinimumReservation(max_partition_ht_size);
 			for (auto &local_ht : sink.local_hash_tables) {
 				ht.Merge(*local_ht);
 			}
 			sink.local_hash_tables.clear();
-			sink.hash_table->PrepareExternalFinalize();
+			sink.hash_table->PrepareExternalFinalize(sink.temporary_memory_state->GetReservation());
 			sink.ScheduleFinalize(pipeline, event);
 		}
 		sink.finalized = true;
 		return SinkFinalizeType::READY;
 	} else {
+		// In-memory Hash Join
 		for (auto &local_ht : sink.local_hash_tables) {
 			ht.Merge(*local_ht);
 		}
@@ -486,7 +593,7 @@ OperatorResultType PhysicalHashJoin::ExecuteInternal(ExecutionContext &context,
 	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 (chunk.size() > 0) {
+		if (!state.scan_structure->PointersExhausted() || chunk.size() > 0) {
 			return OperatorResultType::HAVE_MORE_OUTPUT;
 		}
 		state.scan_structure = nullptr;
@@ -528,7 +635,7 @@ public:
 	//! Initialize this source state using the info in the sink
 	void Initialize(HashJoinGlobalSinkState &sink);
 	//! Try to prepare the next stage
-	void TryPrepareNextStage(HashJoinGlobalSinkState &sink);
+	bool TryPrepareNextStage(HashJoinGlobalSinkState &sink);
 	//! Prepare the next build/probe/scan_ht stage for external hash join (must hold lock)
 	void PrepareBuild(HashJoinGlobalSinkState &sink);
 	void PrepareProbe(HashJoinGlobalSinkState &sink);
@@ -543,7 +650,7 @@ public:
 		idx_t count;
 		if (gstate.probe_spill) {
 			count = probe_count;
-		} else if (IsRightOuterJoin(op.join_type)) {
+		} else if (PropagatesBuildSide(op.join_type)) {
 			count = gstate.hash_table->Count();
 		} else {
 			return 0;
@@ -577,6 +684,8 @@ public:
 	idx_t full_outer_chunk_count;
 	idx_t full_outer_chunk_done;
 	idx_t full_outer_chunks_per_thread;
+
+	vector<InterruptState> blocked_tasks;
 };
 
 class HashJoinLocalSourceState : public LocalSourceState {
@@ -653,41 +762,49 @@ void HashJoinGlobalSourceState::Initialize(HashJoinGlobalSinkState &sink) {
 	TryPrepareNextStage(sink);
 }
 
-void HashJoinGlobalSourceState::TryPrepareNextStage(HashJoinGlobalSinkState &sink) {
+bool HashJoinGlobalSourceState::TryPrepareNextStage(HashJoinGlobalSinkState &sink) {
 	switch (global_stage.load()) {
 	case HashJoinSourceStage::BUILD:
 		if (build_chunk_done == build_chunk_count) {
 			sink.hash_table->GetDataCollection().VerifyEverythingPinned();
 			sink.hash_table->finalized = true;
 			PrepareProbe(sink);
+			return true;
 		}
 		break;
 	case HashJoinSourceStage::PROBE:
 		if (probe_chunk_done == probe_chunk_count) {
-			if (IsRightOuterJoin(op.join_type)) {
+			if (PropagatesBuildSide(op.join_type)) {
 				PrepareScanHT(sink);
 			} else {
 				PrepareBuild(sink);
 			}
+			return true;
 		}
 		break;
 	case HashJoinSourceStage::SCAN_HT:
 		if (full_outer_chunk_done == full_outer_chunk_count) {
 			PrepareBuild(sink);
+			return true;
 		}
 		break;
 	default:
 		break;
 	}
+	return false;
 }
 
 void HashJoinGlobalSourceState::PrepareBuild(HashJoinGlobalSinkState &sink) {
 	D_ASSERT(global_stage != HashJoinSourceStage::BUILD);
 	auto &ht = *sink.hash_table;
 
+	// Update remaining size
+	sink.temporary_memory_state->SetRemainingSize(sink.context, ht.GetRemainingSize());
+
 	// Try to put the next partitions in the block collection of the HT
-	if (!sink.external || !ht.PrepareExternalFinalize()) {
+	if (!sink.external || !ht.PrepareExternalFinalize(sink.temporary_memory_state->GetReservation())) {
 		global_stage = HashJoinSourceStage::DONE;
+		sink.temporary_memory_state->SetRemainingSize(sink.context, 0);
 		return;
 	}
 
@@ -846,7 +963,7 @@ void HashJoinLocalSourceState::ExternalProbe(HashJoinGlobalSinkState &sink, Hash
 	if (scan_structure) {
 		// 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) {
+		if (chunk.size() != 0 || !scan_structure->PointersExhausted()) {
 			return;
 		}
 	}
@@ -904,7 +1021,12 @@ SourceResultType PhysicalHashJoin::GetData(ExecutionContext &context, DataChunk
 	auto &lstate = input.local_state.Cast<HashJoinLocalSourceState>();
 	sink.scanned_data = true;
 
-	if (!sink.external && !IsRightOuterJoin(join_type)) {
+	if (!sink.external && !PropagatesBuildSide(join_type)) {
+		lock_guard<mutex> guard(gstate.lock);
+		if (gstate.global_stage != HashJoinSourceStage::DONE) {
+			gstate.global_stage = HashJoinSourceStage::DONE;
+			sink.temporary_memory_state->SetRemainingSize(context.client, 0);
+		}
 		return SourceResultType::FINISHED;
 	}
 
@@ -919,11 +1041,49 @@ SourceResultType PhysicalHashJoin::GetData(ExecutionContext &context, DataChunk
 			lstate.ExecuteTask(sink, gstate, chunk);
 		} else {
 			lock_guard<mutex> guard(gstate.lock);
-			gstate.TryPrepareNextStage(sink);
+			if (gstate.TryPrepareNextStage(sink) || gstate.global_stage == HashJoinSourceStage::DONE) {
+				for (auto &state : gstate.blocked_tasks) {
+					state.Callback();
+				}
+				gstate.blocked_tasks.clear();
+			} else {
+				gstate.blocked_tasks.push_back(input.interrupt_state);
+				return SourceResultType::BLOCKED;
+			}
 		}
 	}
 
 	return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
 }
 
+double PhysicalHashJoin::GetProgress(ClientContext &context, GlobalSourceState &gstate_p) const {
+	auto &sink = sink_state->Cast<HashJoinGlobalSinkState>();
+	auto &gstate = gstate_p.Cast<HashJoinGlobalSourceState>();
+
+	if (!sink.external) {
+		if (PropagatesBuildSide(join_type)) {
+			return double(gstate.full_outer_chunk_done) / 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();
+
+	// This many partitions are fully done
+	auto progress = partition_start / double(num_partitions);
+
+	double probe_chunk_done = gstate.probe_chunk_done;
+	double probe_chunk_count = 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);
+		// Add it to the progress, weighed by the number of partitions in the current round
+		progress += (partition_end - partition_start) / num_partitions * probe_progress;
+	}
+
+	return progress * 100.0;
+}
+
 } // namespace duckdb

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

@@ -24,8 +24,6 @@ PhysicalIEJoin::PhysicalIEJoin(LogicalComparisonJoin &op, unique_ptr<PhysicalOpe
 
 	// 1. let L1 (resp. L2) be the array of column X (resp. Y)
 	D_ASSERT(conditions.size() >= 2);
-	lhs_orders.resize(2);
-	rhs_orders.resize(2);
 	for (idx_t i = 0; i < 2; ++i) {
 		auto &cond = conditions[i];
 		D_ASSERT(cond.left->return_type == cond.right->return_type);
@@ -52,8 +50,8 @@ PhysicalIEJoin::PhysicalIEJoin(LogicalComparisonJoin &op, unique_ptr<PhysicalOpe
 		default:
 			throw NotImplementedException("Unimplemented join type for IEJoin");
 		}
-		lhs_orders[i].emplace_back(BoundOrderByNode(sense, OrderByNullType::NULLS_LAST, std::move(left)));
-		rhs_orders[i].emplace_back(BoundOrderByNode(sense, OrderByNullType::NULLS_LAST, std::move(right)));
+		lhs_orders.emplace_back(sense, OrderByNullType::NULLS_LAST, std::move(left));
+		rhs_orders.emplace_back(sense, OrderByNullType::NULLS_LAST, std::move(right));
 	}
 
 	for (idx_t i = 2; i < conditions.size(); ++i) {
@@ -88,13 +86,13 @@ public:
 		RowLayout lhs_layout;
 		lhs_layout.Initialize(op.children[0]->types);
 		vector<BoundOrderByNode> lhs_order;
-		lhs_order.emplace_back(op.lhs_orders[0][0].Copy());
+		lhs_order.emplace_back(op.lhs_orders[0].Copy());
 		tables[0] = make_uniq<GlobalSortedTable>(context, lhs_order, lhs_layout);
 
 		RowLayout rhs_layout;
 		rhs_layout.Initialize(op.children[1]->types);
 		vector<BoundOrderByNode> rhs_order;
-		rhs_order.emplace_back(op.rhs_orders[0][0].Copy());
+		rhs_order.emplace_back(op.rhs_orders[0].Copy());
 		tables[1] = make_uniq<GlobalSortedTable>(context, rhs_order, rhs_layout);
 	}
 
@@ -164,7 +162,7 @@ SinkFinalizeType PhysicalIEJoin::Finalize(Pipeline &pipeline, Event &event, Clie
 	auto &table = *gstate.tables[gstate.child];
 	auto &global_sort_state = table.global_sort_state;
 
-	if ((gstate.child == 1 && IsRightOuterJoin(join_type)) || (gstate.child == 0 && IsLeftOuterJoin(join_type))) {
+	if ((gstate.child == 1 && PropagatesBuildSide(join_type)) || (gstate.child == 0 && IsLeftOuterJoin(join_type))) {
 		// for FULL/LEFT/RIGHT OUTER JOIN, initialize found_match to false for every tuple
 		table.IntializeMatches();
 	}
@@ -369,8 +367,8 @@ IEJoinUnion::IEJoinUnion(ClientContext &context, const PhysicalIEJoin &op, Sorte
 	}
 
 	// 1. let L1 (resp. L2) be the array of column X (resp. Y )
-	const auto &order1 = op.lhs_orders[0][0];
-	const auto &order2 = op.lhs_orders[1][0];
+	const auto &order1 = op.lhs_orders[0];
+	const auto &order2 = op.lhs_orders[1];
 
 	// 2. if (op1 ∈ {>, ≥}) sort L1 in descending order
 	// 3. else if (op1 ∈ {<, ≤}) sort L1 in ascending order
@@ -399,8 +397,8 @@ IEJoinUnion::IEJoinUnion(ClientContext &context, const PhysicalIEJoin &op, Sorte
 
 	// RHS has negative rids
 	ExpressionExecutor r_executor(context);
-	r_executor.AddExpression(*op.rhs_orders[0][0].expression);
-	r_executor.AddExpression(*op.rhs_orders[1][0].expression);
+	r_executor.AddExpression(*op.rhs_orders[0].expression);
+	r_executor.AddExpression(*op.rhs_orders[1].expression);
 	AppendKey(t2, r_executor, *l1, -1, -1, b2);
 
 	if (l1->global_sort_state.sorted_blocks.empty()) {
@@ -616,15 +614,14 @@ idx_t IEJoinUnion::JoinComplexBlocks(SelectionVector &lsel, SelectionVector &rse
 			const auto rrid = li[j];
 			++j;
 
+			D_ASSERT(lrid > 0 && rrid < 0);
 			// 15. add tuples w.r.t. (L1[j], L1[i]) to join result
-			if (lrid > 0 && rrid < 0) {
-				lsel.set_index(result_count, sel_t(+lrid - 1));
-				rsel.set_index(result_count, sel_t(-rrid - 1));
-				++result_count;
-				if (result_count == STANDARD_VECTOR_SIZE) {
-					// out of space!
-					return result_count;
-				}
+			lsel.set_index(result_count, sel_t(+lrid - 1));
+			rsel.set_index(result_count, sel_t(-rrid - 1));
+			++result_count;
+			if (result_count == STANDARD_VECTOR_SIZE) {
+				// out of space!
+				return result_count;
 			}
 		}
 		++i;
@@ -1040,8 +1037,8 @@ void PhysicalIEJoin::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeli
 	children[0]->BuildPipelines(*lhs_pipeline, child_meta_pipeline);
 
 	// Build out RHS
-	auto rhs_pipeline = child_meta_pipeline.CreatePipeline();
-	children[1]->BuildPipelines(*rhs_pipeline, child_meta_pipeline);
+	auto &rhs_pipeline = child_meta_pipeline.CreatePipeline();
+	children[1]->BuildPipelines(rhs_pipeline, child_meta_pipeline);
 
 	// Despite having the same sink, RHS and everything created after it need their own (same) PipelineFinishEvent
 	child_meta_pipeline.AddFinishEvent(rhs_pipeline);

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

@@ -17,6 +17,8 @@ bool PhysicalJoin::EmptyResultIfRHSIsEmpty() const {
 	case JoinType::INNER:
 	case JoinType::RIGHT:
 	case JoinType::SEMI:
+	case JoinType::RIGHT_SEMI:
+	case JoinType::RIGHT_ANTI:
 		return true;
 	default:
 		return false;
@@ -26,7 +28,8 @@ bool PhysicalJoin::EmptyResultIfRHSIsEmpty() const {
 //===--------------------------------------------------------------------===//
 // Pipeline Construction
 //===--------------------------------------------------------------------===//
-void PhysicalJoin::BuildJoinPipelines(Pipeline &current, MetaPipeline &meta_pipeline, PhysicalOperator &op) {
+void PhysicalJoin::BuildJoinPipelines(Pipeline &current, MetaPipeline &meta_pipeline, PhysicalOperator &op,
+                                      bool build_rhs) {
 	op.op_state.reset();
 	op.sink_state.reset();
 
@@ -37,11 +40,13 @@ void PhysicalJoin::BuildJoinPipelines(Pipeline &current, MetaPipeline &meta_pipe
 	// save the last added pipeline to set up dependencies later (in case we need to add a child pipeline)
 	vector<shared_ptr<Pipeline>> pipelines_so_far;
 	meta_pipeline.GetPipelines(pipelines_so_far, false);
-	auto last_pipeline = pipelines_so_far.back().get();
+	auto &last_pipeline = *pipelines_so_far.back();
 
-	// on the RHS (build side), we construct a child MetaPipeline with this operator as its sink
-	auto &child_meta_pipeline = meta_pipeline.CreateChildMetaPipeline(current, op);
-	child_meta_pipeline.Build(*op.children[1]);
+	if (build_rhs) {
+		// on the RHS (build side), we construct a child MetaPipeline with this operator as its sink
+		auto &child_meta_pipeline = meta_pipeline.CreateChildMetaPipeline(current, op);
+		child_meta_pipeline.Build(*op.children[1]);
+	}
 
 	// continue building the current pipeline on the LHS (probe side)
 	op.children[0]->BuildPipelines(current, meta_pipeline);