duckdb 0.8.2-dev87.0 → 0.9.1-dev0.0

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

@@ -7,78 +7,83 @@
 //===----------------------------------------------------------------------===//
 #pragma once
 
+#include "duckdb/execution/index/fixed_size_allocator.hpp"
+#include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/node.hpp"
 
 namespace duckdb {
 
 // classes
 class ARTKey;
-class PrefixSegment;
 
+//! The Prefix is a special node type that contains up to PREFIX_SIZE bytes, and one byte for the count,
+//! and a Node pointer. This pointer either points to a prefix node or another Node.
 class Prefix {
 public:
-	//! Number of bytes in this prefix
-	uint32_t count;
-	union {
-		//! Pointer to the head of the list of prefix segments
-		Node ptr;
-		//! Inlined prefix bytes
-		uint8_t inlined[Node::PREFIX_INLINE_BYTES];
-	} data;
+	//! Delete copy constructors, as any Prefix can never own its memory
+	Prefix(const Prefix &) = delete;
+	Prefix &operator=(const Prefix &) = delete;
+
+	//! Up to PREFIX_SIZE bytes of prefix data and the count
+	uint8_t data[Node::PREFIX_SIZE + 1];
+	//! A pointer to the next Node
+	Node ptr;
 
 public:
-	//! Delete all prefix segments (if not inlined) and reset all fields
-	void Free(ART &art);
-	//! Initializes all the fields of an empty prefix
-	inline void Initialize() {
-		count = 0;
-	}
-	//! Initialize a prefix from an ART key
-	void Initialize(ART &art, const ARTKey &key, const uint32_t depth, const uint32_t count_p);
-	//! Initialize a prefix from another prefix up to count
-	void Initialize(ART &art, const Prefix &other, const uint32_t count_p);
+	//! Get a new empty prefix node, might cause a new buffer allocation
+	static Prefix &New(ART &art, Node &node);
+	//! Create a new prefix node containing a single byte and a pointer to a next node
+	static Prefix &New(ART &art, Node &node, uint8_t byte, const Node &next = Node());
+	//! Get a new chain of prefix nodes, might cause new buffer allocations,
+	//! with the node parameter holding the tail of the chain
+	static void New(ART &art, reference<Node> &node, const ARTKey &key, const uint32_t depth, uint32_t count);
+	//! Free the node (and its subtree)
+	static void Free(ART &art, Node &node);
 
-	//! Initializes a merge by incrementing the buffer IDs of the prefix segments
-	void InitializeMerge(ART &art, const idx_t buffer_count);
+	//! Initializes a merge by incrementing the buffer ID of the prefix and its child node(s)
+	static void InitializeMerge(ART &art, Node &node, const ARTFlags &flags);
 
-	//! Move a prefix into this prefix
-	inline void Move(Prefix &other) {
-		count = other.count;
-		data = other.data;
-		other.Initialize();
+	//! Appends a byte and a child_prefix to prefix. If there is no prefix, than it pushes the
+	//! byte on top of child_prefix. If there is no child_prefix, then it creates a new
+	//! prefix node containing that byte
+	static void Concatenate(ART &art, Node &prefix_node, const uint8_t byte, Node &child_prefix_node);
+	//! Traverse a prefix and a key until (1) encountering a non-prefix node, or (2) encountering
+	//! a mismatching byte, in which case depth indexes the mismatching byte in the key
+	static idx_t Traverse(ART &art, reference<const Node> &prefix_node, const ARTKey &key, idx_t &depth);
+	//! Traverse a prefix and a key until (1) encountering a non-prefix node, or (2) encountering
+	//! a mismatching byte, in which case depth indexes the mismatching byte in the key
+	static idx_t TraverseMutable(ART &art, reference<Node> &prefix_node, const ARTKey &key, idx_t &depth);
+	//! Traverse two prefixes to find (1) that they match (so far), or (2) that they have a mismatching position,
+	//! or (3) that one prefix contains the other prefix. This function aids in merging Nodes, and, therefore,
+	//! the nodes are not const
+	static bool Traverse(ART &art, reference<Node> &l_node, reference<Node> &r_node, idx_t &mismatch_position);
+	//! Returns the byte at position
+	static inline uint8_t GetByte(const ART &art, const Node &prefix_node, const idx_t position) {
+		auto &prefix = Node::Ref<const Prefix>(art, prefix_node, NType::PREFIX);
+		D_ASSERT(position < Node::PREFIX_SIZE);
+		D_ASSERT(position < prefix.data[Node::PREFIX_SIZE]);
+		return prefix.data[position];
 	}
-	//! Append a prefix to this prefix
-	void Append(ART &art, const Prefix &other);
-	//! Concatenate prefix with a partial key byte and another prefix: other.prefix + byte + this->prefix
-	void Concatenate(ART &art, const uint8_t byte, const Prefix &other);
-	//! Removes the first n bytes, and returns the new first byte
-	uint8_t Reduce(ART &art, const idx_t reduce_count);
-
-	//! Get the byte at position
-	uint8_t GetByte(const ART &art, const idx_t position) const;
-	//! Compare the key with the prefix of the node, return the position where they mismatch
-	uint32_t KeyMismatchPosition(const ART &art, const ARTKey &key, const uint32_t depth) const;
-	//! Compare this prefix to another prefix, return the position where they mismatch, or count otherwise
-	uint32_t MismatchPosition(const ART &art, const Prefix &other) const;
+	//! Removes the first n bytes from the prefix and shifts all subsequent bytes in the
+	//! prefix node(s) by n. Frees empty prefix nodes
+	static void Reduce(ART &art, Node &prefix_node, const idx_t n);
+	//! Splits the prefix at position. prefix_node then references the ptr (if any bytes left before
+	//! the split), or stays unchanged (no bytes left before the split). child_node references
+	//! the node after the split, which is either a new prefix node, or ptr
+	static void Split(ART &art, reference<Node> &prefix_node, Node &child_node, idx_t position);
 
-	//! Serialize this prefix
-	void Serialize(const ART &art, MetaBlockWriter &writer) const;
-	//! Deserialize this prefix
-	void Deserialize(ART &art, MetaBlockReader &reader);
+	//! Returns the string representation of the node, or only traverses and verifies the node and its subtree
+	static string VerifyAndToString(ART &art, const Node &node, const bool only_verify);
 
-	//! Vacuum the prefix segments of a prefix, if not inlined
-	void Vacuum(ART &art);
+	//! Vacuum the child of the node
+	static void Vacuum(ART &art, Node &node, const ARTFlags &flags);
 
 private:
-	//! Returns whether this prefix is inlined
-	inline bool IsInlined() const {
-		return count <= Node::PREFIX_INLINE_BYTES;
-	}
-	//! Moves all inlined bytes onto a prefix segment, does not change the size
-	//! so this will be an (temporarily) invalid prefix
-	PrefixSegment &MoveInlinedToSegment(ART &art);
-	//! Inlines up to eight bytes on the first prefix segment
-	void MoveSegmentToInlined(ART &art);
+	//! Appends the byte to this prefix node, or creates a subsequent prefix node,
+	//! if this node is full
+	Prefix &Append(ART &art, const uint8_t byte);
+	//! Appends the other_prefix and all its subsequent prefix nodes to this prefix node.
+	//! Also frees all copied/appended nodes
+	void Append(ART &art, Node other_prefix);
 };
-
 } // namespace duckdb

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

@@ -0,0 +1,120 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/index/fixed_size_allocator.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/types/validity_mask.hpp"
+#include "duckdb/common/unordered_set.hpp"
+#include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/storage/metadata/metadata_manager.hpp"
+#include "duckdb/storage/metadata/metadata_writer.hpp"
+#include "duckdb/execution/index/fixed_size_buffer.hpp"
+#include "duckdb/execution/index/index_pointer.hpp"
+#include "duckdb/common/unordered_map.hpp"
+#include "duckdb/common/constants.hpp"
+#include "duckdb/common/map.hpp"
+
+namespace duckdb {
+
+//! The FixedSizeAllocator provides pointers to fixed-size memory segments of pre-allocated memory buffers.
+//! The pointers are IndexPointers, and the leftmost byte (metadata) must always be zero.
+//! It is also possible to directly request a C++ pointer to the underlying segment of an index pointer.
+class FixedSizeAllocator {
+public:
+	//! We can vacuum 10% or more of the total in-memory footprint
+	static constexpr uint8_t VACUUM_THRESHOLD = 10;
+
+public:
+	FixedSizeAllocator(const idx_t segment_size, BlockManager &block_manager);
+
+	//! Block manager of the database instance
+	BlockManager &block_manager;
+	//! Buffer manager of the database instance
+	BufferManager &buffer_manager;
+	//! Metadata manager for (de)serialization
+	MetadataManager &metadata_manager;
+
+public:
+	//! Get a new IndexPointer to a segment, might cause a new buffer allocation
+	IndexPointer New();
+	//! Free the segment of the IndexPointer
+	void Free(const IndexPointer ptr);
+	//! Returns a pointer of type T to a segment. If dirty is false, then T should be a const class
+	template <class T>
+	inline T *Get(const IndexPointer ptr, const bool dirty = true) {
+		return (T *)Get(ptr, dirty);
+	}
+
+	//! Resets the allocator, e.g., during 'DELETE FROM table'
+	void Reset();
+
+	//! Returns the in-memory usage in bytes
+	inline idx_t GetMemoryUsage() const;
+
+	//! Returns the upper bound of the available buffer IDs, i.e., upper_bound > max_buffer_id
+	idx_t GetUpperBoundBufferId() const;
+	//! Merge another FixedSizeAllocator into this allocator. Both must have the same segment size
+	void Merge(FixedSizeAllocator &other);
+
+	//! Initialize a vacuum operation, and return true, if the allocator needs a vacuum
+	bool InitializeVacuum();
+	//! Finalize a vacuum operation by freeing all vacuumed buffers
+	void FinalizeVacuum();
+	//! Returns true, if an IndexPointer qualifies for a vacuum operation, and false otherwise
+	inline bool NeedsVacuum(const IndexPointer ptr) const {
+		if (vacuum_buffers.find(ptr.GetBufferId()) != vacuum_buffers.end()) {
+			return true;
+		}
+		return false;
+	}
+	//! Vacuums an IndexPointer
+	IndexPointer VacuumPointer(const IndexPointer ptr);
+
+	//! Serializes all in-memory buffers and the metadata
+	BlockPointer Serialize(PartialBlockManager &partial_block_manager, MetadataWriter &writer);
+	//! Deserializes all metadata
+	void Deserialize(const BlockPointer &block_pointer);
+
+private:
+	//! Allocation size of one segment in a buffer
+	//! We only need this value to calculate bitmask_count, bitmask_offset, and
+	//! available_segments_per_buffer
+	idx_t segment_size;
+
+	//! Number of validity_t values in the bitmask
+	idx_t bitmask_count;
+	//! First starting byte of the payload (segments)
+	idx_t bitmask_offset;
+	//! Number of possible segment allocations per buffer
+	idx_t available_segments_per_buffer;
+
+	//! Total number of allocated segments in all buffers
+	//! We can recalculate this by iterating over all buffers
+	idx_t total_segment_count;
+
+	//! Buffers containing the segments
+	unordered_map<idx_t, FixedSizeBuffer> buffers;
+	//! Buffers with free space
+	unordered_set<idx_t> buffers_with_free_space;
+	//! Buffers qualifying for a vacuum (helper field to allow for fast NeedsVacuum checks)
+	unordered_set<idx_t> vacuum_buffers;
+
+private:
+	//! Returns the data_ptr_t to a segment, and sets the dirty flag of the buffer containing that segment
+	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 = buffers.find(ptr.GetBufferId())->second;
+		auto buffer_ptr = buffer.Get(dirty);
+		return buffer_ptr + ptr.GetOffset() * segment_size + bitmask_offset;
+	}
+	//! Returns an available buffer id
+	idx_t GetAvailableBufferId() const;
+};
+
+} // namespace duckdb

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

