duckdb 1.3.3-dev0.0 → 1.3.3-dev4.0

package/src/duckdb/src/include/duckdb/execution/index/art/node256.hpp

@@ -33,21 +33,41 @@ private:
 	Node children[CAPACITY];
 
 public:
-	//! Get a new Node256 and initialize it.
-	static Node256 &New(ART &art, Node &node);
-	//! Free the node and its children.
-	static void Free(ART &art, Node &node);
+	//! Get a new Node256 handle and initialize the Node256.
+	static NodeHandle<Node256> New(ART &art, Node &node) {
+		node = Node::GetAllocator(art, NODE_256).New();
+		node.SetMetadata(static_cast<uint8_t>(NODE_256));
+
+		NodeHandle<Node256> handle(art, node);
+		auto &n = handle.Get();
+
+		// Reset the node (count and children).
+		n.count = 0;
+		for (uint16_t i = 0; i < CAPACITY; i++) {
+			n.children[i].Clear();
+		}
+
+		return handle;
+	}
 
 	//! Insert a child at byte.
 	static void InsertChild(ART &art, Node &node, const uint8_t byte, const Node child);
 	//! Delete the child at byte.
 	static void DeleteChild(ART &art, Node &node, const uint8_t byte);
 	//! Replace the child at byte.
-	void ReplaceChild(const uint8_t byte, const Node child);
+	void ReplaceChild(const uint8_t byte, const Node child) {
+		D_ASSERT(count > SHRINK_THRESHOLD);
+		auto status = children[byte].GetGateStatus();
+		children[byte] = child;
+		if (status == GateStatus::GATE_SET && child.HasMetadata()) {
+			children[byte].SetGateStatus(status);
+		}
+	}
 
 public:
 	template <class F, class NODE>
 	static void Iterator(NODE &n, F &&lambda) {
+		D_ASSERT(n.count);
 		for (idx_t i = 0; i < CAPACITY; i++) {
 			if (n.children[i].HasMetadata()) {
 				lambda(n.children[i]);
@@ -56,7 +76,10 @@ public:
 	}
 
 	template <class NODE>
-	static unsafe_optional_ptr<Node> GetChild(NODE &n, const uint8_t byte) {
+	static unsafe_optional_ptr<Node> GetChild(NODE &n, const uint8_t byte, const bool unsafe = false) {
+		if (unsafe) {
+			return &n.children[byte];
+		}
 		if (n.children[byte].HasMetadata()) {
 			return &n.children[byte];
 		}
@@ -92,11 +115,10 @@ public:
 			}
 		}
 
-		count = 0;
 		return NodeChildren(bytes, children_ptr);
 	}
 
 private:
-	static Node256 &GrowNode48(ART &art, Node &node256, Node &node48);
+	static void GrowNode48(ART &art, Node &node256, Node &node48);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/index/art/node256_leaf.hpp

@@ -33,8 +33,8 @@ private:
 	validity_t mask[CAPACITY / sizeof(validity_t)];
 
 public:
-	//! Get a new Node256Leaf and initialize it.
-	static Node256Leaf &New(ART &art, Node &node);
+	//! Get a new Node256Leaf handle and initialize the leaf.
+	static NodeHandle<Node256Leaf> New(ART &art, Node &node);
 
 	//! Insert a byte.
 	static void InsertByte(ART &art, Node &node, const uint8_t byte);
@@ -42,15 +42,18 @@ public:
 	static void DeleteByte(ART &art, Node &node, const uint8_t byte);
 
 	//! Returns true, if the byte exists, else false.
-	bool HasByte(uint8_t &byte);
+	bool HasByte(const uint8_t byte);
+
 	//! Returns a pointer to the bytes in the leaf.
-	//! The pointer's data is valid as long as the arena is valid.
+	//! The pointer data is valid as long as the arena is valid.
 	array_ptr<uint8_t> GetBytes(ArenaAllocator &arena);
+
 	//! Get the first byte greater or equal to the byte.
+	//! Returns true, if such a byte exists, else false.
 	bool GetNextByte(uint8_t &byte);
 
 private:
-	static Node256Leaf &GrowNode15Leaf(ART &art, Node &node256_leaf, Node &node15_leaf);
+	static void GrowNode15Leaf(ART &art, Node &node256_leaf, Node &node15_leaf);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/index/art/node48.hpp

@@ -38,21 +38,45 @@ private:
 	Node children[CAPACITY];
 
 public:
-	//! Get a new Node48 and initialize it.
-	static Node48 &New(ART &art, Node &node);
-	//! Free the node and its children.
-	static void Free(ART &art, Node &node);
+	//! Get a new Node48 handle and initialize the Node48.
+	static NodeHandle<Node48> New(ART &art, Node &node) {
+		node = Node::GetAllocator(art, NODE_48).New();
+		node.SetMetadata(static_cast<uint8_t>(NODE_48));
+
+		NodeHandle<Node48> handle(art, node);
+		auto &n = handle.Get();
+
+		// Reset the node (count and child_index).
+		n.count = 0;
+		for (uint16_t i = 0; i < Node256::CAPACITY; i++) {
+			n.child_index[i] = EMPTY_MARKER;
+		}
+		// Zero-initialize the node.
+		for (uint8_t i = 0; i < CAPACITY; i++) {
+			n.children[i].Clear();
+		}
+
+		return handle;
+	}
 
 	//! Insert a child at byte.
 	static void InsertChild(ART &art, Node &node, const uint8_t byte, const Node child);
 	//! Delete the child at byte.
 	static void DeleteChild(ART &art, Node &node, const uint8_t byte);
 	//! Replace the child at byte.
-	void ReplaceChild(const uint8_t byte, const Node child);
+	void ReplaceChild(const uint8_t byte, const Node child) {
+		D_ASSERT(count >= SHRINK_THRESHOLD);
+		auto status = children[child_index[byte]].GetGateStatus();
+		children[child_index[byte]] = child;
+		if (status == GateStatus::GATE_SET && child.HasMetadata()) {
+			children[child_index[byte]].SetGateStatus(status);
+		}
+	}
 
 public:
 	template <class F, class NODE>
 	static void Iterator(NODE &n, F &&lambda) {
+		D_ASSERT(n.count);
 		for (idx_t i = 0; i < Node256::CAPACITY; i++) {
 			if (n.child_index[i] != EMPTY_MARKER) {
 				lambda(n.children[n.child_index[i]]);
@@ -61,8 +85,11 @@ public:
 	}
 
 	template <class NODE>
-	static unsafe_optional_ptr<Node> GetChild(NODE &n, const uint8_t byte) {
+	static unsafe_optional_ptr<Node> GetChild(NODE &n, const uint8_t byte, const bool unsafe = false) {
 		if (n.child_index[byte] != Node48::EMPTY_MARKER) {
+			if (!unsafe && !n.children[n.child_index[byte]].HasMetadata()) {
+				throw InternalException("empty child for byte %d in Node48::GetChild", byte);
+			}
 			return &n.children[n.child_index[byte]];
 		}
 		return nullptr;
@@ -97,12 +124,12 @@ public:
 			}
 		}
 
-		count = 0;
 		return NodeChildren(bytes, children_ptr);
 	}
 
 private:
-	static Node48 &GrowNode16(ART &art, Node &node48, Node &node16);
-	static Node48 &ShrinkNode256(ART &art, Node &node48, Node &node256);
+	static void GrowNode16(ART &art, Node &node48, Node &node16);
+	//! We shrink at <= Node256::SHRINK_THRESHOLD.
+	static void ShrinkNode256(ART &art, Node &node48, Node &node256);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/index/art/prefix.hpp

@@ -40,28 +40,15 @@ public:
 	static inline uint8_t Count(const ART &art) {
 		return art.prefix_count;
 	}
-	static optional_idx GetMismatchWithKey(ART &art, const Node &node, const ARTKey &key, idx_t &depth);
 	static uint8_t GetByte(const ART &art, const Node &node, const uint8_t pos);
 
 public:
 	//! Get a new list of prefix nodes. The node reference holds the child of the last prefix node.
 	static void New(ART &art, reference<Node> &ref, const ARTKey &key, const idx_t depth, idx_t count);
 
-	//! Free the prefix and its child.
-	static void Free(ART &art, Node &node);
-
-	//! Concatenates parent -> byte -> child. Special-handling, if
-	//! 1. the byte was in a gate node.
-	//! 2. the byte was in PREFIX_INLINED.
-	static void Concat(ART &art, Node &parent, uint8_t byte, const GateStatus old_status, const Node &child,
-	                   const GateStatus status);
-
-	//! Traverse a prefix and a key until
-	//! 1. a non-prefix node.
-	//! 2. a mismatching byte.
-	//! Early-out, if the next prefix is a gate node.
-	static optional_idx Traverse(ART &art, reference<const Node> &node, const ARTKey &key, idx_t &depth);
-	static optional_idx TraverseMutable(ART &art, reference<Node> &node, const ARTKey &key, idx_t &depth);
+	//! Concatenates parent -> prev_node4 -> child.
+	static void Concat(ART &art, Node &parent, Node &node4, const Node child, uint8_t byte,
+	                   const GateStatus node4_status);
 
 	//! Removes up to pos bytes from the prefix.
 	//! Shifts all subsequent bytes by pos. Frees empty nodes.
@@ -80,13 +67,15 @@ public:
 	static void TransformToDeprecated(ART &art, Node &node, unsafe_unique_ptr<FixedSizeAllocator> &allocator);
 
 private:
-	static Prefix NewInternal(ART &art, Node &node, const data_ptr_t data, const uint8_t count, const idx_t offset,
-	                          const NType type);
+	static Prefix NewInternal(ART &art, Node &node, const data_ptr_t data, const uint8_t count, const idx_t offset);
 
 	static Prefix GetTail(ART &art, const Node &node);
 
-	static void ConcatGate(ART &art, Node &parent, uint8_t byte, const Node &child);
-	static void ConcatChildIsGate(ART &art, Node &parent, uint8_t byte, const Node &child);
+	static void ConcatInternal(ART &art, Node &parent, Node &node4, const Node child, uint8_t byte,
+	                           const bool inside_gate);
+	static void ConcatNode4WasGate(ART &art, Node &node4, const Node child, uint8_t byte);
+	static void ConcatChildIsGate(ART &art, Node &parent, Node &node4, const Node child, uint8_t byte);
+	static void ConcatOutsideGate(ART &art, Node &parent, Node &node4, const Node child, uint8_t byte);
 
 	Prefix Append(ART &art, const uint8_t byte);
 	void Append(ART &art, Node other);

package/src/duckdb/src/include/duckdb/execution/index/bound_index.hpp

@@ -60,19 +60,18 @@ public:
 	//! The index constraint type
 	IndexConstraintType index_constraint_type;
 
+	vector<unique_ptr<Expression>> unbound_expressions;
+
 public:
 	bool IsBound() const override {
 		return true;
 	}
-
 	const string &GetIndexType() const override {
 		return index_type;
 	}
-
 	const string &GetIndexName() const override {
 		return name;
 	}
-
 	IndexConstraintType GetConstraintType() const override {
 		return index_constraint_type;
 	}
@@ -143,8 +142,10 @@ public:
 	//! Returns true if the index is affected by updates on the specified column IDs, and false otherwise
 	bool IndexIsUpdated(const vector<PhysicalIndex> &column_ids) const;
 
-	//! Returns index storage serialization information.
-	virtual IndexStorageInfo GetStorageInfo(const case_insensitive_map_t<Value> &options, const bool to_wal);
+	//! Serializes index memory to disk and returns the index storage information.
+	virtual IndexStorageInfo SerializeToDisk(QueryContext context, const case_insensitive_map_t<Value> &options);
+	//! Serializes index memory to the WAL and returns the index storage information.
+	virtual IndexStorageInfo SerializeToWAL(const case_insensitive_map_t<Value> &options);
 
 	//! Execute the index expressions on an input chunk
 	void ExecuteExpressions(DataChunk &input, DataChunk &result);
@@ -154,7 +155,8 @@ public:
 	virtual string GetConstraintViolationMessage(VerifyExistenceType verify_type, idx_t failed_index,
 	                                             DataChunk &input) = 0;
 
-	vector<unique_ptr<Expression>> unbound_expressions;
+	void ApplyBufferedAppends(const vector<LogicalType> &table_types, ColumnDataCollection &buffered_appends,
+	                          const vector<StorageIndex> &mapped_column_ids);
 
 protected:
 	//! Lock used for any changes to the index

package/src/duckdb/src/include/duckdb/execution/index/fixed_size_allocator.hpp

@@ -43,30 +43,47 @@ public:
 	//! Free the segment of the IndexPointer
 	void Free(const IndexPointer ptr);
 
+	//! Get a segment handle.
+	inline SegmentHandle GetHandle(const IndexPointer ptr) {
+		D_ASSERT(ptr.GetOffset() < available_segments_per_buffer);
+
+		auto buffer_it = buffers.find(ptr.GetBufferId());
+		D_ASSERT(buffer_it != buffers.end());
+
+		auto offset = ptr.GetOffset() * segment_size + bitmask_offset;
+		auto &buffer = *buffer_it->second;
+		return SegmentHandle(buffer, offset);
+	}
+
 	//! Returns a pointer of type T to a segment. If dirty is false, then T must be a const class.
+	//! DEPRECATED. Use segment handles.
 	template <class T>
 	inline unsafe_optional_ptr<T> Get(const IndexPointer ptr, const bool dirty = true) {
 		return (T *)Get(ptr, dirty);
 	}
 
 	//! Returns the data_ptr_t to a segment, and sets the dirty flag of the buffer containing that segment.
+	//! DEPRECATED. Use segment handles.
 	inline data_ptr_t Get(const IndexPointer ptr, const bool dirty = true) {
 		D_ASSERT(ptr.GetOffset() < available_segments_per_buffer);
-		D_ASSERT(buffers.find(ptr.GetBufferId()) != buffers.end());
 
 		auto buffer_it = buffers.find(ptr.GetBufferId());
 		D_ASSERT(buffer_it != buffers.end());
-		auto buffer_ptr = buffer_it->second->Get(dirty);
-		return buffer_ptr + ptr.GetOffset() * segment_size + bitmask_offset;
+
+		auto offset = ptr.GetOffset() * segment_size + bitmask_offset;
+		auto buffer_ptr = buffer_it->second->GetDeprecated(dirty);
+		return buffer_ptr + offset;
 	}
 
 	//! Returns a pointer of type T to a segment, or nullptr, if the buffer is not in memory.
+	//! DEPRECATED. Use segment handles.
 	template <class T>
 	inline unsafe_optional_ptr<T> GetIfLoaded(const IndexPointer ptr) {
 		return (T *)GetIfLoaded(ptr);
 	}
 
 	//! Returns the data_ptr_t to a segment, or nullptr, if the buffer is not in memory.
+	//! DEPRECATED. Use segment handles.
 	inline data_ptr_t GetIfLoaded(const IndexPointer ptr) {
 		D_ASSERT(ptr.GetOffset() < available_segments_per_buffer);
 		D_ASSERT(buffers.find(ptr.GetBufferId()) != buffers.end());
@@ -76,7 +93,7 @@ public:
 			return nullptr;
 		}
 
-		auto buffer_ptr = buffer->Get();
+		auto buffer_ptr = buffer->GetDeprecated();
 		auto raw_ptr = buffer_ptr + ptr.GetOffset() * segment_size + bitmask_offset;
 		return raw_ptr;
 	}

package/src/duckdb/src/include/duckdb/execution/index/fixed_size_buffer.hpp

@@ -25,16 +25,16 @@ public:
 	~PartialBlockForIndex() override {};
 
 public:
-	void Flush(const idx_t free_space_left) override;
+	void Flush(QueryContext context, const idx_t free_space_left) override;
 	void Clear() override;
 	void Merge(PartialBlock &other, idx_t offset, idx_t other_size) override;
 };
 
 //! A fixed-size buffer holds fixed-size segments of data. It lazily deserializes a buffer, if on-disk and not
