duckdb 1.3.4 → 1.4.0

package/src/duckdb/src/execution/index/bound_index.cpp

@@ -117,14 +117,13 @@ void BoundIndex::ExecuteExpressions(DataChunk &input, DataChunk &result) {
 	executor.Execute(input, result);
 }
 
-unique_ptr<Expression> BoundIndex::BindExpression(unique_ptr<Expression> expr) {
-	if (expr->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		auto &bound_colref = expr->Cast<BoundColumnRefExpression>();
-		return make_uniq<BoundReferenceExpression>(expr->return_type, column_ids[bound_colref.binding.column_index]);
-	}
-	ExpressionIterator::EnumerateChildren(
-	    *expr, [this](unique_ptr<Expression> &expr) { expr = BindExpression(std::move(expr)); });
-	return expr;
+unique_ptr<Expression> BoundIndex::BindExpression(unique_ptr<Expression> root_expr) {
+	ExpressionIterator::VisitExpressionMutable<BoundColumnRefExpression>(
+	    root_expr, [&](BoundColumnRefExpression &bound_colref, unique_ptr<Expression> &expr) {
+		    expr =
+		        make_uniq<BoundReferenceExpression>(expr->return_type, column_ids[bound_colref.binding.column_index]);
+	    });
+	return root_expr;
 }
 
 bool BoundIndex::IndexIsUpdated(const vector<PhysicalIndex> &column_ids_p) const {
@@ -136,8 +135,12 @@ bool BoundIndex::IndexIsUpdated(const vector<PhysicalIndex> &column_ids_p) const
 	return false;
 }
 
-IndexStorageInfo BoundIndex::GetStorageInfo(const case_insensitive_map_t<Value> &options, const bool to_wal) {
-	throw NotImplementedException("The implementation of this index serialization does not exist.");
+IndexStorageInfo BoundIndex::SerializeToDisk(QueryContext context, const case_insensitive_map_t<Value> &options) {
+	throw NotImplementedException("The implementation of this index disk serialization does not exist.");
+}
+
+IndexStorageInfo BoundIndex::SerializeToWAL(const case_insensitive_map_t<Value> &options) {
+	throw NotImplementedException("The implementation of this index WAL serialization does not exist.");
 }
 
 string BoundIndex::AppendRowError(DataChunk &input, idx_t index) {
@@ -151,4 +154,30 @@ string BoundIndex::AppendRowError(DataChunk &input, idx_t index) {
 	return error;
 }
 
+void BoundIndex::ApplyBufferedAppends(const vector<LogicalType> &table_types, ColumnDataCollection &buffered_appends,
+                                      const vector<StorageIndex> &mapped_column_ids) {
+	IndexAppendInfo index_append_info(IndexAppendMode::INSERT_DUPLICATES, nullptr);
+
+	ColumnDataScanState state;
+	buffered_appends.InitializeScan(state);
+
+	DataChunk scan_chunk;
+	buffered_appends.InitializeScanChunk(scan_chunk);
+	DataChunk table_chunk;
+	table_chunk.InitializeEmpty(table_types);
+
+	while (buffered_appends.Scan(state, scan_chunk)) {
+		for (idx_t i = 0; i < scan_chunk.ColumnCount() - 1; i++) {
+			auto col_id = mapped_column_ids[i].GetPrimaryIndex();
+			table_chunk.data[col_id].Reference(scan_chunk.data[i]);
+		}
+		table_chunk.SetCardinality(scan_chunk.size());
+
+		auto error = Append(table_chunk, scan_chunk.data.back(), index_append_info);
+		if (error.HasError()) {
+			throw InternalException("error while applying buffered appends: " + error.Message());
+		}
+	}
+}
+
 } // namespace duckdb

package/src/duckdb/src/execution/index/fixed_size_allocator.cpp

@@ -55,7 +55,11 @@ IndexPointer FixedSizeAllocator::New() {
 		// Set and initialize the bitmask of the new buffer.
 		D_ASSERT(buffers.find(buffer_id) != buffers.end());
 		auto &buffer = buffers.find(buffer_id)->second;
-		ValidityMask mask(reinterpret_cast<validity_t *>(buffer->Get()), available_segments_per_buffer);
+
+		// Get a handle to the buffer's validity mask (offset 0).
+		SegmentHandle handle(*buffer, 0);
+		const auto bitmask_ptr = handle.GetPtr<validity_t>();
+		ValidityMask mask(bitmask_ptr, available_segments_per_buffer);
 		mask.SetAllValid(available_segments_per_buffer);
 	}
 
@@ -88,10 +92,15 @@ void FixedSizeAllocator::Free(const IndexPointer ptr) {
 	D_ASSERT(buffer_it != buffers.end());
 	auto &buffer = buffer_it->second;
 
-	auto bitmask_ptr = reinterpret_cast<validity_t *>(buffer->Get());
-	ValidityMask mask(bitmask_ptr, offset + 1); // FIXME
-	D_ASSERT(!mask.RowIsValid(offset));
-	mask.SetValid(offset);
+	{
+		// Get a handle to the buffer's validity mask (offset 0).
+		SegmentHandle handle(*buffer, 0);
+		const auto bitmask_ptr = handle.GetPtr<validity_t>();
+
+		ValidityMask mask(bitmask_ptr, offset + 1); // FIXME
+		D_ASSERT(!mask.RowIsValid(offset));
+		mask.SetValid(offset);
+	}
 
 	D_ASSERT(total_segment_count > 0);
 	D_ASSERT(buffer->segment_count > 0);
@@ -250,7 +259,7 @@ void FixedSizeAllocator::FinalizeVacuum() {
 	vacuum_buffers.clear();
 }
 
-IndexPointer FixedSizeAllocator::VacuumPointer(const IndexPointer ptr) {
+IndexPointer FixedSizeAllocator::VacuumPointer(const IndexPointer old_ptr) {
 	// we do not need to adjust the bitmask of the old buffer, because we will free the entire
 	// buffer after the vacuum operation
 
@@ -258,7 +267,10 @@ IndexPointer FixedSizeAllocator::VacuumPointer(const IndexPointer ptr) {
 	// new increases the allocation count, we need to counter that here
 	total_segment_count--;
 
-	memcpy(Get(new_ptr), Get(ptr), segment_size);
+	auto old_handle = GetHandle(old_ptr);
+	auto new_handle = GetHandle(new_ptr);
+
+	memcpy(new_handle.GetPtr(), old_handle.GetPtr(), segment_size);
 	return new_ptr;
 }
 
@@ -296,7 +308,10 @@ vector<IndexBufferInfo> FixedSizeAllocator::InitSerializationToWAL() {
 	vector<IndexBufferInfo> buffer_infos;
 	for (auto &buffer : buffers) {
 		buffer.second->SetAllocationSize(available_segments_per_buffer, segment_size, bitmask_offset);
-		buffer_infos.emplace_back(buffer.second->Get(), buffer.second->allocation_size);
+
+		// Get a handle to the buffer's memory (offset 0).
+		SegmentHandle handle(*buffer.second, 0);
+		buffer_infos.emplace_back(handle.GetPtr(), buffer.second->allocation_size);
 	}
 	return buffer_infos;
 }

package/src/duckdb/src/execution/index/fixed_size_buffer.cpp

@@ -14,9 +14,9 @@ PartialBlockForIndex::PartialBlockForIndex(PartialBlockState state, BlockManager
     : PartialBlock(state, block_manager, block_handle) {
 }
 
-void PartialBlockForIndex::Flush(const idx_t free_space_left) {
+void PartialBlockForIndex::Flush(QueryContext context, const idx_t free_space_left) {
 	FlushInternal(free_space_left);
-	block_handle = block_manager.ConvertToPersistent(state.block_id, std::move(block_handle));
+	block_handle = block_manager.ConvertToPersistent(context, state.block_id, std::move(block_handle));
 	Clear();
 }
 
@@ -36,22 +36,22 @@ constexpr idx_t FixedSizeBuffer::BASE[];
 constexpr uint8_t FixedSizeBuffer::SHIFT[];
 
 FixedSizeBuffer::FixedSizeBuffer(BlockManager &block_manager)
-    : block_manager(block_manager), segment_count(0), allocation_size(0), dirty(false), vacuum(false), block_pointer(),
-      block_handle(nullptr) {
+    : block_manager(block_manager), readers(0), segment_count(0), allocation_size(0), dirty(false), vacuum(false),
+      loaded(false), block_pointer(), block_handle(nullptr) {
 
 	auto &buffer_manager = block_manager.buffer_manager;
-	auto block_size = block_manager.GetBlockSize();
 	buffer_handle = buffer_manager.Allocate(MemoryTag::ART_INDEX, &block_manager, false);
 	block_handle = buffer_handle.GetBlockHandle();
 
 	// Zero-initialize the buffer as it might get serialized to storage.
+	auto block_size = block_manager.GetBlockSize();
 	memset(buffer_handle.Ptr(), 0, block_size);
 }
 
 FixedSizeBuffer::FixedSizeBuffer(BlockManager &block_manager, const idx_t segment_count, const idx_t allocation_size,
                                  const BlockPointer &block_pointer)
-    : block_manager(block_manager), segment_count(segment_count), allocation_size(allocation_size), dirty(false),
-      vacuum(false), block_pointer(block_pointer) {
+    : block_manager(block_manager), readers(0), segment_count(segment_count), allocation_size(allocation_size),
+      dirty(false), vacuum(false), loaded(false), block_pointer(block_pointer) {
 
 	D_ASSERT(block_pointer.IsValid());
 	block_handle = block_manager.RegisterBlock(block_pointer.block_id);
@@ -60,6 +60,8 @@ FixedSizeBuffer::FixedSizeBuffer(BlockManager &block_manager, const idx_t segmen
 
 FixedSizeBuffer::~FixedSizeBuffer() {
 	lock_guard<mutex> l(lock);
+	D_ASSERT(readers == 0);
+
 	if (InMemory()) {
 		// we can have multiple readers on a pinned block, and unpinning the buffer handle
 		// decrements the reader count on the underlying block handle (Destroy() unpins)
@@ -73,6 +75,7 @@ FixedSizeBuffer::~FixedSizeBuffer() {
 
 void FixedSizeBuffer::Serialize(PartialBlockManager &partial_block_manager, const idx_t available_segments,
                                 const idx_t segment_size, const idx_t bitmask_offset) {
+	D_ASSERT(readers == 0);
 
 	// Early-out, if the block is already on disk and not in memory.
 	if (!InMemory()) {
@@ -91,13 +94,15 @@ void FixedSizeBuffer::Serialize(PartialBlockManager &partial_block_manager, cons
 	D_ASSERT(segment_count != 0);
 	SetAllocationSize(available_segments, segment_size, bitmask_offset);
 
-	// the buffer is in memory, so we copied it onto a new buffer when pinning
+	// The buffer is in memory.
 	D_ASSERT(InMemory());
 	if (OnDisk()) {
+		// We copied it onto a new buffer when loading from disk.
 		block_manager.MarkBlockAsModified(block_pointer.block_id);
 	}
 
-	// now we write the changes, first get a partial block allocation
+	// Write the changes.
+	// First, we get a partial block allocation.
 	PartialBlockAllocation allocation =
 	    partial_block_manager.GetBlockAllocation(NumericCast<uint32_t>(allocation_size));
 	block_pointer.block_id = allocation.state.block_id;
@@ -106,46 +111,48 @@ void FixedSizeBuffer::Serialize(PartialBlockManager &partial_block_manager, cons
 	auto &buffer_manager = block_manager.buffer_manager;
 
 	if (allocation.partial_block) {
-		// copy to an existing partial block
+		// There is space, so we copy to an existing partial block.
 		D_ASSERT(block_pointer.offset > 0);
 		auto &p_block_for_index = allocation.partial_block->Cast<PartialBlockForIndex>();
 		auto dst_handle = buffer_manager.Pin(p_block_for_index.block_handle);
 		memcpy(dst_handle.Ptr() + block_pointer.offset, buffer_handle.Ptr(), allocation_size);
 
 	} else {
-		// create a new block that can potentially be used as a partial block
+		// No partial block available, so we create a new partial block.
 		D_ASSERT(block_handle);
 		D_ASSERT(!block_pointer.offset);
 		auto p_block_for_index = make_uniq<PartialBlockForIndex>(allocation.state, block_manager, block_handle);
 		allocation.partial_block = std::move(p_block_for_index);
 	}
 
-	// resetting this buffer
+	// We are done with this buffer.
+	// To use the fixed-size buffer again, we need to re-load it from disk.
 	buffer_handle.Destroy();
 
-	// register the partial block
+	// Register the partial block and the block handle.
 	partial_block_manager.RegisterPartialBlock(std::move(allocation));
 
 	block_handle = block_manager.RegisterBlock(block_pointer.block_id);
 	D_ASSERT(block_handle->BlockId() < MAXIMUM_BLOCK);
 
-	// we persist any changes, so the buffer is no longer dirty
+	// We persisted any changes, so the fixed-size buffer is no longer dirty.
 	dirty = false;
 }
 
-void FixedSizeBuffer::Pin() {
-	auto &buffer_manager = block_manager.buffer_manager;
+void FixedSizeBuffer::LoadFromDisk() {
 	D_ASSERT(block_pointer.IsValid());
 	D_ASSERT(block_handle && block_handle->BlockId() < MAXIMUM_BLOCK);
 	D_ASSERT(!dirty);
 
-	buffer_handle = buffer_manager.Pin(block_handle);
+	// Pin the partial block.
+	auto &buffer_manager = block_manager.buffer_manager;
+	auto pinned_buffer_handle = buffer_manager.Pin(block_handle);
 
 	// Copy the (partial) data into a new (not yet disk-backed) buffer handle.
 	shared_ptr<BlockHandle> new_block_handle;
 	auto new_buffer_handle = buffer_manager.Allocate(MemoryTag::ART_INDEX, &block_manager, false);
 	new_block_handle = new_buffer_handle.GetBlockHandle();
-	memcpy(new_buffer_handle.Ptr(), buffer_handle.Ptr() + block_pointer.offset, allocation_size);
+	memcpy(new_buffer_handle.Ptr(), pinned_buffer_handle.Ptr() + block_pointer.offset, allocation_size);
 
 	buffer_handle = std::move(new_buffer_handle);
 	block_handle = std::move(new_block_handle);
@@ -153,10 +160,12 @@ void FixedSizeBuffer::Pin() {
 
 uint32_t FixedSizeBuffer::GetOffset(const idx_t bitmask_count, const idx_t available_segments) {
 
-	// get the bitmask data
-	auto bitmask_ptr = reinterpret_cast<validity_t *>(Get());
+	// Get a handle to the buffer's validity mask (offset 0).
+	SegmentHandle handle(*this, 0);
+	const auto bitmask_ptr = handle.GetPtr<validity_t>();
+
 	ValidityMask mask(bitmask_ptr, available_segments);
-	auto data = mask.GetData();
+	const auto data = mask.GetData();
 
 	// fills up a buffer sequentially before searching for free bits
 	if (mask.RowIsValid(segment_count)) {
@@ -208,8 +217,11 @@ void FixedSizeBuffer::SetAllocationSize(const idx_t available_segments, const id
 
 	// We traverse from the back. A binary search would be faster.
 	// However, buffers are often (almost) full, so the overhead is acceptable.
-	auto bitmask_ptr = reinterpret_cast<validity_t *>(Get());
-	ValidityMask mask(bitmask_ptr, available_segments);
+
+	// Get a handle to the buffer's validity mask (offset 0).
+	SegmentHandle handle(*this, 0);
+	const auto bitmask_ptr = handle.GetPtr<validity_t>();
+	const ValidityMask mask(bitmask_ptr, available_segments);
 
 	auto max_offset = available_segments;
 	for (idx_t i = available_segments; i > 0; i--) {

package/src/duckdb/src/execution/index/unbound_index.cpp

@@ -1,15 +1,13 @@
 #include "duckdb/execution/index/unbound_index.hpp"
+
+#include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/parser/parsed_data/create_index_info.hpp"
-#include "duckdb/storage/table_io_manager.hpp"
 #include "duckdb/storage/block_manager.hpp"
 #include "duckdb/storage/index_storage_info.hpp"
+#include "duckdb/storage/table_io_manager.hpp"
 
 namespace duckdb {
 
-//-------------------------------------------------------------------------------
-// Unbound index
-//-------------------------------------------------------------------------------
-
 UnboundIndex::UnboundIndex(unique_ptr<CreateInfo> create_info, IndexStorageInfo storage_info_p,
                            TableIOManager &table_io_manager, AttachedDatabase &db)
     : Index(create_info->Cast<CreateIndexInfo>().column_ids, table_io_manager, db), create_info(std::move(create_info)),
@@ -20,7 +18,7 @@ UnboundIndex::UnboundIndex(unique_ptr<CreateInfo> create_info, IndexStorageInfo
 		auto &info = storage_info.allocator_infos[info_idx];
 		for (idx_t buffer_idx = 0; buffer_idx < info.buffer_ids.size(); buffer_idx++) {
 			if (info.buffer_ids[buffer_idx] > idx_t(MAX_ROW_ID)) {
-				throw InternalException("Found invalid buffer ID in UnboundIndex constructor");
+				throw InternalException("found invalid buffer ID in UnboundIndex constructor");
 			}
 		}
 	}
@@ -37,4 +35,26 @@ void UnboundIndex::CommitDrop() {
 	}
 }
 
+void UnboundIndex::BufferChunk(DataChunk &chunk, Vector &row_ids, const vector<StorageIndex> &mapped_column_ids_p) {
+	D_ASSERT(!column_ids.empty());
+	auto types = chunk.GetTypes();
+	types.push_back(LogicalType::ROW_TYPE);
+
+	if (!buffered_appends) {
+		auto &allocator = Allocator::Get(db);
+		buffered_appends = make_uniq<ColumnDataCollection>(allocator, types);
+		mapped_column_ids = mapped_column_ids_p;
+	}
+	D_ASSERT(mapped_column_ids == mapped_column_ids_p);
+
+	DataChunk combined_chunk;
+	combined_chunk.InitializeEmpty(types);
+	for (idx_t i = 0; i < chunk.ColumnCount(); i++) {
+		combined_chunk.data[i].Reference(chunk.data[i]);
+	}
+	combined_chunk.data.back().Reference(row_ids);
+	combined_chunk.SetCardinality(chunk.size());
+	buffered_appends->Append(combined_chunk);
+}
+
 } // namespace duckdb

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

@@ -6,6 +6,8 @@
 #include "duckdb/execution/ht_entry.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/main/settings.hpp"
+#include "duckdb/logging/log_manager.hpp"
 
 namespace duckdb {
 
@@ -19,7 +21,7 @@ JoinHashTable::SharedState::SharedState()
 }
 
 JoinHashTable::ProbeState::ProbeState()
-    : SharedState(), ht_offsets_v(LogicalType::UBIGINT), hashes_dense_v(LogicalType::HASH),
+    : SharedState(), ht_offsets_and_salts_v(LogicalType::UBIGINT), hashes_dense_v(LogicalType::HASH),
       non_empty_sel(STANDARD_VECTOR_SIZE) {
 }
 
@@ -75,7 +77,7 @@ JoinHashTable::JoinHashTable(ClientContext &context_p, const PhysicalOperator &o
 		layout_types.emplace_back(LogicalType::BOOLEAN);
 	}
 	layout_types.emplace_back(LogicalType::HASH);
-	layout->Initialize(layout_types, false);
+	layout->Initialize(layout_types, TupleDataValidityType::CAN_HAVE_NULL_VALUES);
 	layout_ptr = std::move(layout);
 
 	// Initialize the row matcher that are used for filtering during the probing only if there are non-equality
@@ -109,8 +111,7 @@ JoinHashTable::JoinHashTable(ClientContext &context_p, const PhysicalOperator &o
 	memset(dead_end.get(), 0, layout_ptr->GetRowWidth());
 
 	if (join_type == JoinType::SINGLE) {
-		auto &config = ClientConfig::GetConfig(context);
-		single_join_error_on_multiple_rows = config.scalar_subquery_error_on_multiple_rows;
+		single_join_error_on_multiple_rows = DBConfig::GetSetting<ScalarSubqueryErrorOnMultipleRowsSetting>(context);
 	}
 
 	InitializePartitionMasks();
@@ -168,18 +169,21 @@ static void AddPointerToCompare(JoinHashTable::ProbeState &state, const ht_entry
                                 idx_t row_ht_offset, idx_t &keys_to_compare_count, const idx_t &row_index) {
 
 	const auto row_ptr_insert_to = FlatVector::GetData<data_ptr_t>(pointers_result_v);
-	const auto ht_offsets = FlatVector::GetData<idx_t>(state.ht_offsets_v);
+	const auto ht_offsets_and_salts = FlatVector::GetData<idx_t>(state.ht_offsets_and_salts_v);
 
 	state.keys_to_compare_sel.set_index(keys_to_compare_count, row_index);
 	row_ptr_insert_to[row_index] = entry.GetPointer();
-	ht_offsets[row_index] = row_ht_offset;
+
+	// If the key does not match, we have to continue linear probing, we need to store the ht_offset and the salt
+	// for this element based on the row_index. We can't get the offset from the hash as we already might have
+	// some linear probing steps when arriving here.
+	ht_offsets_and_salts[row_index] = row_ht_offset | entry.GetSaltWithNulls();
 	keys_to_compare_count += 1;
 }
 
 template <bool USE_SALTS, bool HAS_SEL>
 static idx_t ProbeForPointersInternal(JoinHashTable::ProbeState &state, JoinHashTable &ht, ht_entry_t *entries,
-                                      Vector &hashes_v, Vector &pointers_result_v, const SelectionVector *row_sel,
-                                      idx_t &count) {
+                                      Vector &pointers_result_v, const SelectionVector *row_sel, idx_t &count) {
 
 	auto hashes_dense = FlatVector::GetData<hash_t>(state.hashes_dense_v);
 
@@ -187,11 +191,11 @@ static idx_t ProbeForPointersInternal(JoinHashTable::ProbeState &state, JoinHash
 
 	for (idx_t i = 0; i < count; i++) {
 
-		auto row_hash = hashes_dense[i]; // hashes has been flattened before -> always access dense
+		auto row_hash = hashes_dense[i]; // hashes have been flattened before -> always access dense
 		auto row_ht_offset = row_hash & ht.bitmask;
 
 		if (USE_SALTS) {
-			// increment the ht_offset of the entry as long as next entry is occupied and salt does not match
+			// increment the ht_offset of the entry as long as the next entry is occupied and salt does not match
 			while (true) {
 				const ht_entry_t entry = entries[row_ht_offset];
 				const bool occupied = entry.IsOccupied();
@@ -211,7 +215,7 @@ static idx_t ProbeForPointersInternal(JoinHashTable::ProbeState &state, JoinHash
 					break;
 				}
 
-				// full and salt does not match -> continue probing
+				// full and salt do not match -> continue probing
 				IncrementAndWrap(row_ht_offset, ht.bitmask);
 			}
 		} else {
@@ -235,14 +239,12 @@ static idx_t ProbeForPointersInternal(JoinHashTable::ProbeState &state, JoinHash
 ///	   -> match, add to compare sel and increase found count
 template <bool USE_SALTS>
 static idx_t ProbeForPointers(JoinHashTable::ProbeState &state, JoinHashTable &ht, ht_entry_t *entries,
-                              Vector &hashes_v, Vector &pointers_result_v, const SelectionVector *row_sel, idx_t count,
+                              Vector &pointers_result_v, const SelectionVector *row_sel, idx_t count,
                               const bool has_row_sel) {
 	if (has_row_sel) {
-		return ProbeForPointersInternal<USE_SALTS, true>(state, ht, entries, hashes_v, pointers_result_v, row_sel,
-		                                                 count);
+		return ProbeForPointersInternal<USE_SALTS, true>(state, ht, entries, pointers_result_v, row_sel, count);
 	} else {
-		return ProbeForPointersInternal<USE_SALTS, false>(state, ht, entries, hashes_v, pointers_result_v, row_sel,
-		                                                  count);
+		return ProbeForPointersInternal<USE_SALTS, false>(state, ht, entries, pointers_result_v, row_sel, count);
 	}
 }
 
@@ -254,14 +256,10 @@ static void GetRowPointersInternal(DataChunk &keys, TupleDataChunkState &key_sta
                                    ht_entry_t *entries, Vector &pointers_result_v, SelectionVector &match_sel,
                                    bool has_row_sel) {
 
-	// in case of a hash collision, we need this information to correctly retrieve the salt of this hash
-	bool uses_unified = false;
-	UnifiedVectorFormat hashes_unified_v;
-
 	// densify hashes: If there is no sel, flatten the hashes, else densify via UnifiedVectorFormat
 	if (has_row_sel) {
+		UnifiedVectorFormat hashes_unified_v;
 		hashes_v.ToUnifiedFormat(count, hashes_unified_v);
-		uses_unified = true;
 
 		auto hashes_unified = UnifiedVectorFormat::GetData<hash_t>(hashes_unified_v);
 		auto hashes_dense = FlatVector::GetData<idx_t>(state.hashes_dense_v);
@@ -282,8 +280,8 @@ static void GetRowPointersInternal(DataChunk &keys, TupleDataChunkState &key_sta
 	idx_t elements_to_probe_count = count;
 
 	do {
-		const idx_t keys_to_compare_count = ProbeForPointers<USE_SALTS>(state, ht, entries, hashes_v, pointers_result_v,
-		                                                                row_sel, elements_to_probe_count, has_row_sel);
+		const idx_t keys_to_compare_count = ProbeForPointers<USE_SALTS>(state, ht, entries, pointers_result_v, row_sel,
+		                                                                elements_to_probe_count, has_row_sel);
 
 		// if there are no keys to compare, we are done
 		if (keys_to_compare_count == 0) {
@@ -292,9 +290,9 @@ static void GetRowPointersInternal(DataChunk &keys, TupleDataChunkState &key_sta
 
 		// Perform row comparisons, after Match function call salt_match_sel will point to the keys that match
 		keys_no_match_count = 0;
-		const idx_t keys_match_count = ht.row_matcher_build.Match(
-		    keys, key_state.vector_data, state.keys_to_compare_sel, keys_to_compare_count, *ht.layout_ptr,
-		    pointers_result_v, &state.keys_no_match_sel, keys_no_match_count);
+		const idx_t keys_match_count =
+		    ht.row_matcher_build.Match(keys, key_state.vector_data, state.keys_to_compare_sel, keys_to_compare_count,
+		                               pointers_result_v, &state.keys_no_match_sel, keys_no_match_count);
 
 		D_ASSERT(keys_match_count + keys_no_match_count == keys_to_compare_count);
 
@@ -305,37 +303,21 @@ static void GetRowPointersInternal(DataChunk &keys, TupleDataChunkState &key_sta
 			match_count++;
 		}
 
-		// Linear probing for collisions: Move to the next entry in the HT
-		auto hashes_unified = UnifiedVectorFormat::GetData<hash_t>(hashes_unified_v);
-		auto hashes_dense = FlatVector::GetData<hash_t>(state.hashes_dense_v);
-		auto ht_offsets = FlatVector::GetData<idx_t>(state.ht_offsets_v);
+		const auto ht_offsets_and_salts = FlatVector::GetData<idx_t>(state.ht_offsets_and_salts_v);
+		const auto hashes_dense = FlatVector::GetData<hash_t>(state.hashes_dense_v);
 
+		// For all the non-matches, increment the offset to continue probing but keep the salt intact
 		for (idx_t i = 0; i < keys_no_match_count; i++) {
 			const auto row_index = state.keys_no_match_sel.get_index(i);
-			// The ProbeForPointers function calculates the ht_offset from the hash; therefore, we have to write the
-			// new offset into the hashes_v; otherwise the next iteration will start at the old position. This might
-			// seem as an overhead but assures that the first call of ProbeForPointers is optimized as conceding
-			// calls are unlikely (Max 1-(65535/65536)^VectorSize = 3.1%)
-			auto ht_offset = ht_offsets[row_index];
-			IncrementAndWrap(ht_offset, ht.bitmask);
-
-			// Get original hash from unified vector format to extract the salt if hashes_dense was populated that way
-			hash_t hash;
-			if (uses_unified) {
-				const auto uvf_index = hashes_unified_v.sel->get_index(row_index);
-				hash = hashes_unified[uvf_index];
-			} else {
-				hash = hashes_dense[row_index];
-			}
-
-			const auto offset_and_salt = ht_offset | (hash & ht_entry_t::SALT_MASK);
-
-			hashes_dense[i] = offset_and_salt; // populate dense again
+			auto ht_offset_and_salt = ht_offsets_and_salts[row_index];
+			IncrementAndWrap(ht_offset_and_salt, ht.bitmask | ht_entry_t::SALT_MASK);
+			hashes_dense[i] = ht_offset_and_salt; // populate dense again
 		}
 
 		// in the next interation, we have a selection vector with the keys that do not match
 		row_sel = &state.keys_no_match_sel;
 		has_row_sel = true;
+
 		elements_to_probe_count = keys_no_match_count;
 
 	} while (DUCKDB_UNLIKELY(keys_no_match_count > 0));
@@ -562,9 +544,9 @@ static inline void PerformKeyComparison(JoinHashTable::InsertState &state, JoinH
 	}
 
 	// Perform row comparisons
-	key_match_count = ht.row_matcher_build.Match(state.lhs_data, state.chunk_state.vector_data, state.key_match_sel,
-	                                             count, *ht.layout_ptr, state.rhs_row_locations,
-	                                             &state.keys_no_match_sel, key_no_match_count);
+	key_match_count =
+	    ht.row_matcher_build.Match(state.lhs_data, state.chunk_state.vector_data, state.key_match_sel, count,
+	                               state.rhs_row_locations, &state.keys_no_match_sel, key_no_match_count);
 
 	D_ASSERT(key_match_count + key_no_match_count == count);
 }
@@ -611,6 +593,8 @@ static void InsertHashesLoop(atomic<ht_entry_t> entries[], Vector &row_locations
 	D_ASSERT(hashes_v.GetType().id() == LogicalType::HASH);
 	ApplyBitmaskAndGetSaltBuild(hashes_v, state.salt_v, count, ht.bitmask);
 
+	const auto &layout = data_collection.GetLayout();
+
 	// 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);
@@ -623,6 +607,9 @@ static void InsertHashesLoop(atomic<ht_entry_t> entries[], Vector &row_locations
 	idx_t remaining_count = count;
 	const auto *remaining_sel = FlatVector::IncrementalSelectionVector();
 
+	const auto all_valid = layout.AllValid();
+	const auto column_count = layout.ColumnCount();
+
 	if (PropagatesBuildSide(ht.join_type)) {
 		// if we propagate the build side, we may have added rows with NULL keys to the HT
 		// these may need to be filtered out depending on the comparison type (exactly like PrepareKeys does)
@@ -639,7 +626,12 @@ 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], count).RowIsValidUnsafe(col_idx)) {
+				const auto valid =
+				    all_valid ||
+				    ValidityBytes::RowIsValid(
+				        ValidityBytes(lhs_row_locations[idx], column_count).GetValidityEntryUnsafe(entry_idx),
+				        idx_in_entry);
+				if (valid) {
 					state.remaining_sel.set_index(new_remaining_count++, idx);
 				}
 			}
@@ -736,6 +728,11 @@ void JoinHashTable::AllocatePointerTable() {
 	capacity = PointerTableCapacity(Count());
 	D_ASSERT(IsPowerOfTwo(capacity));
 
+	constexpr uint64_t MAX_HASHTABLE_CAPACITY = (1ULL << 48) - 1;
+	if (capacity >= MAX_HASHTABLE_CAPACITY) {
+		throw InternalException("Hashtable capacity exceeds 48-bit limit (2^48 - 1)");
+	}
+
 	if (hash_map.get()) {
 		// There is already a hash map
 		auto current_capacity = hash_map.GetSize() / sizeof(ht_entry_t);
@@ -898,8 +895,8 @@ idx_t ScanStructure::ResolvePredicates(DataChunk &keys, SelectionVector &match_s
 
 		// we need to only use the vectors with the indices of the columns that are used in the probe phase, namely
 		// the non-equality columns
-		return matcher->Match(keys, key_state.vector_data, match_sel, this->count, *ht.layout_ptr, pointers,
-		                      no_match_sel, no_match_count, ht.non_equality_predicate_columns);
+		return matcher->Match(keys, key_state.vector_data, match_sel, this->count, pointers, no_match_sel,
+		                      no_match_count);
 	} else {
 		// no match sel is the opposite of match sel
 		return this->count;

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

@@ -156,6 +156,9 @@ idx_t NestedLoopJoinComparisonSwitch(Vector &left, Vector &right, idx_t left_siz
 	case ExpressionType::COMPARE_DISTINCT_FROM:
 		return NestedLoopJoinTypeSwitch<NLTYPE, DistinctFrom>(left, right, left_size, right_size, lpos, rpos, lvector,
 		                                                      rvector, current_match_count);
+	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
+		return NestedLoopJoinTypeSwitch<NLTYPE, NotDistinctFrom>(left, right, left_size, right_size, lpos, rpos,
+		                                                         lvector, rvector, current_match_count);
 	default:
 		throw NotImplementedException("Unimplemented comparison type for join!");
 	}

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

@@ -68,12 +68,14 @@ DistinctAggregateState::DistinctAggregateState(const DistinctAggregateData &data
 }
 
 //! Persistent + shared (read-only) data for the distinct aggregates
-DistinctAggregateData::DistinctAggregateData(const DistinctAggregateCollectionInfo &info)
-    : DistinctAggregateData(info, {}, nullptr) {
+DistinctAggregateData::DistinctAggregateData(const DistinctAggregateCollectionInfo &info,
+                                             TupleDataValidityType distinct_validity)
+    : DistinctAggregateData(info, {}, nullptr, distinct_validity) {
 }
 
 DistinctAggregateData::DistinctAggregateData(const DistinctAggregateCollectionInfo &info, const GroupingSet &groups,
-                                             const vector<unique_ptr<Expression>> *group_expressions)
+                                             const vector<unique_ptr<Expression>> *group_expressions,
+                                             TupleDataValidityType distinct_validity)
     : info(info) {
 	grouped_aggregate_data.resize(info.table_count);
 	radix_tables.resize(info.table_count);
@@ -103,7 +105,7 @@ DistinctAggregateData::DistinctAggregateData(const DistinctAggregateCollectionIn
 		grouped_aggregate_data[table_idx] = make_uniq<GroupedAggregateData>();
 		grouped_aggregate_data[table_idx]->InitializeDistinct(info.aggregates[i], group_expressions);
 		radix_tables[table_idx] =
-		    make_uniq<RadixPartitionedHashTable>(grouping_set, *grouped_aggregate_data[table_idx]);
+		    make_uniq<RadixPartitionedHashTable>(grouping_set, *grouped_aggregate_data[table_idx], distinct_validity);
 
 		// Fill the chunk_types (only contains the payload of the distinct aggregates)
 		vector<LogicalType> chunk_types;