duckdb 1.1.2-dev6.0 → 1.1.4-dev11.0

package/src/duckdb/src/execution/join_hashtable.cpp

@@ -14,13 +14,13 @@ using ProbeSpill = JoinHashTable::ProbeSpill;
 using ProbeSpillLocalState = JoinHashTable::ProbeSpillLocalAppendState;
 
 JoinHashTable::SharedState::SharedState()
-    : rhs_row_locations(LogicalType::POINTER), salt_match_sel(STANDARD_VECTOR_SIZE),
+    : rhs_row_locations(LogicalType::POINTER), salt_v(LogicalType::UBIGINT), salt_match_sel(STANDARD_VECTOR_SIZE),
       key_no_match_sel(STANDARD_VECTOR_SIZE) {
 }
 
 JoinHashTable::ProbeState::ProbeState()
-    : SharedState(), salt_v(LogicalType::UBIGINT), ht_offsets_v(LogicalType::UBIGINT),
-      ht_offsets_dense_v(LogicalType::UBIGINT), non_empty_sel(STANDARD_VECTOR_SIZE) {
+    : SharedState(), ht_offsets_v(LogicalType::UBIGINT), ht_offsets_dense_v(LogicalType::UBIGINT),
+      non_empty_sel(STANDARD_VECTOR_SIZE) {
 }
 
 JoinHashTable::InsertState::InsertState(const JoinHashTable &ht)
@@ -34,7 +34,7 @@ JoinHashTable::JoinHashTable(ClientContext &context, const vector<JoinCondition>
     : buffer_manager(BufferManager::GetBufferManager(context)), conditions(conditions_p),
       build_types(std::move(btypes)), output_columns(output_columns_p), entry_size(0), tuple_size(0),
       vfound(Value::BOOLEAN(false)), join_type(type_p), finalized(false), has_null(false),
-      radix_bits(INITIAL_RADIX_BITS), partition_start(0), partition_end(0) {
+      radix_bits(INITIAL_RADIX_BITS) {
 	for (idx_t i = 0; i < conditions.size(); ++i) {
 		auto &condition = conditions[i];
 		D_ASSERT(condition.left->return_type == condition.right->return_type);
@@ -108,6 +108,8 @@ JoinHashTable::JoinHashTable(ClientContext &context, const vector<JoinCondition>
 		auto &config = ClientConfig::GetConfig(context);
 		single_join_error_on_multiple_rows = config.scalar_subquery_error_on_multiple_rows;
 	}
+
+	InitializePartitionMasks();
 }
 
 JoinHashTable::~JoinHashTable() {
@@ -132,21 +134,23 @@ void JoinHashTable::Merge(JoinHashTable &other) {
 	sink_collection->Combine(*other.sink_collection);
 }
 
-static void ApplyBitmaskAndGetSaltBuild(Vector &hashes_v, const idx_t &count, const idx_t &bitmask) {
+static void ApplyBitmaskAndGetSaltBuild(Vector &hashes_v, Vector &salt_v, const idx_t &count, const idx_t &bitmask) {
 	if (hashes_v.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		D_ASSERT(!ConstantVector::IsNull(hashes_v));
-		auto indices = ConstantVector::GetData<hash_t>(hashes_v);
-		hash_t salt = ht_entry_t::ExtractSaltWithNulls(*indices);
-		idx_t offset = *indices & bitmask;
-		*indices = offset | salt;
+		auto &hash = *ConstantVector::GetData<hash_t>(hashes_v);
+		salt_v.SetVectorType(VectorType::CONSTANT_VECTOR);
+
+		*ConstantVector::GetData<hash_t>(salt_v) = ht_entry_t::ExtractSalt(hash);
+		salt_v.Flatten(count);
+
+		hash = hash & bitmask;
 		hashes_v.Flatten(count);
 	} else {
 		hashes_v.Flatten(count);
+		auto salts = FlatVector::GetData<hash_t>(salt_v);
 		auto hashes = FlatVector::GetData<hash_t>(hashes_v);
 		for (idx_t i = 0; i < count; i++) {
-			idx_t salt = ht_entry_t::ExtractSaltWithNulls(hashes[i]);
-			idx_t offset = hashes[i] & bitmask;
-			hashes[i] = offset | salt;
+			salts[i] = ht_entry_t::ExtractSalt(hashes[i]);
+			hashes[i] &= bitmask;
 		}
 	}
 }
@@ -156,7 +160,7 @@ static void ApplyBitmaskAndGetSaltBuild(Vector &hashes_v, const idx_t &count, co
 template <bool USE_SALTS>
 static inline void GetRowPointersInternal(DataChunk &keys, TupleDataChunkState &key_state,
                                           JoinHashTable::ProbeState &state, Vector &hashes_v,
-                                          const SelectionVector &sel, idx_t &count, JoinHashTable *ht,
+                                          const SelectionVector &sel, idx_t &count, JoinHashTable &ht,
                                           ht_entry_t *entries, Vector &pointers_result_v, SelectionVector &match_sel) {
 	UnifiedVectorFormat hashes_v_unified;
 	hashes_v.ToUnifiedFormat(count, hashes_v_unified);
@@ -173,7 +177,7 @@ static inline void GetRowPointersInternal(DataChunk &keys, TupleDataChunkState &
 	for (idx_t i = 0; i < count; i++) {
 		const auto row_index = sel.get_index(i);
 		auto uvf_index = hashes_v_unified.sel->get_index(row_index);
-		auto ht_offset = hashes[uvf_index] & ht->bitmask;
+		auto ht_offset = hashes[uvf_index] & ht.bitmask;
 		ht_offsets_dense[i] = ht_offset;
 		ht_offsets[row_index] = ht_offset;
 	}
@@ -239,7 +243,7 @@ static inline void GetRowPointersInternal(DataChunk &keys, TupleDataChunkState &
 						break;
 					}
 
-					IncrementAndWrap(ht_offset, ht->bitmask);
+					IncrementAndWrap(ht_offset, ht.bitmask);
 				}
 			} else {
 				entry = entries[ht_offset];
@@ -258,9 +262,9 @@ static inline void GetRowPointersInternal(DataChunk &keys, TupleDataChunkState &
 
 		if (salt_match_count != 0) {
 			// Perform row comparisons, after function call salt_match_sel will point to the keys that match
-			idx_t key_match_count = ht->row_matcher_build.Match(keys, key_state.vector_data, state.salt_match_sel,
-			                                                    salt_match_count, ht->layout, state.rhs_row_locations,
-			                                                    &state.key_no_match_sel, key_no_match_count);
+			idx_t key_match_count = ht.row_matcher_build.Match(keys, key_state.vector_data, state.salt_match_sel,
+			                                                   salt_match_count, ht.layout, state.rhs_row_locations,
+			                                                   &state.key_no_match_sel, key_no_match_count);
 
 			D_ASSERT(key_match_count + key_no_match_count == salt_match_count);
 
@@ -278,7 +282,7 @@ static inline void GetRowPointersInternal(DataChunk &keys, TupleDataChunkState &
 				const auto row_index = state.key_no_match_sel.get_index(i);
 				auto &ht_offset = ht_offsets[row_index];
 
-				IncrementAndWrap(ht_offset, ht->bitmask);
+				IncrementAndWrap(ht_offset, ht.bitmask);
 			}
 		}
 
@@ -288,19 +292,18 @@ static inline void GetRowPointersInternal(DataChunk &keys, TupleDataChunkState &
 }
 
 inline bool JoinHashTable::UseSalt() const {
-	// only use salt for large hash tables and if there is only one equality condition as otherwise
-	// we potentially need to compare multiple keys
-	return this->capacity > USE_SALT_THRESHOLD && this->equality_predicate_columns.size() == 1;
+	// only use salt for large hash tables
+	return this->capacity > USE_SALT_THRESHOLD;
 }
 
 void JoinHashTable::GetRowPointers(DataChunk &keys, TupleDataChunkState &key_state, ProbeState &state, Vector &hashes_v,
                                    const SelectionVector &sel, idx_t &count, Vector &pointers_result_v,
                                    SelectionVector &match_sel) {
 	if (UseSalt()) {
-		GetRowPointersInternal<true>(keys, key_state, state, hashes_v, sel, count, this, entries, pointers_result_v,
+		GetRowPointersInternal<true>(keys, key_state, state, hashes_v, sel, count, *this, entries, pointers_result_v,
 		                             match_sel);
 	} else {
-		GetRowPointersInternal<false>(keys, key_state, state, hashes_v, sel, count, this, entries, pointers_result_v,
+		GetRowPointersInternal<false>(keys, key_state, state, hashes_v, sel, count, *this, entries, pointers_result_v,
 		                              match_sel);
 	}
 }
@@ -420,6 +423,10 @@ idx_t JoinHashTable::PrepareKeys(DataChunk &keys, vector<TupleDataVectorFormat>
 	}
 
 	for (idx_t col_idx = 0; col_idx < keys.ColumnCount(); col_idx++) {
+		// see internal issue 3717.
+		if (join_type == JoinType::MARK && !correlated_mark_join_info.correlated_types.empty()) {
+			continue;
+		}
 		if (null_values_are_equal[col_idx]) {
 			continue;
 		}
@@ -434,11 +441,11 @@ idx_t JoinHashTable::PrepareKeys(DataChunk &keys, vector<TupleDataVectorFormat>
 	return added_count;
 }
 
-static void StorePointer(const_data_ptr_t pointer, data_ptr_t target) {
+static void StorePointer(const const_data_ptr_t &pointer, const data_ptr_t &target) {
 	Store<uint64_t>(cast_pointer_to_uint64(pointer), target);
 }
 
-static data_ptr_t LoadPointer(const_data_ptr_t source) {
+static data_ptr_t LoadPointer(const const_data_ptr_t &source) {
 	return cast_uint64_to_pointer(Load<uint64_t>(source));
 }
 
@@ -448,44 +455,36 @@ static data_ptr_t LoadPointer(const_data_ptr_t source) {
 template <bool PARALLEL, bool EXPECT_EMPTY>
 static inline data_ptr_t InsertRowToEntry(atomic<ht_entry_t> &entry, const data_ptr_t &row_ptr_to_insert,
                                           const hash_t &salt, const idx_t &pointer_offset) {
-
+	const ht_entry_t desired_entry(salt, row_ptr_to_insert);
 	if (PARALLEL) {
-		// if we expect the entry to be empty, if the operation fails we need to cancel the whole operation as another
-		// key might have been inserted in the meantime that does not match the current key
 		if (EXPECT_EMPTY) {
-			// add nullptr to the end of the list to mark the end
+			// Add nullptr to the end of the list to mark the end
 			StorePointer(nullptr, row_ptr_to_insert + pointer_offset);
 
-			ht_entry_t new_empty_entry = ht_entry_t::GetDesiredEntry(row_ptr_to_insert, salt);
-			ht_entry_t expected_empty_entry = ht_entry_t::GetEmptyEntry();
-			entry.compare_exchange_strong(expected_empty_entry, new_empty_entry, std::memory_order_acquire,
+			ht_entry_t expected_entry;
+			entry.compare_exchange_strong(expected_entry, desired_entry, std::memory_order_acquire,
 			                              std::memory_order_relaxed);
 
-			// if the expected empty entry actually was null, we can just return the pointer, and it will be a nullptr
-			// if the expected entry was filled in the meantime, we need to cancel the operation and will return the
-			// pointer to the next entry
-			return expected_empty_entry.GetPointerOrNull();
+			// The expected entry is updated with the encountered entry by the compare exchange
+			// So, this returns a nullptr if it was empty, and a non-null if it was not (which cancels the insert)
+			return expected_entry.GetPointerOrNull();
 		} else {
-			// if we expect the entry to be full, we know that even if the insert fails the keys still match so we can
-			// just keep trying until we succeed
-			ht_entry_t expected_current_entry = entry.load(std::memory_order_relaxed);
-			ht_entry_t desired_new_entry = ht_entry_t::GetDesiredEntry(row_ptr_to_insert, salt);
-			D_ASSERT(expected_current_entry.IsOccupied());
-
+			// At this point we know that the keys match, so we can try to insert until we succeed
+			ht_entry_t expected_entry = entry.load(std::memory_order_relaxed);
+			D_ASSERT(expected_entry.IsOccupied());
 			do {
-				data_ptr_t current_row_pointer = expected_current_entry.GetPointer();
+				data_ptr_t current_row_pointer = expected_entry.GetPointer();
 				StorePointer(current_row_pointer, row_ptr_to_insert + pointer_offset);
-			} while (!entry.compare_exchange_weak(expected_current_entry, desired_new_entry, std::memory_order_release,
+			} while (!entry.compare_exchange_weak(expected_entry, desired_entry, std::memory_order_release,
 			                                      std::memory_order_relaxed));
 
 			return nullptr;
 		}
 	} else {
-		// if we are not in parallel mode, we can just do the operation without any checks
-		ht_entry_t current_entry = entry.load(std::memory_order_relaxed);
-		data_ptr_t current_row_pointer = current_entry.GetPointerOrNull();
+		// If we are not in parallel mode, we can just do the operation without any checks
+		data_ptr_t current_row_pointer = entry.load(std::memory_order_relaxed).GetPointerOrNull();
 		StorePointer(current_row_pointer, row_ptr_to_insert + pointer_offset);
-		entry = ht_entry_t::GetDesiredEntry(row_ptr_to_insert, salt);
+		entry = desired_entry;
 		return nullptr;
 	}
 }
@@ -518,8 +517,9 @@ static inline void PerformKeyComparison(JoinHashTable::InsertState &state, JoinH
 template <bool PARALLEL>
 static inline void InsertMatchesAndIncrementMisses(atomic<ht_entry_t> entries[], JoinHashTable::InsertState &state,
                                                    JoinHashTable &ht, const data_ptr_t lhs_row_locations[],
-                                                   idx_t ht_offsets_and_salts[], const idx_t capacity_mask,
-                                                   const idx_t key_match_count, const idx_t key_no_match_count) {
+                                                   idx_t ht_offsets[], const hash_t hash_salts[],
+                                                   const idx_t capacity_mask, const idx_t key_match_count,
+                                                   const idx_t key_no_match_count) {
 	if (key_match_count != 0) {
 		ht.chains_longer_than_one = true;
 	}
@@ -529,11 +529,11 @@ static inline void InsertMatchesAndIncrementMisses(atomic<ht_entry_t> entries[],
 		const auto need_compare_idx = state.key_match_sel.get_index(i);
 		const auto entry_index = state.salt_match_sel.get_index(need_compare_idx);
 
-		const auto &ht_offset = ht_offsets_and_salts[entry_index] & ht_entry_t::POINTER_MASK;
+		const auto &ht_offset = ht_offsets[entry_index];
 		auto &entry = entries[ht_offset];
-		const data_ptr_t row_ptr_to_insert = lhs_row_locations[entry_index];
+		const auto row_ptr_to_insert = lhs_row_locations[entry_index];
 
-		const auto salt = ht_offsets_and_salts[entry_index];
+		const auto salt = hash_salts[entry_index];
 		InsertRowToEntry<PARALLEL, false>(entry, row_ptr_to_insert, salt, ht.pointer_offset);
 	}
 
@@ -542,8 +542,8 @@ static inline void InsertMatchesAndIncrementMisses(atomic<ht_entry_t> entries[],
 		const auto need_compare_idx = state.key_no_match_sel.get_index(i);
 		const auto entry_index = state.salt_match_sel.get_index(need_compare_idx);
 
-		idx_t &ht_offset_and_salt = ht_offsets_and_salts[entry_index];
-		IncrementAndWrap(ht_offset_and_salt, capacity_mask);
+		auto &ht_offset = ht_offsets[entry_index];
+		IncrementAndWrap(ht_offset, capacity_mask);
 
 		state.remaining_sel.set_index(i, entry_index);
 	}
@@ -554,10 +554,11 @@ static void InsertHashesLoop(atomic<ht_entry_t> entries[], Vector &row_locations
                              JoinHashTable::InsertState &state, const TupleDataCollection &data_collection,
                              JoinHashTable &ht) {
 	D_ASSERT(hashes_v.GetType().id() == LogicalType::HASH);
-	ApplyBitmaskAndGetSaltBuild(hashes_v, count, ht.bitmask);
+	ApplyBitmaskAndGetSaltBuild(hashes_v, state.salt_v, count, ht.bitmask);
 
-	// the offset for each row to insert
-	const auto ht_offsets_and_salts = FlatVector::GetData<idx_t>(hashes_v);
+	// the salts offset for each row to insert
+	const auto ht_offsets = FlatVector::GetData<idx_t>(hashes_v);
+	const auto hash_salts = FlatVector::GetData<hash_t>(state.salt_v);
 	// the row locations of the rows that are already in the hash table
 	const auto rhs_row_locations = FlatVector::GetData<data_ptr_t>(state.rhs_row_locations);
 	// the row locations of the rows that are to be inserted
@@ -583,7 +584,7 @@ static void InsertHashesLoop(atomic<ht_entry_t> entries[], Vector &row_locations
 			idx_t new_remaining_count = 0;
 			for (idx_t i = 0; i < remaining_count; i++) {
 				const auto idx = remaining_sel->get_index(i);
-				if (ValidityBytes(lhs_row_locations[idx]).RowIsValidUnsafe(col_idx)) {
+				if (ValidityBytes(lhs_row_locations[idx], count).RowIsValidUnsafe(col_idx)) {
 					state.remaining_sel.set_index(new_remaining_count++, idx);
 				}
 			}
@@ -600,15 +601,13 @@ static void InsertHashesLoop(atomic<ht_entry_t> entries[], Vector &row_locations
 		// iterate over each entry to find out whether it belongs to an existing list or will start a new list
 		for (idx_t i = 0; i < remaining_count; i++) {
 			const idx_t row_index = remaining_sel->get_index(i);
-			idx_t &ht_offset_and_salt = ht_offsets_and_salts[row_index];
-			const hash_t salt = ht_entry_t::ExtractSalt(ht_offset_and_salt);
+			auto &ht_offset = ht_offsets[row_index];
+			auto &salt = hash_salts[row_index];
 
-			// increment the ht_offset_and_salt of the entry as long as next entry is occupied and salt does not match
-			idx_t ht_offset;
+			// increment the ht_offset of the entry as long as next entry is occupied and salt does not match
 			ht_entry_t entry;
 			bool occupied;
 			while (true) {
-				ht_offset = ht_offset_and_salt & ht_entry_t::POINTER_MASK;
 				atomic<ht_entry_t> &atomic_entry = entries[ht_offset];
 				entry = atomic_entry.load(std::memory_order_relaxed);
 				occupied = entry.IsOccupied();
@@ -621,7 +620,7 @@ static void InsertHashesLoop(atomic<ht_entry_t> entries[], Vector &row_locations
 					break;
 				}
 
-				IncrementAndWrap(ht_offset_and_salt, capacity_mask);
+				IncrementAndWrap(ht_offset, capacity_mask);
 			}
 
 			if (!occupied) { // insert into free
@@ -656,7 +655,7 @@ static void InsertHashesLoop(atomic<ht_entry_t> entries[], Vector &row_locations
 			idx_t key_match_count = 0;
 			PerformKeyComparison(state, ht, data_collection, row_locations, salt_match_count, key_match_count,
 			                     key_no_match_count);
-			InsertMatchesAndIncrementMisses<PARALLEL>(entries, state, ht, lhs_row_locations, ht_offsets_and_salts,
+			InsertMatchesAndIncrementMisses<PARALLEL>(entries, state, ht, lhs_row_locations, ht_offsets, hash_salts,
 			                                          capacity_mask, key_match_count, key_no_match_count);
 		}
 
@@ -701,7 +700,7 @@ void JoinHashTable::InitializePointerTable() {
 	D_ASSERT(hash_map.GetSize() == capacity * sizeof(ht_entry_t));
 
 	// initialize HT with all-zero entries
-	std::fill_n(entries, capacity, ht_entry_t::GetEmptyEntry());
+	std::fill_n(entries, capacity, ht_entry_t());
 
 	bitmask = capacity - 1;
 }
@@ -772,10 +771,12 @@ ScanStructure::ScanStructure(JoinHashTable &ht_p, TupleDataChunkState &key_state
     : key_state(key_state_p), pointers(LogicalType::POINTER), count(0), sel_vector(STANDARD_VECTOR_SIZE),
       chain_match_sel_vector(STANDARD_VECTOR_SIZE), chain_no_match_sel_vector(STANDARD_VECTOR_SIZE),
       found_match(make_unsafe_uniq_array_uninitialized<bool>(STANDARD_VECTOR_SIZE)), ht(ht_p), finished(false),
-      is_null(true) {
+      is_null(true), rhs_pointers(LogicalType::POINTER), lhs_sel_vector(STANDARD_VECTOR_SIZE), last_match_count(0),
+      last_sel_vector(STANDARD_VECTOR_SIZE) {
 }
 
 void ScanStructure::Next(DataChunk &keys, DataChunk &left, DataChunk &result) {
+	D_ASSERT(keys.size() == left.size());
 	if (finished) {
 		return;
 	}
@@ -896,46 +897,100 @@ void ScanStructure::GatherResult(Vector &result, const SelectionVector &sel_vect
 	GatherResult(result, *FlatVector::IncrementalSelectionVector(), sel_vector, count, col_idx);
 }
 
+void ScanStructure::GatherResult(Vector &result, const idx_t count, const idx_t col_idx) {
+	ht.data_collection->Gather(rhs_pointers, *FlatVector::IncrementalSelectionVector(), count, col_idx, result,
+	                           *FlatVector::IncrementalSelectionVector(), nullptr);
+}
+
+void ScanStructure::UpdateCompactionBuffer(idx_t base_count, SelectionVector &result_vector, idx_t result_count) {
+	// matches were found
+	// record the result
+	// on the LHS, we store result vector
+	for (idx_t i = 0; i < result_count; i++) {
+		lhs_sel_vector.set_index(base_count + i, result_vector.get_index(i));
+	}
+
+	// on the RHS, we collect their pointers
+	VectorOperations::Copy(pointers, rhs_pointers, result_vector, result_count, 0, base_count);
+}
+
 void ScanStructure::NextInnerJoin(DataChunk &keys, DataChunk &left, DataChunk &result) {
 	if (ht.join_type != JoinType::RIGHT_SEMI && ht.join_type != JoinType::RIGHT_ANTI) {
 		D_ASSERT(result.ColumnCount() == left.ColumnCount() + ht.output_columns.size());
 	}
-	if (this->count == 0) {
-		// no pointers left to chase
-		return;
-	}
 
-	idx_t result_count = ScanInnerJoin(keys, chain_match_sel_vector);
+	idx_t base_count = 0;
+	idx_t result_count;
+	while (this->count > 0) {
+		// if we have saved the match result, we need not call ScanInnerJoin again
+		if (last_match_count == 0) {
+			result_count = ScanInnerJoin(keys, chain_match_sel_vector);
+		} else {
+			chain_match_sel_vector.Initialize(last_sel_vector);
+			result_count = last_match_count;
+			last_match_count = 0;
+		}
 
-	if (result_count > 0) {
-		if (PropagatesBuildSide(ht.join_type)) {
-			// full/right outer join: mark join matches as FOUND in the HT
-			auto ptrs = FlatVector::GetData<data_ptr_t>(pointers);
-			for (idx_t i = 0; i < result_count; i++) {
-				auto idx = chain_match_sel_vector.get_index(i);
-				// NOTE: threadsan reports this as a data race because this can be set concurrently by separate
-				// threads Technically it is, but it does not matter, since the only value that can be written is
-				// "true"
-				Store<bool>(true, ptrs[idx] + ht.tuple_size);
+		if (result_count > 0) {
+			// the result chunk cannot contain more data, we record the match result for future use
+			if (base_count + result_count > STANDARD_VECTOR_SIZE) {
+				last_sel_vector.Initialize(chain_match_sel_vector);
+				last_match_count = result_count;
+				break;
 			}
-		}
-		// for right semi join, just mark the entry as found and move on. Propagation happens later
-		if (ht.join_type != JoinType::RIGHT_SEMI && ht.join_type != JoinType::RIGHT_ANTI) {
-			// matches were found
-			// construct the result
-			// on the LHS, we create a slice using the result vector
-			result.Slice(left, chain_match_sel_vector, result_count);
-
-			// on the RHS, we need to fetch the data from the hash table
-			for (idx_t i = 0; i < ht.output_columns.size(); i++) {
-				auto &vector = result.data[left.ColumnCount() + i];
-				const auto output_col_idx = ht.output_columns[i];
-				D_ASSERT(vector.GetType() == ht.layout.GetTypes()[output_col_idx]);
-				GatherResult(vector, chain_match_sel_vector, result_count, output_col_idx);
+
+			if (PropagatesBuildSide(ht.join_type)) {
+				// full/right outer join: mark join matches as FOUND in the HT
+				auto ptrs = FlatVector::GetData<data_ptr_t>(pointers);
+				for (idx_t i = 0; i < result_count; i++) {
+					auto idx = chain_match_sel_vector.get_index(i);
+					// NOTE: threadsan reports this as a data race because this can be set concurrently by separate
+					// threads Technically it is, but it does not matter, since the only value that can be written is
+					// "true"
+					Store<bool>(true, ptrs[idx] + ht.tuple_size);
+				}
+			}
+
+			if (ht.join_type != JoinType::RIGHT_SEMI && ht.join_type != JoinType::RIGHT_ANTI) {
+				// Fast Path: if there is NO more than one element in the chain, we construct the result chunk directly
+				if (!ht.chains_longer_than_one) {
+					// matches were found
+					// on the LHS, we create a slice using the result vector
+					result.Slice(left, chain_match_sel_vector, result_count);
+
+					// on the RHS, we need to fetch the data from the hash table
+					for (idx_t i = 0; i < ht.output_columns.size(); i++) {
+						auto &vector = result.data[left.ColumnCount() + i];
+						const auto output_col_idx = ht.output_columns[i];
+						D_ASSERT(vector.GetType() == ht.layout.GetTypes()[output_col_idx]);
+						GatherResult(vector, chain_match_sel_vector, result_count, output_col_idx);
+					}
+
+					AdvancePointers();
+					return;
+				}
+
+				// Common Path: use a buffer to store temporary data
+				UpdateCompactionBuffer(base_count, chain_match_sel_vector, result_count);
+				base_count += result_count;
 			}
 		}
 		AdvancePointers();
 	}
+
+	if (base_count > 0) {
+		// create result chunk, we have two steps:
+		// 1) slice LHS vectors
+		result.Slice(left, lhs_sel_vector, base_count);
+
+		// 2) gather RHS vectors
+		for (idx_t i = 0; i < ht.output_columns.size(); i++) {
+			auto &vector = result.data[left.ColumnCount() + i];
+			const auto output_col_idx = ht.output_columns[i];
+			D_ASSERT(vector.GetType() == ht.layout.GetTypes()[output_col_idx]);
+			GatherResult(vector, base_count, output_col_idx);
+		}
+	}
 }
 
 void ScanStructure::ScanKeyMatches(DataChunk &keys) {
@@ -963,7 +1018,6 @@ void ScanStructure::ScanKeyMatches(DataChunk &keys) {
 template <bool MATCH>
 void ScanStructure::NextSemiOrAntiJoin(DataChunk &keys, DataChunk &left, DataChunk &result) {
 	D_ASSERT(left.ColumnCount() == result.ColumnCount());
-	D_ASSERT(keys.size() == left.size());
 	// create the selection vector from the matches that were found
 	SelectionVector sel(STANDARD_VECTOR_SIZE);
 	idx_t result_count = 0;
@@ -1378,7 +1432,10 @@ idx_t JoinHashTable::GetRemainingSize() const {
 
 	idx_t count = 0;
 	idx_t data_size = 0;
-	for (idx_t partition_idx = partition_end; partition_idx < num_partitions; partition_idx++) {
+	for (idx_t partition_idx = 0; partition_idx < num_partitions; partition_idx++) {
+		if (completed_partitions.RowIsValidUnsafe(partition_idx)) {
+			continue;
+		}
 		count += partitions[partition_idx]->Count();
 		data_size += partitions[partition_idx]->SizeInBytes();
 	}
@@ -1412,6 +1469,32 @@ void JoinHashTable::SetRepartitionRadixBits(const idx_t max_ht_size, const idx_t
 	radix_bits += added_bits;
 	sink_collection =
 	    make_uniq<RadixPartitionedTupleData>(buffer_manager, layout, radix_bits, layout.ColumnCount() - 1);
+
+	// Need to initialize again after changing the number of bits
+	InitializePartitionMasks();
+}
+
+void JoinHashTable::InitializePartitionMasks() {
+	const auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
+
+	current_partitions.Initialize(num_partitions);
+	current_partitions.SetAllInvalid(num_partitions);
+
+	completed_partitions.Initialize(num_partitions);
+	completed_partitions.SetAllInvalid(num_partitions);
+}
+
+idx_t JoinHashTable::CurrentPartitionCount() const {
+	const auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
+	D_ASSERT(current_partitions.Capacity() == num_partitions);
+	return current_partitions.CountValid(num_partitions);
+}
+
+idx_t JoinHashTable::FinishedPartitionCount() const {
+	const auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
+	D_ASSERT(completed_partitions.Capacity() == num_partitions);
+	// We already marked the active partitions as done, so we have to subtract them here
+	return completed_partitions.CountValid(num_partitions) - CurrentPartitionCount();
 }
 
 void JoinHashTable::Repartition(JoinHashTable &global_ht) {
@@ -1425,6 +1508,7 @@ void JoinHashTable::Repartition(JoinHashTable &global_ht) {
 void JoinHashTable::Reset() {
 	data_collection->Reset();
 	hash_map.Reset();
+	current_partitions.SetAllInvalid(RadixPartitioning::NumberOfPartitions(radix_bits));
 	finalized = false;
 }
 
@@ -1434,90 +1518,98 @@ bool JoinHashTable::PrepareExternalFinalize(const idx_t max_ht_size) {
 	}
 
 	const auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
-	if (partition_end == num_partitions) {
-		return false;
+	D_ASSERT(current_partitions.Capacity() == num_partitions);
+	D_ASSERT(completed_partitions.Capacity() == num_partitions);
+	D_ASSERT(current_partitions.CheckAllInvalid(num_partitions));
+
+	if (completed_partitions.CheckAllValid(num_partitions)) {
+		return false; // All partitions are done
 	}
 
-	// Start where we left off
+	// Create vector with unfinished partition indices
 	auto &partitions = sink_collection->GetPartitions();
-	partition_start = partition_end;
-
-	// Determine how many partitions we can do next (at least one)
+	auto min_partition_size = NumericLimits<idx_t>::Maximum();
+	vector<idx_t> partition_indices;
+	partition_indices.reserve(num_partitions);
+	for (idx_t partition_idx = 0; partition_idx < num_partitions; partition_idx++) {
+		if (completed_partitions.RowIsValidUnsafe(partition_idx)) {
+			continue;
+		}
+		partition_indices.push_back(partition_idx);
+		// Keep track of min partition size
+		const auto size =
+		    partitions[partition_idx]->SizeInBytes() + PointerTableSize(partitions[partition_idx]->Count());
+		min_partition_size = MinValue(min_partition_size, size);
+	}
+
+	// Sort partitions by size, from small to large
+	std::stable_sort(partition_indices.begin(), partition_indices.end(), [&](const idx_t &lhs, const idx_t &rhs) {
+		const auto lhs_size = partitions[lhs]->SizeInBytes() + PointerTableSize(partitions[lhs]->Count());
+		const auto rhs_size = partitions[rhs]->SizeInBytes() + PointerTableSize(partitions[rhs]->Count());
+		// We divide by min_partition_size, effectively rouding everything down to a multiple of min_partition_size
+		// Makes it so minor differences in partition sizes don't mess up the original order
+		// Retaining as much of the original order as possible reduces I/O (partition idx determines eviction queue idx)
+		return lhs_size / min_partition_size < rhs_size / min_partition_size;
+	});
+
+	// Determine which partitions should go next
 	idx_t count = 0;
 	idx_t data_size = 0;
-	idx_t partition_idx;
-	for (partition_idx = partition_start; partition_idx < num_partitions; partition_idx++) {
-		auto incl_count = count + partitions[partition_idx]->Count();
-		auto incl_data_size = data_size + partitions[partition_idx]->SizeInBytes();
-		auto incl_ht_size = incl_data_size + PointerTableSize(incl_count);
+	for (const auto &partition_idx : partition_indices) {
+		D_ASSERT(!completed_partitions.RowIsValidUnsafe(partition_idx));
+		const auto incl_count = count + partitions[partition_idx]->Count();
+		const auto incl_data_size = data_size + partitions[partition_idx]->SizeInBytes();
+		const auto incl_ht_size = incl_data_size + PointerTableSize(incl_count);
 		if (count > 0 && incl_ht_size > max_ht_size) {
-			break;
+			break; // Always add at least one partition
 		}
 		count = incl_count;
 		data_size = incl_data_size;
-	}
-	partition_end = partition_idx;
-
-	// Move the partitions to the main data collection
-	for (partition_idx = partition_start; partition_idx < partition_end; partition_idx++) {
-		data_collection->Combine(*partitions[partition_idx]);
+		current_partitions.SetValidUnsafe(partition_idx);     // Mark as currently active
+		data_collection->Combine(*partitions[partition_idx]); // Move partition to the main data collection
+		completed_partitions.SetValidUnsafe(partition_idx);   // Also already mark as done
 	}
 	D_ASSERT(Count() == count);
 
 	return true;
 }
 
-static void CreateSpillChunk(DataChunk &spill_chunk, DataChunk &keys, DataChunk &payload, Vector &hashes) {
-	spill_chunk.Reset();
-	idx_t spill_col_idx = 0;
-	for (idx_t col_idx = 0; col_idx < keys.ColumnCount(); col_idx++) {
-		spill_chunk.data[col_idx].Reference(keys.data[col_idx]);
-	}
-	spill_col_idx += keys.ColumnCount();
-	for (idx_t col_idx = 0; col_idx < payload.data.size(); col_idx++) {
-		spill_chunk.data[spill_col_idx + col_idx].Reference(payload.data[col_idx]);
-	}
-	spill_col_idx += payload.ColumnCount();
-	spill_chunk.data[spill_col_idx].Reference(hashes);
-}
-
-void JoinHashTable::ProbeAndSpill(ScanStructure &scan_structure, DataChunk &keys, TupleDataChunkState &key_state,
-                                  ProbeState &probe_state, DataChunk &payload, ProbeSpill &probe_spill,
+void JoinHashTable::ProbeAndSpill(ScanStructure &scan_structure, DataChunk &probe_keys, TupleDataChunkState &key_state,
+                                  ProbeState &probe_state, DataChunk &probe_chunk, ProbeSpill &probe_spill,
                                   ProbeSpillLocalAppendState &spill_state, DataChunk &spill_chunk) {
 	// hash all the keys
 	Vector hashes(LogicalType::HASH);
-	Hash(keys, *FlatVector::IncrementalSelectionVector(), keys.size(), hashes);
+	Hash(probe_keys, *FlatVector::IncrementalSelectionVector(), probe_keys.size(), hashes);
 
 	// find out which keys we can match with the current pinned partitions
-	SelectionVector true_sel;
-	SelectionVector false_sel;
-	true_sel.Initialize();
-	false_sel.Initialize();
-	auto true_count = RadixPartitioning::Select(hashes, FlatVector::IncrementalSelectionVector(), keys.size(),
-	                                            radix_bits, partition_end, &true_sel, &false_sel);
-	auto false_count = keys.size() - true_count;
-
-	CreateSpillChunk(spill_chunk, keys, payload, hashes);
+	SelectionVector true_sel(STANDARD_VECTOR_SIZE);
+	SelectionVector false_sel(STANDARD_VECTOR_SIZE);
+	const auto true_count =
+	    RadixPartitioning::Select(hashes, FlatVector::IncrementalSelectionVector(), probe_keys.size(), radix_bits,
+	                              current_partitions, &true_sel, &false_sel);
+	const auto false_count = probe_keys.size() - true_count;
 
 	// can't probe these values right now, append to spill
+	spill_chunk.Reset();
+	spill_chunk.Reference(probe_chunk);
+	spill_chunk.data.back().Reference(hashes);
 	spill_chunk.Slice(false_sel, false_count);
-	spill_chunk.Verify();
 	probe_spill.Append(spill_chunk, spill_state);
 
 	// slice the stuff we CAN probe right now
 	hashes.Slice(true_sel, true_count);
-	keys.Slice(true_sel, true_count);
-	payload.Slice(true_sel, true_count);
+	probe_keys.Slice(true_sel, true_count);
+	probe_chunk.Slice(true_sel, true_count);
 
 	const SelectionVector *current_sel;
-	InitializeScanStructure(scan_structure, keys, key_state, current_sel);
+	InitializeScanStructure(scan_structure, probe_keys, key_state, current_sel);
 	if (scan_structure.count == 0) {
 		return;
 	}
 
 	// now initialize the pointers of the scan structure based on the hashes
-	GetRowPointers(keys, key_state, probe_state, hashes, *current_sel, scan_structure.count, scan_structure.pointers,
-	               scan_structure.sel_vector);
+	GetRowPointers(probe_keys, key_state, probe_state, hashes, *current_sel, scan_structure.count,
+	               scan_structure.pointers, scan_structure.sel_vector);
 }
 
 ProbeSpill::ProbeSpill(JoinHashTable &ht, ClientContext &context, const vector<LogicalType> &probe_types)
@@ -1559,21 +1651,25 @@ void ProbeSpill::Finalize() {
 }
 
 void ProbeSpill::PrepareNextProbe() {
+	global_spill_collection.reset();
 	auto &partitions = global_partitions->GetPartitions();
-	if (partitions.empty() || ht.partition_start == partitions.size()) {
+	if (partitions.empty() || ht.current_partitions.CheckAllInvalid(partitions.size())) {
 		// Can't probe, just make an empty one
 		global_spill_collection =
 		    make_uniq<ColumnDataCollection>(BufferManager::GetBufferManager(context), probe_types);
 	} else {
-		// Move specific partitions to the global spill collection
-		global_spill_collection = std::move(partitions[ht.partition_start]);
-		for (idx_t i = ht.partition_start + 1; i < ht.partition_end; i++) {
-			auto &partition = partitions[i];
-			if (global_spill_collection->Count() == 0) {
+		// Move current partitions to the global spill collection
+		for (idx_t partition_idx = 0; partition_idx < partitions.size(); partition_idx++) {
+			if (!ht.current_partitions.RowIsValidUnsafe(partition_idx)) {
+				continue;
+			}
+			auto &partition = partitions[partition_idx];
+			if (!global_spill_collection) {
 				global_spill_collection = std::move(partition);
-			} else {
+			} else if (partition->Count() != 0) {
 				global_spill_collection->Combine(*partition);
 			}
+			partition.reset();
 		}
 	}
 	consumer = make_uniq<ColumnDataConsumer>(*global_spill_collection, column_ids);