@@ -0,0 +1,109 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/index/fixed_size_buffer.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/storage/partial_block_manager.hpp"
+#include "duckdb/common/typedefs.hpp"
+#include "duckdb/storage/buffer/block_handle.hpp"
+#include "duckdb/storage/buffer/buffer_handle.hpp"
+#include "duckdb/storage/block_manager.hpp"
+
+namespace duckdb {
+
+class FixedSizeAllocator;
+class MetadataWriter;
+
+struct PartialBlockForIndex : public PartialBlock {
+public:
+	PartialBlockForIndex(PartialBlockState state, BlockManager &block_manager,
+	                     const shared_ptr<BlockHandle> &block_handle);
+	~PartialBlockForIndex() override {};
+
+public:
+	void Flush(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.
+class FixedSizeBuffer {
+public:
+	//! Constants for fast offset calculations in the bitmask
+	static constexpr idx_t BASE[] = {0x00000000FFFFFFFF, 0x0000FFFF, 0x00FF, 0x0F, 0x3, 0x1};
+	static constexpr uint8_t SHIFT[] = {32, 16, 8, 4, 2, 1};
+
+public:
+	//! Constructor for a new in-memory buffer
+	explicit FixedSizeBuffer(BlockManager &block_manager);
+	//! Constructor for deserializing buffer metadata from disk
+	FixedSizeBuffer(BlockManager &block_manager, const idx_t segment_count, const idx_t allocation_size,
+	                const BlockPointer &block_pointer);
+
+	//! Block manager of the database instance
+	BlockManager &block_manager;
+
+	//! 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
+	bool dirty;
+	//! True: can be vacuumed after the vacuum operation
+	bool vacuum;
+
+	//! Partial block id and offset
+	BlockPointer block_pointer;
+
+public:
+	//! Returns true, if the buffer is in-memory
+	inline bool InMemory() const {
+		return buffer_handle.IsValid();
+	}
+	//! Returns true, if the block is on-disk
+	inline bool OnDisk() const {
+		return block_pointer.IsValid();
+	}
+	//! Returns a pointer to the buffer in memory, and calls Deserialize, if the buffer is not in memory
+	inline data_ptr_t Get(const bool dirty_p = true) {
+		if (!InMemory()) {
+			Pin();
+		}
+		if (dirty_p) {
+			dirty = dirty_p;
+		}
+		return buffer_handle.Ptr();
+	}
+	//! Destroys the in-memory buffer and the on-disk block
+	void Destroy();
+	//! 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();
+	//! Returns the first free offset in a bitmask
+	uint32_t GetOffset(const idx_t bitmask_count);
+
+private:
+	//! The buffer handle of the in-memory buffer
+	BufferHandle buffer_handle;
+	//! The block handle of the on-disk buffer
+	shared_ptr<BlockHandle> block_handle;
+
+private:
+	//! Returns the maximum non-free offset in a bitmask
+	uint32_t GetMaxOffset(const idx_t available_segments_per_buffer);
+	//! Sets all uninitialized regions of a buffer in the respective partial block allocation
+	void SetUninitializedRegions(PartialBlockForIndex &p_block_for_index, const idx_t segment_size, const idx_t offset,
+	                             const idx_t bitmask_offset);
+};
+
+} // namespace duckdb

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

@@ -0,0 +1,96 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/index/index_pointer.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/typedefs.hpp"
+
+namespace duckdb {
+
+class IndexPointer {
+public:
+	//! Bit-shifting
+	static constexpr idx_t SHIFT_OFFSET = 32;
+	static constexpr idx_t SHIFT_METADATA = 56;
+	//! AND operations
+	static constexpr idx_t AND_OFFSET = 0x0000000000FFFFFF;
+	static constexpr idx_t AND_BUFFER_ID = 0x00000000FFFFFFFF;
+	static constexpr idx_t AND_METADATA = 0xFF00000000000000;
+
+public:
+	//! Constructs an empty IndexPointer
+	IndexPointer() : data(0) {};
+	//! Constructs an in-memory IndexPointer with a buffer ID and an offset
+	IndexPointer(const uint32_t buffer_id, const uint32_t offset) : data(0) {
+		auto shifted_offset = ((idx_t)offset) << SHIFT_OFFSET;
+		data += shifted_offset;
+		data += buffer_id;
+	};
+
+public:
+	//! Get data (all 64 bits)
+	inline idx_t Get() const {
+		return data;
+	}
+	//! Set data (all 64 bits)
+	inline void Set(const idx_t data_p) {
+		data = data_p;
+	}
+
+	//! Returns false, if the metadata is empty
+	inline bool HasMetadata() const {
+		return data & AND_METADATA;
+	}
+	//! Get metadata (zero to 7th bit)
+	inline uint8_t GetMetadata() const {
+		return data >> SHIFT_METADATA;
+	}
+	//! Set metadata (zero to 7th bit)
+	inline void SetMetadata(const uint8_t metadata) {
+		data += (idx_t)metadata << SHIFT_METADATA;
+	}
+
+	//! Get the offset (8th to 23rd bit)
+	inline idx_t GetOffset() const {
+		auto offset = data >> SHIFT_OFFSET;
+		return offset & AND_OFFSET;
+	}
+	//! Get the buffer ID (24th to 63rd bit)
+	inline idx_t GetBufferId() const {
+		return data & AND_BUFFER_ID;
+	}
+
+	//! Resets the IndexPointer
+	inline void Clear() {
+		data = 0;
+	}
+
+	//! Adds an idx_t to a buffer ID, the rightmost 32 bits of data contain the buffer ID
+	inline void IncreaseBufferId(const idx_t summand) {
+		data += summand;
+	}
+
+	//! Comparison operator
+	inline bool operator==(const IndexPointer &ptr) const {
+		return data == ptr.data;
+	}
+
+private:
+	//! Data holds all the information contained in an IndexPointer
+	//! [0 - 7: metadata,
+	//! 8 - 23: offset, 24 - 63: buffer ID]
+	//! NOTE: we do not use bit fields because when using bit fields Windows compiles
+	//! the IndexPointer class into 16 bytes instead of the intended 8 bytes, doubling the
+	//! space requirements
+	//! https://learn.microsoft.com/en-us/cpp/cpp/cpp-bit-fields?view=msvc-170
+	idx_t data;
+};
+
+static_assert(sizeof(IndexPointer) == sizeof(idx_t), "Invalid size for IndexPointer.");
+
+} // namespace duckdb

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

@@ -65,7 +65,7 @@ public:
 	//! returned by the JoinHashTable::Scan function and can be used to resume a
 	//! probe.
 	struct ScanStructure {
-		unsafe_unique_array<UnifiedVectorFormat> key_data;
+		TupleDataChunkState &key_state;
 		Vector pointers;
 		idx_t count;
 		SelectionVector sel_vector;
@@ -74,7 +74,7 @@ public:
 		JoinHashTable &ht;
 		bool finished;
 
-		explicit ScanStructure(JoinHashTable &ht);
+		explicit ScanStructure(JoinHashTable &ht, TupleDataChunkState &key_state);
 		//! Get the next batch of data from the scan structure
 		void Next(DataChunk &keys, DataChunk &left, DataChunk &result);
 
@@ -130,7 +130,8 @@ public:
 	//! ever called.
 	void Finalize(idx_t chunk_idx_from, idx_t chunk_idx_to, bool parallel);
 	//! Probe the HT with the given input chunk, resulting in the given result
-	unique_ptr<ScanStructure> Probe(DataChunk &keys, Vector *precomputed_hashes = nullptr);
+	unique_ptr<ScanStructure> Probe(DataChunk &keys, TupleDataChunkState &key_state,
+	                                Vector *precomputed_hashes = nullptr);
 	//! Scan the HT to construct the full outer join result
 	void ScanFullOuter(JoinHTScanState &state, Vector &addresses, DataChunk &result);
 
@@ -166,6 +167,9 @@ public:
 	vector<ExpressionType> predicates;
 	//! Data column layout
 	TupleDataLayout layout;
+	//! Efficiently matches rows
+	RowMatcher row_matcher;
+	RowMatcher row_matcher_no_match_sel;
 	//! The size of an entry as stored in the HashTable
 	idx_t entry_size;
 	//! The total tuple size
@@ -201,7 +205,8 @@ public:
 	} correlated_mark_join_info;
 
 private:
-	unique_ptr<ScanStructure> InitializeScanStructure(DataChunk &keys, const SelectionVector *&current_sel);
+	unique_ptr<ScanStructure> InitializeScanStructure(DataChunk &keys, TupleDataChunkState &key_state,
+	                                                  const SelectionVector *&current_sel);
 	void Hash(DataChunk &keys, const SelectionVector &sel, idx_t count, Vector &hashes);
 
 	//! Apply a bitmask to the hashes
@@ -212,8 +217,8 @@ private:
 	//! Insert the given set of locations into the HT with the given set of hashes
 	void InsertHashes(Vector &hashes, idx_t count, data_ptr_t key_locations[], bool parallel);
 
-	idx_t PrepareKeys(DataChunk &keys, unsafe_unique_array<UnifiedVectorFormat> &key_data,
-	                  const SelectionVector *&current_sel, SelectionVector &sel, bool build_side);
+	idx_t PrepareKeys(DataChunk &keys, vector<TupleDataVectorFormat> &vector_data, const SelectionVector *&current_sel,
+	                  SelectionVector &sel, bool build_side);
 
 	//! Lock for combining data_collection when merging HTs
 	mutex data_lock;
@@ -316,8 +321,9 @@ public:
 	//! Build HT for the next partitioned probe round
 	bool PrepareExternalFinalize();
 	//! Probe whatever we can, sink the rest into a thread-local HT
-	unique_ptr<ScanStructure> ProbeAndSpill(DataChunk &keys, DataChunk &payload, ProbeSpill &probe_spill,
-	                                        ProbeSpillLocalAppendState &spill_state, DataChunk &spill_chunk);
+	unique_ptr<ScanStructure> ProbeAndSpill(DataChunk &keys, TupleDataChunkState &key_state, DataChunk &payload,
+	                                        ProbeSpill &probe_spill, ProbeSpillLocalAppendState &spill_state,
+	                                        DataChunk &spill_chunk);
 
 private:
 	//! First and last partition of the current probe round

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

@@ -8,17 +8,18 @@
 
 #pragma once
 
+#include "duckdb/execution/operator/aggregate/distinct_aggregate_data.hpp"
+#include "duckdb/execution/operator/aggregate/grouped_aggregate_data.hpp"
 #include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/parser/group_by_node.hpp"
 #include "duckdb/execution/radix_partitioned_hashtable.hpp"
-#include "duckdb/execution/operator/aggregate/grouped_aggregate_data.hpp"
-#include "duckdb/execution/operator/aggregate/distinct_aggregate_data.hpp"
+#include "duckdb/parser/group_by_node.hpp"
+#include "duckdb/storage/data_table.hpp"
 
 namespace duckdb {
 
 class ClientContext;
 class BufferManager;
+class PhysicalHashAggregate;
 
 struct HashAggregateGroupingData {
 public:
@@ -106,9 +107,9 @@ public:
 public:
 	// Sink interface
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
+	                          OperatorSinkFinalizeInput &input) const override;
 	SinkFinalizeType FinalizeInternal(Pipeline &pipeline, Event &event, ClientContext &context, GlobalSinkState &gstate,
 	                                  bool check_distinct) const;
 
@@ -141,7 +142,7 @@ private:
 	SinkFinalizeType FinalizeDistinct(Pipeline &pipeline, Event &event, ClientContext &context,
 	                                  GlobalSinkState &gstate) const;
 	//! Combine the distinct aggregates
-	void CombineDistinct(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const;
+	void CombineDistinct(ExecutionContext &context, OperatorSinkCombineInput &input) const;
 	//! Sink the distinct aggregates for a single grouping
 	void SinkDistinctGrouping(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input,
 	                          idx_t grouping_idx) const;

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

@@ -46,7 +46,7 @@ public:
 public:
 	// Sink interface
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;

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

@@ -44,9 +44,9 @@ public:
 public:
 	// Sink interface
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
+	                          OperatorSinkFinalizeInput &input) const override;
 
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
@@ -68,7 +68,7 @@ private:
 	SinkFinalizeType FinalizeDistinct(Pipeline &pipeline, Event &event, ClientContext &context,
 	                                  GlobalSinkState &gstate) const;
 	//! Combine the distinct aggregates
-	void CombineDistinct(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const;
+	void CombineDistinct(ExecutionContext &context, OperatorSinkCombineInput &input) const;
 	//! Sink the distinct aggregates
 	void SinkDistinct(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const;
 };

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

@@ -36,6 +36,8 @@ public:
 	                                                 GlobalSourceState &gstate) const override;
 	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
 	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
+	idx_t GetBatchIndex(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
+	                    LocalSourceState &lstate) const override;
 
 	bool IsSource() const override {
 		return true;
@@ -44,16 +46,15 @@ public:
 		return true;
 	}
 
-	OrderPreservationType SourceOrder() const override {
-		return OrderPreservationType::NO_ORDER;
-	}
+	bool SupportsBatchIndex() const override;
+	OrderPreservationType SourceOrder() const override;
 
 public:
 	// Sink interface
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
+	                          OperatorSinkFinalizeInput &input) const override;
 
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_batch_collector.hpp

@@ -22,9 +22,9 @@ public:
 public:
 	// Sink interface
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
+	                          OperatorSinkFinalizeInput &input) const override;
 
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;