duckdb 0.9.3-dev0.0 → 0.9.3-dev3.0

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

@@ -15,10 +15,10 @@ using ProbeSpill = JoinHashTable::ProbeSpill;
 using ProbeSpillLocalState = JoinHashTable::ProbeSpillLocalAppendState;
 
 JoinHashTable::JoinHashTable(BufferManager &buffer_manager_p, const vector<JoinCondition> &conditions_p,
-                             vector<LogicalType> btypes, JoinType type_p)
-    : buffer_manager(buffer_manager_p), conditions(conditions_p), build_types(std::move(btypes)), entry_size(0),
-      tuple_size(0), vfound(Value::BOOLEAN(false)), join_type(type_p), finalized(false), has_null(false),
-      external(false), radix_bits(4), partition_start(0), partition_end(0) {
+                             vector<LogicalType> btypes, JoinType type_p, const vector<idx_t> &output_columns_p)
+    : buffer_manager(buffer_manager_p), 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) {
 
 	for (auto &condition : conditions) {
 		D_ASSERT(condition.left->return_type == condition.right->return_type);
@@ -44,7 +44,7 @@ JoinHashTable::JoinHashTable(BufferManager &buffer_manager_p, const vector<JoinC
 	// Types for the layout
 	vector<LogicalType> layout_types(condition_types);
 	layout_types.insert(layout_types.end(), build_types.begin(), build_types.end());
-	if (IsRightOuterJoin(join_type)) {
+	if (PropagatesBuildSide(join_type)) {
 		// full/right outer joins need an extra bool to keep track of whether or not a tuple has found a matching entry
 		// we place the bool before the NEXT pointer
 		layout_types.emplace_back(LogicalType::BOOLEAN);
@@ -184,7 +184,7 @@ void JoinHashTable::Build(PartitionedTupleDataAppendState &append_state, DataChu
 		source_chunk.data[col_offset + i].Reference(payload.data[i]);
 	}
 	col_offset += payload.ColumnCount();
-	if (IsRightOuterJoin(join_type)) {
+	if (PropagatesBuildSide(join_type)) {
 		// for FULL/RIGHT OUTER joins initialize the "found" boolean to false
 		source_chunk.data[col_offset].Reference(vfound);
 		col_offset++;
@@ -224,7 +224,7 @@ idx_t JoinHashTable::PrepareKeys(DataChunk &keys, vector<TupleDataVectorFormat>
 	// figure out which keys are NULL, and create a selection vector out of them
 	current_sel = FlatVector::IncrementalSelectionVector();
 	idx_t added_count = keys.size();
-	if (build_side && IsRightOuterJoin(join_type)) {
+	if (build_side && (PropagatesBuildSide(join_type))) {
 		// in case of a right or full outer join, we cannot remove NULL keys from the build side
 		return added_count;
 	}
@@ -290,12 +290,9 @@ void JoinHashTable::InitializePointerTable() {
 	if (hash_map.get()) {
 		// There is already a hash map
 		auto current_capacity = hash_map.GetSize() / sizeof(data_ptr_t);
-		if (capacity > current_capacity) {
-			// Need more space
+		if (capacity != current_capacity) {
+			// Different size, re-allocate
 			hash_map = buffer_manager.GetBufferAllocator().Allocate(capacity * sizeof(data_ptr_t));
-		} else {
-			// Just use the current hash map
-			capacity = current_capacity;
 		}
 	} else {
 		// Allocate a hash map
@@ -384,6 +381,8 @@ void ScanStructure::Next(DataChunk &keys, DataChunk &left, DataChunk &result) {
 	switch (ht.join_type) {
 	case JoinType::INNER:
 	case JoinType::RIGHT:
+	case JoinType::RIGHT_ANTI:
+	case JoinType::RIGHT_SEMI:
 		NextInnerJoin(keys, left, result);
 		break;
 	case JoinType::SEMI:
@@ -407,6 +406,13 @@ void ScanStructure::Next(DataChunk &keys, DataChunk &left, DataChunk &result) {
 	}
 }
 
+bool ScanStructure::PointersExhausted() {
+	// AdvancePointers creates a "new_count" for every pointer advanced during the
+	// previous advance pointers call. If no pointers are advanced, new_count = 0.
+	// count is then set ot new_count.
+	return count == 0;
+}
+
 idx_t ScanStructure::ResolvePredicates(DataChunk &keys, SelectionVector &match_sel, SelectionVector *no_match_sel) {
 	// Start with the scan selection
 	for (idx_t i = 0; i < this->count; ++i) {
@@ -476,7 +482,7 @@ void ScanStructure::AdvancePointers() {
 
 void ScanStructure::GatherResult(Vector &result, const SelectionVector &result_vector,
                                  const SelectionVector &sel_vector, const idx_t count, const idx_t col_no) {
-	ht.data_collection->Gather(pointers, sel_vector, count, col_no, result, result_vector);
+	ht.data_collection->Gather(pointers, sel_vector, count, col_no, result, result_vector, nullptr);
 }
 
 void ScanStructure::GatherResult(Vector &result, const SelectionVector &sel_vector, const idx_t count,
@@ -485,7 +491,9 @@ void ScanStructure::GatherResult(Vector &result, const SelectionVector &sel_vect
 }
 
 void ScanStructure::NextInnerJoin(DataChunk &keys, DataChunk &left, DataChunk &result) {
-	D_ASSERT(result.ColumnCount() == left.ColumnCount() + ht.build_types.size());
+	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;
@@ -495,7 +503,7 @@ void ScanStructure::NextInnerJoin(DataChunk &keys, DataChunk &left, DataChunk &r
 
 	idx_t result_count = ScanInnerJoin(keys, result_vector);
 	if (result_count > 0) {
-		if (IsRightOuterJoin(ht.join_type)) {
+		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++) {
@@ -505,16 +513,20 @@ void ScanStructure::NextInnerJoin(DataChunk &keys, DataChunk &left, DataChunk &r
 				Store<bool>(true, ptrs[idx] + ht.tuple_size);
 			}
 		}
-		// matches were found
-		// construct the result
-		// on the LHS, we create a slice using the result vector
-		result.Slice(left, result_vector, result_count);
-
-		// on the RHS, we need to fetch the data from the hash table
-		for (idx_t i = 0; i < ht.build_types.size(); i++) {
-			auto &vector = result.data[left.ColumnCount() + i];
-			D_ASSERT(vector.GetType() == ht.build_types[i]);
-			GatherResult(vector, result_vector, result_count, i + ht.condition_types.size());
+		// for right semi join, just mark the entry as found and move on. Propogation 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, result_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, result_vector, result_count, output_col_idx);
+			}
 		}
 		AdvancePointers();
 	}
@@ -759,7 +771,7 @@ void ScanStructure::NextSingleJoin(DataChunk &keys, DataChunk &input, DataChunk
 		result.data[i].Reference(input.data[i]);
 	}
 	// now fetch the data from the RHS
-	for (idx_t i = 0; i < ht.build_types.size(); i++) {
+	for (idx_t i = 0; i < ht.output_columns.size(); i++) {
 		auto &vector = result.data[input.ColumnCount() + i];
 		// set NULL entries for every entry that was not found
 		for (idx_t j = 0; j < input.size(); j++) {
@@ -767,8 +779,9 @@ void ScanStructure::NextSingleJoin(DataChunk &keys, DataChunk &input, DataChunk
 				FlatVector::SetNull(vector, j, true);
 			}
 		}
-		// for the remaining values we fetch the values
-		GatherResult(vector, result_sel, result_sel, result_count, i + ht.condition_types.size());
+		const auto output_col_idx = ht.output_columns[i];
+		D_ASSERT(vector.GetType() == ht.layout.GetTypes()[output_col_idx]);
+		GatherResult(vector, result_sel, result_sel, result_count, output_col_idx);
 	}
 	result.SetCardinality(input.size());
 
@@ -786,12 +799,20 @@ void JoinHashTable::ScanFullOuter(JoinHTScanState &state, Vector &addresses, Dat
 		return;
 	}
 
+	// When scanning Full Outer for right semi joins, we only propagate matches that have true
+	// Right Semi Joins do not propagate values during the probe phase, since we do not want to
+	// duplicate RHS rows.
+	bool match_propagation_value = false;
+	if (join_type == JoinType::RIGHT_SEMI) {
+		match_propagation_value = true;
+	}
+
 	const auto row_locations = iterator.GetRowLocations();
 	do {
 		const auto count = iterator.GetCurrentChunkCount();
 		for (idx_t i = state.offset_in_chunk; i < count; i++) {
 			auto found_match = Load<bool>(row_locations[i] + tuple_size);
-			if (!found_match) {
+			if (found_match == match_propagation_value) {
 				key_locations[found_entries++] = row_locations[i];
 				if (found_entries == STANDARD_VECTOR_SIZE) {
 					state.offset_in_chunk = i + 1;
@@ -810,7 +831,11 @@ void JoinHashTable::ScanFullOuter(JoinHTScanState &state, Vector &addresses, Dat
 		return;
 	}
 	result.SetCardinality(found_entries);
-	idx_t left_column_count = result.ColumnCount() - build_types.size();
+
+	idx_t left_column_count = result.ColumnCount() - output_columns.size();
+	if (join_type == JoinType::RIGHT_SEMI || join_type == JoinType::RIGHT_ANTI) {
+		left_column_count = 0;
+	}
 	const auto &sel_vector = *FlatVector::IncrementalSelectionVector();
 	// set the left side as a constant NULL
 	for (idx_t i = 0; i < left_column_count; i++) {
@@ -820,11 +845,11 @@ void JoinHashTable::ScanFullOuter(JoinHTScanState &state, Vector &addresses, Dat
 	}
 
 	// gather the values from the RHS
-	for (idx_t i = 0; i < build_types.size(); i++) {
+	for (idx_t i = 0; i < output_columns.size(); i++) {
 		auto &vector = result.data[left_column_count + i];
-		D_ASSERT(vector.GetType() == build_types[i]);
-		const auto col_no = condition_types.size() + i;
-		data_collection->Gather(addresses, sel_vector, found_entries, col_no, vector, sel_vector);
+		const auto output_col_idx = output_columns[i];
+		D_ASSERT(vector.GetType() == layout.GetTypes()[output_col_idx]);
+		data_collection->Gather(addresses, sel_vector, found_entries, output_col_idx, vector, sel_vector, nullptr);
 	}
 }
 
@@ -846,96 +871,88 @@ idx_t JoinHashTable::FillWithHTOffsets(JoinHTScanState &state, Vector &addresses
 	return key_count;
 }
 
-bool JoinHashTable::RequiresExternalJoin(ClientConfig &config, vector<unique_ptr<JoinHashTable>> &local_hts) {
-	total_count = 0;
-	idx_t data_size = 0;
-	for (auto &ht : local_hts) {
-		auto &local_sink_collection = ht->GetSinkCollection();
-		total_count += local_sink_collection.Count();
-		data_size += local_sink_collection.SizeInBytes();
+idx_t JoinHashTable::GetTotalSize(const vector<idx_t> &partition_sizes, const vector<idx_t> &partition_counts,
+                                  idx_t &max_partition_size, idx_t &max_partition_count) const {
+	const auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
+
+	idx_t total_size = 0;
+	idx_t total_count = 0;
+	idx_t max_partition_ht_size = 0;
+	max_partition_size = 0;
+	max_partition_count = 0;
+	for (idx_t i = 0; i < num_partitions; i++) {
+		total_size += partition_sizes[i];
+		total_count += partition_counts[i];
+
+		auto partition_size = partition_sizes[i] + PointerTableSize(partition_counts[i]);
+		if (partition_size > max_partition_ht_size) {
+			max_partition_ht_size = partition_size;
+			max_partition_size = partition_sizes[i];
+			max_partition_count = partition_counts[i];
+		}
 	}
 
 	if (total_count == 0) {
-		return false;
+		return 0;
 	}
 
-	if (config.force_external) {
-		// Do 1 round per partition if forcing external join to test all code paths
-		const auto r = RadixPartitioning::NumberOfPartitions(radix_bits);
-		auto data_size_per_round = (data_size + r - 1) / r;
-		auto count_per_round = (total_count + r - 1) / r;
-		max_ht_size = data_size_per_round + PointerTableSize(count_per_round);
-		external = true;
-	} else {
-		auto ht_size = data_size + PointerTableSize(total_count);
-		external = ht_size > max_ht_size;
-	}
-	return external;
+	return total_size + PointerTableSize(total_count);
 }
 
-void JoinHashTable::Unpartition() {
-	for (auto &partition : sink_collection->GetPartitions()) {
-		data_collection->Combine(*partition);
+idx_t JoinHashTable::GetTotalSize(vector<unique_ptr<JoinHashTable>> &local_hts, idx_t &max_partition_size,
+                                  idx_t &max_partition_count) const {
+	const auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
+	vector<idx_t> partition_sizes(num_partitions, 0);
+	vector<idx_t> partition_counts(num_partitions, 0);
+	for (auto &ht : local_hts) {
+		ht->GetSinkCollection().GetSizesAndCounts(partition_sizes, partition_counts);
 	}
+
+	return GetTotalSize(partition_sizes, partition_counts, max_partition_size, max_partition_count);
 }
 
-bool JoinHashTable::RequiresPartitioning(ClientConfig &config, vector<unique_ptr<JoinHashTable>> &local_hts) {
-	D_ASSERT(total_count != 0);
-	D_ASSERT(external);
+idx_t JoinHashTable::GetRemainingSize() {
+	const auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
+	auto &partitions = sink_collection->GetPartitions();
 
-	idx_t num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
-	vector<idx_t> partition_counts(num_partitions, 0);
-	vector<idx_t> partition_sizes(num_partitions, 0);
-	for (auto &ht : local_hts) {
-		const auto &local_partitions = ht->GetSinkCollection().GetPartitions();
-		for (idx_t partition_idx = 0; partition_idx < num_partitions; partition_idx++) {
-			auto &local_partition = local_partitions[partition_idx];
-			partition_counts[partition_idx] += local_partition->Count();
-			partition_sizes[partition_idx] += local_partition->SizeInBytes();
-		}
+	idx_t count = 0;
+	idx_t data_size = 0;
+	for (idx_t partition_idx = partition_end; partition_idx < num_partitions; partition_idx++) {
+		count += partitions[partition_idx]->Count();
+		data_size += partitions[partition_idx]->SizeInBytes();
 	}
 
-	// Figure out if we can fit all single partitions in memory
-	idx_t max_partition_idx = 0;
-	idx_t max_partition_size = 0;
-	for (idx_t partition_idx = 0; partition_idx < num_partitions; partition_idx++) {
-		const auto &partition_count = partition_counts[partition_idx];
-		const auto &partition_size = partition_sizes[partition_idx];
-		auto partition_ht_size = partition_size + PointerTableSize(partition_count);
-		if (partition_ht_size > max_partition_size) {
-			max_partition_size = partition_ht_size;
-			max_partition_idx = partition_idx;
-		}
-	}
+	return data_size + PointerTableSize(count);
+}
 
-	if (config.force_external || max_partition_size > max_ht_size) {
-		const auto partition_count = partition_counts[max_partition_idx];
-		const auto partition_size = partition_sizes[max_partition_idx];
+void JoinHashTable::Unpartition() {
+	data_collection = sink_collection->GetUnpartitioned();
+}
 
-		const auto max_added_bits = RadixPartitioning::MAX_RADIX_BITS - radix_bits;
-		idx_t added_bits = config.force_external ? 2 : 1;
-		for (; added_bits < max_added_bits; added_bits++) {
-			double partition_multiplier = RadixPartitioning::NumberOfPartitions(added_bits);
+void JoinHashTable::SetRepartitionRadixBits(vector<unique_ptr<JoinHashTable>> &local_hts, const idx_t max_ht_size,
+                                            const idx_t max_partition_size, const idx_t max_partition_count) {
+	D_ASSERT(max_partition_size + PointerTableSize(max_partition_count) > max_ht_size);
 
-			auto new_estimated_count = double(partition_count) / partition_multiplier;
-			auto new_estimated_size = double(partition_size) / partition_multiplier;
-			auto new_estimated_ht_size = new_estimated_size + PointerTableSize(new_estimated_count);
+	const auto max_added_bits = RadixPartitioning::MAX_RADIX_BITS - radix_bits;
+	idx_t added_bits = 1;
+	for (; added_bits < max_added_bits; added_bits++) {
+		double partition_multiplier = RadixPartitioning::NumberOfPartitions(added_bits);
 
-			if (config.force_external || new_estimated_ht_size <= double(max_ht_size) / 4) {
-				// Aim for an estimated partition size of max_ht_size / 4
-				break;
-			}
+		auto new_estimated_size = double(max_partition_size) / partition_multiplier;
+		auto new_estimated_count = double(max_partition_count) / partition_multiplier;
+		auto new_estimated_ht_size = new_estimated_size + PointerTableSize(new_estimated_count);
+
+		if (new_estimated_ht_size <= double(max_ht_size) / 4) {
+			// Aim for an estimated partition size of max_ht_size / 4
+			break;
 		}
-		radix_bits += added_bits;
-		sink_collection =
-		    make_uniq<RadixPartitionedTupleData>(buffer_manager, layout, radix_bits, layout.ColumnCount() - 1);
-		return true;
-	} else {
-		return false;
 	}
+	radix_bits += added_bits;
+	sink_collection =
+	    make_uniq<RadixPartitionedTupleData>(buffer_manager, layout, radix_bits, layout.ColumnCount() - 1);
 }
 
-void JoinHashTable::Partition(JoinHashTable &global_ht) {
+void JoinHashTable::Repartition(JoinHashTable &global_ht) {
 	auto new_sink_collection =
 	    make_uniq<RadixPartitionedTupleData>(buffer_manager, layout, global_ht.radix_bits, layout.ColumnCount() - 1);
 	sink_collection->Repartition(*new_sink_collection);
@@ -948,7 +965,7 @@ void JoinHashTable::Reset() {
 	finalized = false;
 }
 
-bool JoinHashTable::PrepareExternalFinalize() {
+bool JoinHashTable::PrepareExternalFinalize(const idx_t max_ht_size) {
 	if (finalized) {
 		Reset();
 	}
@@ -1047,18 +1064,8 @@ unique_ptr<ScanStructure> JoinHashTable::ProbeAndSpill(DataChunk &keys, TupleDat
 
 ProbeSpill::ProbeSpill(JoinHashTable &ht, ClientContext &context, const vector<LogicalType> &probe_types)
     : ht(ht), context(context), probe_types(probe_types) {
-	auto remaining_count = ht.GetSinkCollection().Count();
-	auto remaining_data_size = ht.GetSinkCollection().SizeInBytes();
-	auto remaining_ht_size = remaining_data_size + ht.PointerTableSize(remaining_count);
-	if (remaining_ht_size <= ht.max_ht_size) {
-		// No need to partition as we will only have one more probe round
-		partitioned = false;
-	} else {
-		// More than one probe round to go, so we need to partition
-		partitioned = true;
-		global_partitions =
-		    make_uniq<RadixPartitionedColumnData>(context, probe_types, ht.radix_bits, probe_types.size() - 1);
-	}
+	global_partitions =
+	    make_uniq<RadixPartitionedColumnData>(context, probe_types, ht.radix_bits, probe_types.size() - 1);
 	column_ids.reserve(probe_types.size());
 	for (column_t column_id = 0; column_id < probe_types.size(); column_id++) {
 		column_ids.emplace_back(column_id);
@@ -1068,76 +1075,46 @@ ProbeSpill::ProbeSpill(JoinHashTable &ht, ClientContext &context, const vector<L
 ProbeSpillLocalState ProbeSpill::RegisterThread() {
 	ProbeSpillLocalAppendState result;
 	lock_guard<mutex> guard(lock);
-	if (partitioned) {
-		local_partitions.emplace_back(global_partitions->CreateShared());
-		local_partition_append_states.emplace_back(make_uniq<PartitionedColumnDataAppendState>());
-		local_partitions.back()->InitializeAppendState(*local_partition_append_states.back());
+	local_partitions.emplace_back(global_partitions->CreateShared());
+	local_partition_append_states.emplace_back(make_uniq<PartitionedColumnDataAppendState>());
+	local_partitions.back()->InitializeAppendState(*local_partition_append_states.back());
 
-		result.local_partition = local_partitions.back().get();
-		result.local_partition_append_state = local_partition_append_states.back().get();
-	} else {
-		local_spill_collections.emplace_back(
-		    make_uniq<ColumnDataCollection>(BufferManager::GetBufferManager(context), probe_types));
-		local_spill_append_states.emplace_back(make_uniq<ColumnDataAppendState>());
-		local_spill_collections.back()->InitializeAppend(*local_spill_append_states.back());
-
-		result.local_spill_collection = local_spill_collections.back().get();
-		result.local_spill_append_state = local_spill_append_states.back().get();
-	}
+	result.local_partition = local_partitions.back().get();
+	result.local_partition_append_state = local_partition_append_states.back().get();
 	return result;
 }
 
 void ProbeSpill::Append(DataChunk &chunk, ProbeSpillLocalAppendState &local_state) {
-	if (partitioned) {
-		local_state.local_partition->Append(*local_state.local_partition_append_state, chunk);
-	} else {
-		local_state.local_spill_collection->Append(*local_state.local_spill_append_state, chunk);
-	}
+	local_state.local_partition->Append(*local_state.local_partition_append_state, chunk);
 }
 
 void ProbeSpill::Finalize() {
-	if (partitioned) {
-		D_ASSERT(local_partitions.size() == local_partition_append_states.size());
-		for (idx_t i = 0; i < local_partition_append_states.size(); i++) {
-			local_partitions[i]->FlushAppendState(*local_partition_append_states[i]);
-		}
-		for (auto &local_partition : local_partitions) {
-			global_partitions->Combine(*local_partition);
-		}
-		local_partitions.clear();
-		local_partition_append_states.clear();
-	} else {
-		if (local_spill_collections.empty()) {
-			global_spill_collection =
-			    make_uniq<ColumnDataCollection>(BufferManager::GetBufferManager(context), probe_types);
-		} else {
-			global_spill_collection = std::move(local_spill_collections[0]);
-			for (idx_t i = 1; i < local_spill_collections.size(); i++) {
-				global_spill_collection->Combine(*local_spill_collections[i]);
-			}
-		}
-		local_spill_collections.clear();
-		local_spill_append_states.clear();
+	D_ASSERT(local_partitions.size() == local_partition_append_states.size());
+	for (idx_t i = 0; i < local_partition_append_states.size(); i++) {
+		local_partitions[i]->FlushAppendState(*local_partition_append_states[i]);
+	}
+	for (auto &local_partition : local_partitions) {
+		global_partitions->Combine(*local_partition);
 	}
+	local_partitions.clear();
+	local_partition_append_states.clear();
 }
 
 void ProbeSpill::PrepareNextProbe() {
-	if (partitioned) {
-		auto &partitions = global_partitions->GetPartitions();
-		if (partitions.empty() || ht.partition_start == 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) {
-					global_spill_collection = std::move(partition);
-				} else {
-					global_spill_collection->Combine(*partition);
-				}
+	auto &partitions = global_partitions->GetPartitions();
+	if (partitions.empty() || ht.partition_start == 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) {
+				global_spill_collection = std::move(partition);
+			} else {
+				global_spill_collection->Combine(*partition);
 			}
 		}
 	}

package/src/duckdb/src/execution/nested_loop_join/nested_loop_join_inner.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/common/operator/comparison_operators.hpp"
+#include "duckdb/common/uhugeint.hpp"
 #include "duckdb/execution/nested_loop_join.hpp"
 
 namespace duckdb {
@@ -108,6 +109,9 @@ static idx_t NestedLoopJoinTypeSwitch(Vector &left, Vector &right, idx_t left_si
 	case PhysicalType::INT128:
 		return NLTYPE::template Operation<hugeint_t, OP>(left, right, left_size, right_size, lpos, rpos, lvector,
 		                                                 rvector, current_match_count);
+	case PhysicalType::UINT128:
+		return NLTYPE::template Operation<uhugeint_t, OP>(left, right, left_size, right_size, lpos, rpos, lvector,
+		                                                  rvector, current_match_count);
 	case PhysicalType::FLOAT:
 		return NLTYPE::template Operation<float, OP>(left, right, left_size, right_size, lpos, rpos, lvector, rvector,
 		                                             current_match_count);

package/src/duckdb/src/execution/nested_loop_join/nested_loop_join_mark.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/common/operator/comparison_operators.hpp"
+#include "duckdb/common/uhugeint.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/execution/nested_loop_join.hpp"
 
@@ -103,6 +104,8 @@ static void MarkJoinSwitch(Vector &left, Vector &right, idx_t lcount, idx_t rcou
 		return TemplatedMarkJoin<uint32_t, OP>(left, right, lcount, rcount, found_match);
 	case PhysicalType::UINT64:
 		return TemplatedMarkJoin<uint64_t, OP>(left, right, lcount, rcount, found_match);
+	case PhysicalType::UINT128:
+		return TemplatedMarkJoin<uhugeint_t, OP>(left, right, lcount, rcount, found_match);
 	case PhysicalType::FLOAT:
 		return TemplatedMarkJoin<float, OP>(left, right, lcount, rcount, found_match);
 	case PhysicalType::DOUBLE:
@@ -119,6 +122,7 @@ static void MarkJoinComparisonSwitch(Vector &left, Vector &right, idx_t lcount,
 	switch (left.GetType().InternalType()) {
 	case PhysicalType::STRUCT:
 	case PhysicalType::LIST:
+	case PhysicalType::ARRAY:
 		return MarkJoinNested(left, right, lcount, rcount, found_match, comparison_type);
 	default:
 		break;

package/src/duckdb/src/execution/operator/aggregate/aggregate_object.cpp

@@ -22,7 +22,8 @@ AggregateObject::AggregateObject(BoundAggregateExpression *aggr)
 
 AggregateObject::AggregateObject(BoundWindowExpression &window)
     : AggregateObject(*window.aggregate, window.bind_info.get(), window.children.size(),
-                      AlignValue(window.aggregate->state_size()), AggregateType::NON_DISTINCT,
+                      AlignValue(window.aggregate->state_size()),
+                      window.distinct ? AggregateType::DISTINCT : AggregateType::NON_DISTINCT,
                       window.return_type.InternalType(), window.filter_expr.get()) {
 }