-//! yet in memory, and it only serializes dirty and non-written buffers to disk during
-//! serialization.
+//! in memory, and it only serializes dirty and non-written buffers to disk during serialization.
 class FixedSizeBuffer {
 	friend class FixedSizeAllocator;
+	friend class SegmentHandle;
 
 public:
 	//! Constants for fast offset calculations in the bitmask
@@ -51,11 +51,12 @@ public:
 	~FixedSizeBuffer();
 
 private:
-	//! Returns a pointer to the buffer in memory, and calls Deserialize, if the buffer is not in memory
-	data_ptr_t Get(const bool dirty_p = true) {
+	//! Returns a pointer to the buffer in memory, and calls Deserialize, if the buffer is not in memory.
+	//! DEPRECATED. Use segment handles.
+	data_ptr_t GetDeprecated(const bool dirty_p = true) {
 		lock_guard<mutex> l(lock);
 		if (!InMemory()) {
-			Pin();
+			LoadFromDisk();
 		}
 		if (dirty_p) {
 			dirty = dirty_p;
@@ -73,11 +74,12 @@ private:
 		return block_pointer.IsValid();
 	}
 
-	//! Serializes a buffer (if dirty or not on disk)
+	//! Serializes a buffer, if dirty or not on disk.
 	void Serialize(PartialBlockManager &partial_block_manager, const idx_t available_segments, const idx_t segment_size,
 	               const idx_t bitmask_offset);
-	//! Pin a buffer (if not in-memory)
-	void Pin();
+
+	//! Load a buffer from disk, if not in memory.
+	void LoadFromDisk();
 	//! Returns the first free offset in a bitmask
 	uint32_t GetOffset(const idx_t bitmask_count, const idx_t available_segments);
 	//! Sets the allocation size, if dirty
@@ -87,15 +89,20 @@ private:
 	//! Block manager of the database instance
 	BlockManager &block_manager;
 
+	//! The number of active segments.
+	atomic<idx_t> readers;
+
 	//! The number of allocated segments
 	idx_t segment_count;
 	//! The size of allocated memory in this buffer (necessary for copying while pinning)
 	idx_t allocation_size;
 
-	//! True: the in-memory buffer is no longer consistent with a (possibly existing) copy on disk
+	//! True: the in-memory buffer is no longer consistent with its optional copy on disk.
 	bool dirty;
-	//! True: can be vacuumed after the vacuum operation
+	//! True: can be vacuumed after the vacuum operation.
 	bool vacuum;
+	//! True: has been loaded from disk.
+	bool loaded;
 
 	//! Partial block id and offset
 	BlockPointer block_pointer;
@@ -107,4 +114,81 @@ private:
 	mutex lock;
 };
 
+class SegmentHandle {
+public:
+	SegmentHandle() = delete;
+	SegmentHandle(FixedSizeBuffer &buffer_p, const idx_t offset) : buffer_ptr(buffer_p) {
+		lock_guard<mutex> l(buffer_ptr->lock);
+
+		if (!buffer_ptr->InMemory() && !buffer_ptr->loaded) {
+			buffer_ptr->LoadFromDisk();
+		}
+		if (!buffer_ptr->InMemory() && buffer_ptr->loaded) {
+			buffer_ptr->block_manager.buffer_manager.Pin(buffer_ptr->block_handle);
+		}
+
+		ptr = buffer_ptr->buffer_handle.Ptr() + offset;
+		buffer_ptr->readers++;
+	}
+
+	~SegmentHandle() {
+		if (!buffer_ptr) {
+			return;
+		}
+		buffer_ptr->readers--;
+		buffer_ptr = nullptr;
+		ptr = nullptr;
+
+		// FIXME: Enable unpinning buffers with zero readers while preventing oscillation.
+		// FIXME: loaded must be set to true.
+	}
+
+	SegmentHandle(const SegmentHandle &) = delete;
+	SegmentHandle &operator=(const SegmentHandle &) = delete;
+
+	SegmentHandle(SegmentHandle &&other) noexcept : buffer_ptr(other.buffer_ptr), ptr(other.ptr) {
+		other.buffer_ptr = nullptr;
+		other.ptr = nullptr;
+	}
+	SegmentHandle &operator=(SegmentHandle &&other) noexcept {
+		if (this != &other) {
+			buffer_ptr = other.buffer_ptr;
+			ptr = other.ptr;
+			other.buffer_ptr = nullptr;
+			other.ptr = nullptr;
+		}
+		return *this;
+	}
+
+public:
+	template <class T>
+	const T &GetRef() const {
+		return *reinterpret_cast<const T *>(ptr);
+	}
+
+	template <class T>
+	T &GetRef() {
+		return *reinterpret_cast<T *>(ptr);
+	}
+
+	template <class T = data_t>
+	T *GetPtr() {
+		return reinterpret_cast<T *>(ptr);
+	}
+
+	template <class T = data_t>
+	const T *GetPtr() const {
+		return reinterpret_cast<T *>(ptr);
+	}
+
+	void MarkModified() {
+		lock_guard<mutex> l(buffer_ptr->lock);
+		buffer_ptr->dirty = true;
+	}
+
+private:
+	optional_ptr<FixedSizeBuffer> buffer_ptr;
+	data_ptr_t ptr;
+};
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/index/unbound_index.hpp

@@ -8,56 +8,67 @@
 
 #pragma once
 
-#include "duckdb/storage/index.hpp"
 #include "duckdb/parser/parsed_data/create_index_info.hpp"
+#include "duckdb/storage/index.hpp"
+#include "duckdb/storage/storage_index.hpp"
 
 namespace duckdb {
 
+class ColumnDataCollection;
+
 class UnboundIndex final : public Index {
 private:
-	// The create info of the index
+	//! The CreateInfo of the index.
 	unique_ptr<CreateInfo> create_info;
-
-	// The serialized storage info of the index
+	//! The serialized storage information of the index.
 	IndexStorageInfo storage_info;
+	//! Buffer for WAL replay appends.
+	unique_ptr<ColumnDataCollection> buffered_appends;
+	//! Maps the column IDs in the buffered appends to the table columns.
+	vector<StorageIndex> mapped_column_ids;
 
 public:
 	UnboundIndex(unique_ptr<CreateInfo> create_info, IndexStorageInfo storage_info, TableIOManager &table_io_manager,
 	             AttachedDatabase &db);
 
+public:
 	bool IsBound() const override {
 		return false;
 	}
-
 	const string &GetIndexType() const override {
 		return GetCreateInfo().index_type;
 	}
-
 	const string &GetIndexName() const override {
 		return GetCreateInfo().index_name;
 	}
-
 	IndexConstraintType GetConstraintType() const override {
 		return GetCreateInfo().constraint_type;
 	}
-
 	const CreateIndexInfo &GetCreateInfo() const {
 		return create_info->Cast<CreateIndexInfo>();
 	}
-
 	const IndexStorageInfo &GetStorageInfo() const {
 		return storage_info;
 	}
-
 	const vector<unique_ptr<ParsedExpression>> &GetParsedExpressions() const {
 		return GetCreateInfo().parsed_expressions;
 	}
-
 	const string &GetTableName() const {
 		return GetCreateInfo().table;
 	}
 
 	void CommitDrop() override;
+
+	void BufferChunk(DataChunk &chunk, Vector &row_ids, const vector<StorageIndex> &mapped_column_ids_p);
+	bool HasBufferedAppends() const {
+		return buffered_appends != nullptr;
+	}
+	ColumnDataCollection &GetBufferedAppends() const {
+		return *buffered_appends;
+	}
+	const vector<StorageIndex> &GetMappedColumnIds() const {
+		return mapped_column_ids;
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/join_hashtable.hpp

@@ -59,9 +59,14 @@ class JoinHashTable {
 public:
 	using ValidityBytes = TemplatedValidityMask<uint8_t>;
 
+#ifdef DUCKDB_HASH_ZERO
+	//! Verify salt when all hashes are 0
+	static constexpr const idx_t USE_SALT_THRESHOLD = 0;
+#else
 	//! only compare salts with the ht entries if the capacity is larger than 8192 so
 	//! that it does not fit into the CPU cache
 	static constexpr const idx_t USE_SALT_THRESHOLD = 8192;
+#endif
 
 	//! Scan structure that can be used to resume scans, as a single probe can
 	//! return 1024*N values (where N is the size of the HT). This is
@@ -149,7 +154,7 @@ public:
 	struct ProbeState : SharedState {
 		ProbeState();
 
-		Vector ht_offsets_v;
+		Vector ht_offsets_and_salts_v;
 		Vector hashes_dense_v;
 		SelectionVector non_empty_sel;
 	};

package/src/duckdb/src/include/duckdb/execution/operator/aggregate/distinct_aggregate_data.hpp

@@ -44,9 +44,10 @@ private:
 
 struct DistinctAggregateData {
 public:
-	explicit DistinctAggregateData(const DistinctAggregateCollectionInfo &info);
+	DistinctAggregateData(const DistinctAggregateCollectionInfo &info, TupleDataValidityType distinct_validity);
 	DistinctAggregateData(const DistinctAggregateCollectionInfo &info, const GroupingSet &groups,
-	                      const vector<unique_ptr<Expression>> *group_expressions);
+	                      const vector<unique_ptr<Expression>> *group_expressions,
+	                      TupleDataValidityType distinct_validity);
 	//! The data used by the hashtables
 	vector<unique_ptr<GroupedAggregateData>> grouped_aggregate_data;
 	//! The hashtables

package/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp

@@ -24,7 +24,8 @@ class PhysicalHashAggregate;
 struct HashAggregateGroupingData {
 public:
 	HashAggregateGroupingData(GroupingSet &grouping_set_p, const GroupedAggregateData &grouped_aggregate_data,
-	                          unique_ptr<DistinctAggregateCollectionInfo> &info);
+	                          unique_ptr<DistinctAggregateCollectionInfo> &info, TupleDataValidityType group_validity,
+	                          TupleDataValidityType distinct_validity);
 
 public:
 	RadixPartitionedHashTable table_data;
@@ -62,13 +63,16 @@ public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::HASH_GROUP_BY;
 
 public:
-	PhysicalHashAggregate(ClientContext &context, vector<LogicalType> types, vector<unique_ptr<Expression>> expressions,
+	PhysicalHashAggregate(PhysicalPlan &physical_plan, ClientContext &context, vector<LogicalType> types,
+	                      vector<unique_ptr<Expression>> expressions, idx_t estimated_cardinality);
+	PhysicalHashAggregate(PhysicalPlan &physical_plan, ClientContext &context, vector<LogicalType> types,
+	                      vector<unique_ptr<Expression>> expressions, vector<unique_ptr<Expression>> groups,
 	                      idx_t estimated_cardinality);
-	PhysicalHashAggregate(ClientContext &context, vector<LogicalType> types, vector<unique_ptr<Expression>> expressions,
-	                      vector<unique_ptr<Expression>> groups, idx_t estimated_cardinality);
-	PhysicalHashAggregate(ClientContext &context, vector<LogicalType> types, vector<unique_ptr<Expression>> expressions,
-	                      vector<unique_ptr<Expression>> groups, vector<GroupingSet> grouping_sets,
-	                      vector<unsafe_vector<idx_t>> grouping_functions, idx_t estimated_cardinality);
+	PhysicalHashAggregate(PhysicalPlan &physical_plan, ClientContext &context, vector<LogicalType> types,
+	                      vector<unique_ptr<Expression>> expressions, vector<unique_ptr<Expression>> groups,
+	                      vector<GroupingSet> grouping_sets, vector<unsafe_vector<idx_t>> grouping_functions,
+	                      idx_t estimated_cardinality, TupleDataValidityType group_validity,
+	                      TupleDataValidityType distinct_validity);
 
 	//! The grouping sets
 	GroupedAggregateData grouped_aggregate_data;
@@ -80,7 +84,7 @@ public:
 	//! A recreation of the input chunk, with nulls for everything that isnt a group
 	vector<LogicalType> input_group_types;
 
-	// Filters given to Sink and friends
+	//! Filters given to Sink and friends
 	unsafe_vector<idx_t> non_distinct_filter;
 	unsafe_vector<idx_t> distinct_filter;
 

package/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_partitioned_aggregate.hpp

@@ -24,7 +24,7 @@ public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::PARTITIONED_AGGREGATE;
 
 public:
-	PhysicalPartitionedAggregate(ClientContext &context, vector<LogicalType> types,
+	PhysicalPartitionedAggregate(PhysicalPlan &physical_plan, ClientContext &context, vector<LogicalType> types,
 	                             vector<unique_ptr<Expression>> expressions, vector<unique_ptr<Expression>> groups,
 	                             vector<column_t> partitions, idx_t estimated_cardinality);