duckdb 0.7.2-dev314.0 → 0.7.2-dev3154.0

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

@@ -8,13 +8,14 @@
 
 #pragma once
 
+#include "duckdb/common/types/row/tuple_data_collection.hpp"
 #include "duckdb/execution/base_aggregate_hashtable.hpp"
+#include "duckdb/storage/arena_allocator.hpp"
 #include "duckdb/storage/buffer/buffer_handle.hpp"
 
 namespace duckdb {
 class BlockHandle;
 class BufferHandle;
-class RowDataCollection;
 
 struct FlushMoveState;
 
@@ -59,7 +60,24 @@ enum HtEntryType { HT_WIDTH_32, HT_WIDTH_64 };
 
 struct AggregateHTScanState {
 	mutex lock;
-	idx_t scan_position = 0;
+	TupleDataScanState scan_state;
+};
+
+struct AggregateHTAppendState {
+	AggregateHTAppendState();
+
+	Vector ht_offsets;
+	Vector hash_salts;
+	SelectionVector group_compare_vector;
+	SelectionVector no_match_vector;
+	SelectionVector empty_vector;
+	SelectionVector new_groups;
+	Vector addresses;
+	unique_ptr<UnifiedVectorFormat[]> group_data;
+	DataChunk group_chunk;
+
+	TupleDataChunkState chunk_state;
+	bool chunk_state_initialized;
 };
 
 class GroupedAggregateHashTable : public BaseAggregateHashTable {
@@ -71,28 +89,29 @@ public:
 public:
 	GroupedAggregateHashTable(ClientContext &context, Allocator &allocator, vector<LogicalType> group_types,
 	                          vector<LogicalType> payload_types, const vector<BoundAggregateExpression *> &aggregates,
-	                          HtEntryType entry_type = HtEntryType::HT_WIDTH_64);
+	                          HtEntryType entry_type = HtEntryType::HT_WIDTH_64,
+	                          idx_t initial_capacity = InitialCapacity());
 	GroupedAggregateHashTable(ClientContext &context, Allocator &allocator, vector<LogicalType> group_types,
 	                          vector<LogicalType> payload_types, vector<AggregateObject> aggregates,
-	                          HtEntryType entry_type = HtEntryType::HT_WIDTH_64);
+	                          HtEntryType entry_type = HtEntryType::HT_WIDTH_64,
+	                          idx_t initial_capacity = InitialCapacity());
 	GroupedAggregateHashTable(ClientContext &context, Allocator &allocator, vector<LogicalType> group_types);
 	~GroupedAggregateHashTable() override;
 
-	//! The stringheap of the AggregateHashTable
-	unique_ptr<RowDataCollection> string_heap;
-
 public:
 	//! Add the given data to the HT, computing the aggregates grouped by the
 	//! data in the group chunk. When resize = true, aggregates will not be
 	//! computed but instead just assigned.
-	idx_t AddChunk(DataChunk &groups, DataChunk &payload, const vector<idx_t> &filter);
-	idx_t AddChunk(DataChunk &groups, Vector &group_hashes, DataChunk &payload, const vector<idx_t> &filter);
-	idx_t AddChunk(DataChunk &groups, DataChunk &payload, AggregateType filter);
+	idx_t AddChunk(AggregateHTAppendState &state, DataChunk &groups, DataChunk &payload,
+	               const unsafe_vector<idx_t> &filter);
+	idx_t AddChunk(AggregateHTAppendState &state, DataChunk &groups, Vector &group_hashes, DataChunk &payload,
+	               const unsafe_vector<idx_t> &filter);
+	idx_t AddChunk(AggregateHTAppendState &state, DataChunk &groups, DataChunk &payload, AggregateType filter);
 
 	//! Scan the HT starting from the scan_position until the result and group
 	//! chunks are filled. scan_position will be updated by this function.
 	//! Returns the amount of elements found.
-	idx_t Scan(AggregateHTScanState &scan_state, DataChunk &result);
+	idx_t Scan(TupleDataParallelScanState &gstate, TupleDataLocalScanState &lstate, DataChunk &result);
 
 	//! Fetch the aggregates for specific groups from the HT and place them in the result
 	void FetchAggregates(DataChunk &groups, DataChunk &result);
@@ -100,86 +119,90 @@ public:
 	//! Finds or creates groups in the hashtable using the specified group keys. The addresses vector will be filled
 	//! with pointers to the groups in the hash table, and the new_groups selection vector will point to the newly
 	//! created groups. The return value is the amount of newly created groups.
-	idx_t FindOrCreateGroups(DataChunk &groups, Vector &group_hashes, Vector &addresses_out,
+	idx_t FindOrCreateGroups(AggregateHTAppendState &state, DataChunk &groups, Vector &group_hashes,
+	                         Vector &addresses_out, SelectionVector &new_groups_out);
+	idx_t FindOrCreateGroups(AggregateHTAppendState &state, DataChunk &groups, Vector &addresses_out,
 	                         SelectionVector &new_groups_out);
-	idx_t FindOrCreateGroups(DataChunk &groups, Vector &addresses_out, SelectionVector &new_groups_out);
-	void FindOrCreateGroups(DataChunk &groups, Vector &addresses_out);
+	void FindOrCreateGroups(AggregateHTAppendState &state, DataChunk &groups, Vector &addresses_out);
 
 	//! Executes the filter(if any) and update the aggregates
 	void Combine(GroupedAggregateHashTable &other);
 
-	idx_t Size() {
-		return entries;
+	TupleDataCollection &GetDataCollection() {
+		return *data_collection;
+	}
+
+	idx_t Count() const {
+		return data_collection->Count();
 	}
 
+	static idx_t InitialCapacity();
+	idx_t Capacity() {
+		return capacity;
+	}
+
+	idx_t ResizeThreshold();
 	idx_t MaxCapacity();
+	static idx_t GetMaxCapacity(HtEntryType entry_type, idx_t tuple_size);
 
-	void Partition(vector<GroupedAggregateHashTable *> &partition_hts, hash_t mask, idx_t shift);
+	void Partition(vector<GroupedAggregateHashTable *> &partition_hts, idx_t radix_bits);
+	void InitializeFirstPart();
 
 	void Finalize();
 
 private:
 	HtEntryType entry_type;
 
-	//! The total tuple size
+	//! The capacity of the HT. This can be increased using GroupedAggregateHashTable::Resize
+	idx_t capacity;
+	//! Tuple width
 	idx_t tuple_size;
-	//! The amount of tuples that fit in a single block
+	//! Tuples per block
 	idx_t tuples_per_block;
-	//! The capacity of the HT. This can be increased using
-	//! GroupedAggregateHashTable::Resize
-	idx_t capacity;
-	//! The amount of entries stored in the HT currently
-	idx_t entries;
 	//! The data of the HT
-	vector<BufferHandle> payload_hds;
+	unique_ptr<TupleDataCollection> data_collection;
+	TupleDataPinState td_pin_state;
 	vector<data_ptr_t> payload_hds_ptrs;
 
 	//! The hashes of the HT
 	BufferHandle hashes_hdl;
 	data_ptr_t hashes_hdl_ptr;
-	data_ptr_t hashes_end_ptr; // of hashes
-	idx_t hash_offset;         // Offset into the layout of the hash column
+	idx_t hash_offset; // Offset into the layout of the hash column
 
 	hash_t hash_prefix_shift;
-	idx_t payload_page_offset;
 
 	//! Bitmask for getting relevant bits from the hashes to determine the position
 	hash_t bitmask;
 
-	vector<unique_ptr<GroupedAggregateHashTable>> distinct_hashes;
-
 	bool is_finalized;
 
-	// some stuff from FindOrCreateGroupsInternal() to avoid allocation there
-	Vector ht_offsets;
-	Vector hash_salts;
-	SelectionVector group_compare_vector;
-	SelectionVector no_match_vector;
-	SelectionVector empty_vector;
 	vector<ExpressionType> predicates;
 
+	//! The arena allocator used by the aggregates for their internal state
+	shared_ptr<ArenaAllocator> aggregate_allocator;
+
 private:
 	GroupedAggregateHashTable(const GroupedAggregateHashTable &) = delete;
 
-	//! Resize the HT to the specified size. Must be larger than the current
-	//! size.
 	void Destroy();
-
 	void Verify();
-
-	void FlushMove(FlushMoveState &state, Vector &source_addresses, Vector &source_hashes, idx_t count);
-	void NewBlock();
-
 	template <class ENTRY>
 	void VerifyInternal();
+	//! Resize the HT to the specified size. Must be larger than the current size.
 	template <class ENTRY>
 	void Resize(idx_t size);
+	//! Initializes the first part of the HT
 	template <class ENTRY>
-	idx_t FindOrCreateGroupsInternal(DataChunk &groups, Vector &group_hashes, Vector &addresses,
+	void InitializeHashes();
+	//! Does the actual group matching / creation
+	template <class ENTRY>
+	idx_t FindOrCreateGroupsInternal(DataChunk &groups, Vector &group_hashes_v, Vector &addresses_v,
 	                                 SelectionVector &new_groups);
-
-	template <class FUNC = std::function<void(idx_t, idx_t, data_ptr_t)>>
-	void PayloadApply(FUNC fun);
+	//! Updates payload_hds_ptrs with the new pointers (after appending to data_collection)
+	void UpdateBlockPointers();
+	template <class ENTRY>
+	idx_t FindOrCreateGroupsInternal(AggregateHTAppendState &state, DataChunk &groups, Vector &group_hashes,
+	                                 Vector &addresses, SelectionVector &new_groups);
 };
 
 } // namespace duckdb

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

@@ -9,7 +9,7 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
-#include "duckdb/common/types/row_layout.hpp"
+#include "duckdb/common/types/row/tuple_data_layout.hpp"
 #include "duckdb/common/types/vector.hpp"
 #include "duckdb/execution/operator/aggregate/aggregate_object.hpp"
 
@@ -27,7 +27,7 @@ protected:
 	Allocator &allocator;
 	BufferManager &buffer_manager;
 	//! A helper for managing offsets into the data buffers
-	RowLayout layout;
+	TupleDataLayout layout;
 	//! The types of the payload columns stored in the hashtable
 	vector<LogicalType> payload_types;
 	//! Intermediate structures and data for aggregate filters

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

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
 namespace duckdb {
 class ClientContext;
@@ -17,7 +18,7 @@ class Pipeline;
 
 class ExecutionContext {
 public:
-	ExecutionContext(ClientContext &client_p, ThreadContext &thread_p, Pipeline *pipeline_p)
+	ExecutionContext(ClientContext &client_p, ThreadContext &thread_p, optional_ptr<Pipeline> pipeline_p)
 	    : client(client_p), thread(thread_p), pipeline(pipeline_p) {
 	}
 
@@ -26,7 +27,7 @@ public:
 	//! The thread-local context for this execution
 	ThreadContext &thread;
 	//! Reference to the pipeline for this execution, can be used for example by operators determine caching strategy
-	Pipeline *pipeline;
+	optional_ptr<Pipeline> pipeline;
 };
 
 } // namespace duckdb

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

@@ -12,7 +12,7 @@
 #include "duckdb/common/enums/pending_execution_result.hpp"
 #include "duckdb/common/mutex.hpp"
 #include "duckdb/common/pair.hpp"
-#include "duckdb/common/unordered_map.hpp"
+#include "duckdb/common/reference_map.hpp"
 #include "duckdb/parallel/pipeline.hpp"
 
 namespace duckdb {
@@ -43,7 +43,7 @@ public:
 public:
 	static Executor &Get(ClientContext &context);
 
-	void Initialize(PhysicalOperator *physical_plan);
+	void Initialize(PhysicalOperator &physical_plan);
 	void Initialize(unique_ptr<PhysicalOperator> physical_plan);
 
 	void CancelTasks();
@@ -70,6 +70,12 @@ public:
 	//! Flush a thread context into the client context
 	void Flush(ThreadContext &context);
 
+	//! Reschedules a task that was blocked
+	void RescheduleTask(shared_ptr<Task> &task);
+
+	//! Add the task to be rescheduled
+	void AddToBeRescheduled(shared_ptr<Task> &task);
+
 	//! Returns the progress of the pipelines
 	bool GetPipelinesProgress(double &current_progress);
 
@@ -81,7 +87,7 @@ public:
 	}
 	void AddEvent(shared_ptr<Event> event);
 
-	void AddRecursiveCTE(PhysicalOperator *rec_cte);
+	void AddRecursiveCTE(PhysicalOperator &rec_cte);
 	void ReschedulePipelines(const vector<shared_ptr<MetaPipeline>> &pipelines, vector<shared_ptr<Event>> &events);
 
 	//! Whether or not the root of the pipeline is a result collector object
@@ -93,7 +99,7 @@ public:
 	bool ExecutionIsFinished();
 
 private:
-	void InitializeInternal(PhysicalOperator *physical_plan);
+	void InitializeInternal(PhysicalOperator &physical_plan);
 
 	void ScheduleEvents(const vector<shared_ptr<MetaPipeline>> &meta_pipelines);
 	static void ScheduleEventsInternal(ScheduleEventData &event_data);
@@ -106,13 +112,13 @@ private:
 
 	bool NextExecutor();
 
-	shared_ptr<Pipeline> CreateChildPipeline(Pipeline *current, PhysicalOperator *op);
+	shared_ptr<Pipeline> CreateChildPipeline(Pipeline &current, PhysicalOperator &op);
 
 	void VerifyPipeline(Pipeline &pipeline);
 	void VerifyPipelines();
 
 private:
-	PhysicalOperator *physical_plan;
+	optional_ptr<PhysicalOperator> physical_plan;
 	unique_ptr<PhysicalOperator> owned_plan;
 
 	mutex executor_lock;
@@ -122,7 +128,7 @@ private:
 	//! The root pipelines of the query
 	vector<shared_ptr<Pipeline>> root_pipelines;
 	//! The recursive CTE's in this query plan
-	vector<PhysicalOperator *> recursive_ctes;
+	vector<reference<PhysicalOperator>> recursive_ctes;
 	//! The pipeline executor for the root pipeline
 	unique_ptr<PipelineExecutor> root_executor;
 	//! The current root pipeline index
@@ -146,6 +152,9 @@ private:
 	//! The last pending execution result (if any)
 	PendingExecutionResult execution_result;
 	//! The current task in process (if any)
-	unique_ptr<Task> task;
+	shared_ptr<Task> task;
+
+	//! Task that have been descheduled
+	unordered_map<Task *, shared_ptr<Task>> to_be_rescheduled_tasks;
 };
 } // namespace duckdb

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

@@ -151,7 +151,7 @@ protected:
 
 private:
 	//! Client context
-	ClientContext *context;
+	optional_ptr<ClientContext> context;
 	//! The states of the expression executor; this holds any intermediates and temporary states of expressions
 	vector<unique_ptr<ExpressionExecutorState>> states;
 

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

@@ -29,7 +29,6 @@ struct ExpressionState {
 	vector<unique_ptr<ExpressionState>> child_states;
 	vector<LogicalType> types;
 	DataChunk intermediate_chunk;
-	string name;
 	CycleCounter profiler;
 
 public:
@@ -55,12 +54,11 @@ public:
 };
 
 struct ExpressionExecutorState {
-	explicit ExpressionExecutorState(const string &name);
+	ExpressionExecutorState();
 
 	unique_ptr<ExpressionState> root_state;
 	ExpressionExecutor *executor = nullptr;
 	CycleCounter profiler;
-	string name;
 
 	void Verify();
 };

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

@@ -8,71 +8,58 @@
 
 #pragma once
 
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/execution/index/art/art_key.hpp"
-#include "duckdb/execution/index/art/iterator.hpp"
-#include "duckdb/execution/index/art/leaf.hpp"
-#include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/index/art/node16.hpp"
-#include "duckdb/execution/index/art/node256.hpp"
-#include "duckdb/execution/index/art/node4.hpp"
-#include "duckdb/execution/index/art/node48.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/storage/data_table.hpp"
 #include "duckdb/storage/index.hpp"
-#include "duckdb/storage/meta_block_writer.hpp"
 
 namespace duckdb {
 
-class ConflictManager;
-
-struct ARTIndexScanState : public IndexScanState {
-
-	//! Scan predicates (single predicate scan or range scan)
-	Value values[2];
-	//! Expressions of the scan predicates
-	ExpressionType expressions[2];
-	bool checked = false;
-	//! All scanned row IDs
-	vector<row_t> result_ids;
-	Iterator iterator;
-};
-
+// classes
 enum class VerifyExistenceType : uint8_t {
 	APPEND = 0,    // appends to a table
 	APPEND_FK = 1, // appends to a table that has a foreign key
 	DELETE_FK = 2  // delete from a table that has a foreign key
 };
+class ConflictManager;
+class Node;
+class ARTKey;
+class FixedSizeAllocator;
+
+// structs
+struct ARTIndexScanState;
+struct ARTFlags {
+	vector<bool> vacuum_flags;
+	vector<idx_t> merge_buffer_counts;
+};
 
 class ART : public Index {
 public:
-	//! Constructs an ART containing the bound expressions, which are resolved during index construction
+	//! Constructs an ART
 	ART(const vector<column_t> &column_ids, TableIOManager &table_io_manager,
-	    const vector<unique_ptr<Expression>> &unbound_expressions, IndexConstraintType constraint_type,
-	    AttachedDatabase &db, bool track_memory, idx_t block_id = DConstants::INVALID_INDEX,
-	    idx_t block_offset = DConstants::INVALID_INDEX);
+	    const vector<unique_ptr<Expression>> &unbound_expressions, const IndexConstraintType constraint_type,
+	    AttachedDatabase &db, const idx_t block_id = DConstants::INVALID_INDEX,
+	    const idx_t block_offset = DConstants::INVALID_INDEX);
 	~ART() override;
 
 	//! Root of the tree
-	Node *tree;
+	unique_ptr<Node> tree;
+	//! Fixed-size allocators holding the ART nodes
+	vector<unique_ptr<FixedSizeAllocator>> allocators;
 
 public:
 	//! Initialize a single predicate scan on the index with the given expression and column IDs
 	unique_ptr<IndexScanState> InitializeScanSinglePredicate(const Transaction &transaction, const Value &value,
-	                                                         ExpressionType expression_type) override;
+	                                                         const ExpressionType expression_type) override;
 	//! Initialize a two predicate scan on the index with the given expression and column IDs
-	unique_ptr<IndexScanState> InitializeScanTwoPredicates(Transaction &transaction, const Value &low_value,
-	                                                       ExpressionType low_expression_type, const Value &high_value,
-	                                                       ExpressionType high_expression_type) override;
+	unique_ptr<IndexScanState> InitializeScanTwoPredicates(const Transaction &transaction, const Value &low_value,
+	                                                       const ExpressionType low_expression_type,
+	                                                       const Value &high_value,
+	                                                       const ExpressionType high_expression_type) override;
 	//! Performs a lookup on the index, fetching up to max_count result IDs. Returns true if all row IDs were fetched,
 	//! and false otherwise
-	bool Scan(Transaction &transaction, DataTable &table, IndexScanState &state, idx_t max_count,
+	bool Scan(const Transaction &transaction, const DataTable &table, IndexScanState &state, const idx_t max_count,
 	          vector<row_t> &result_ids) override;
 
 	//! Called when data is appended to the index. The lock obtained from InitializeLock must be held
-	bool Append(IndexLock &lock, DataChunk &entries, Vector &row_identifiers) override;
+	PreservedError Append(IndexLock &lock, DataChunk &entries, Vector &row_identifiers) override;
 	//! Verify that data can be appended to the index without a constraint violation
 	void VerifyAppend(DataChunk &chunk) override;
 	//! Verify that data can be appended to the index without a constraint violation using the conflict manager
@@ -80,25 +67,28 @@ public:
 	//! Delete a chunk of entries from the index. The lock obtained from InitializeLock must be held
 	void Delete(IndexLock &lock, DataChunk &entries, Vector &row_identifiers) override;
 	//! Insert a chunk of entries into the index
-	bool Insert(IndexLock &lock, DataChunk &data, Vector &row_ids) override;
+	PreservedError Insert(IndexLock &lock, DataChunk &data, Vector &row_ids) override;
 
 	//! Construct an ART from a vector of sorted keys
-	bool ConstructFromSorted(idx_t count, vector<Key> &keys, Vector &row_identifiers);
+	bool ConstructFromSorted(idx_t count, vector<ARTKey> &keys, Vector &row_identifiers);
 
 	//! Search equal values and fetches the row IDs
-	bool SearchEqual(Key &key, idx_t max_count, vector<row_t> &result_ids);
+	bool SearchEqual(ARTKey &key, idx_t max_count, vector<row_t> &result_ids);
 	//! Search equal values used for joins that do not need to fetch data
-	void SearchEqualJoinNoFetch(Key &key, idx_t &result_size);
+	void SearchEqualJoinNoFetch(ARTKey &key, idx_t &result_size);
 
 	//! Serializes the index and returns the pair of block_id offset positions
-	BlockPointer Serialize(duckdb::MetaBlockWriter &writer) override;
+	BlockPointer Serialize(MetaBlockWriter &writer) override;
 
 	//! Merge another index into this index. The lock obtained from InitializeLock must be held, and the other
 	//! index must also be locked during the merge
-	bool MergeIndexes(IndexLock &state, Index *other_index) override;
+	bool MergeIndexes(IndexLock &state, Index &other_index) override;
+
+	//! Traverses an ART and vacuums the qualifying nodes. The lock obtained from InitializeLock must be held
+	void Vacuum(IndexLock &state) override;
 
 	//! Generate ART keys for an input chunk
-	static void GenerateKeys(ArenaAllocator &allocator, DataChunk &input, vector<Key> &keys);
+	static void GenerateKeys(ArenaAllocator &allocator, DataChunk &input, vector<ARTKey> &keys);
 
 	//! Generate a string containing all the expressions and their respective values that violate a constraint
 	string GenerateErrorKeyName(DataChunk &input, idx_t row);
@@ -107,31 +97,38 @@ public:
 	//! Performs constraint checking for a chunk of input data
 	void CheckConstraintsForChunk(DataChunk &input, ConflictManager &conflict_manager) override;
 
-	//! Returns the string representation of an ART
+	//! Returns the string representation of the ART
 	string ToString() override;
-	//! Verifies that the in-memory size value of the index matches its actual size
-	void Verify() override;
-	//! Increases the memory size by the difference between the old size and the current size
-	//! and performs verifications
-	void IncreaseAndVerifyMemorySize(idx_t old_memory_size) override;
 
 private:
 	//! Insert a row ID into a leaf
-	bool InsertToLeaf(Leaf &leaf, row_t row_id);
+	bool InsertToLeaf(Node &leaf_node, const row_t &row_id);
 	//! Insert a key into the tree
-	bool Insert(Node *&node, Key &key, idx_t depth, row_t row_id);
+	bool Insert(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id);
 	//! Erase a key from the tree (if a leaf has more than one value) or erase the leaf itself
-	void Erase(Node *&node, Key &key, idx_t depth, row_t row_id);
+	void Erase(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id);
 	//! Find the node with a matching key, or return nullptr if not found
-	Leaf *Lookup(Node *node, Key &key, idx_t depth);
+	Node Lookup(Node node, const ARTKey &key, idx_t depth);
 	//! Returns all row IDs belonging to a key greater (or equal) than the search key
-	bool SearchGreater(ARTIndexScanState *state, Key &key, bool inclusive, idx_t max_count, vector<row_t> &result_ids);
+	bool SearchGreater(ARTIndexScanState *state, ARTKey &key, bool inclusive, idx_t max_count,
+	                   vector<row_t> &result_ids);
 	//! Returns all row IDs belonging to a key less (or equal) than the upper_bound
-	bool SearchLess(ARTIndexScanState *state, Key &upper_bound, bool inclusive, idx_t max_count,
+	bool SearchLess(ARTIndexScanState *state, ARTKey &upper_bound, bool inclusive, idx_t max_count,
 	                vector<row_t> &result_ids);
 	//! Returns all row IDs belonging to a key within the range of lower_bound and upper_bound
-	bool SearchCloseRange(ARTIndexScanState *state, Key &lower_bound, Key &upper_bound, bool left_inclusive,
+	bool SearchCloseRange(ARTIndexScanState *state, ARTKey &lower_bound, ARTKey &upper_bound, bool left_inclusive,
 	                      bool right_inclusive, idx_t max_count, vector<row_t> &result_ids);
+
+	//! Initializes a merge operation by returning a set containing the buffer count of each fixed-size allocator
+	void InitializeMerge(ARTFlags &flags);
+
+	//! Initializes a vacuum operation by calling the initialize operation of the respective
+	//! node allocator, and returns a vector containing either true, if the allocator at
+	//! the respective position qualifies, or false, if not
+	void InitializeVacuum(ARTFlags &flags);
+	//! Finalizes a vacuum operation by calling the finalize operation of all qualifying
+	//! fixed size allocators
+	void FinalizeVacuum(const ARTFlags &flags);
 };
 
 } // namespace duckdb

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

@@ -17,36 +17,37 @@
 
 namespace duckdb {
 
-class Key {
+class ARTKey {
 public:
-	Key();
-	Key(data_ptr_t data, idx_t len);
-	Key(ArenaAllocator &allocator, idx_t len);
+	ARTKey();
+	ARTKey(const data_ptr_t &data, const uint32_t &len);
+	ARTKey(ArenaAllocator &allocator, const uint32_t &len);
 
-	idx_t len;
+	uint32_t len;
 	data_ptr_t data;
 
 public:
 	template <class T>
-	static inline Key CreateKey(ArenaAllocator &allocator, const LogicalType &type, T element) {
-		auto data = Key::CreateData<T>(allocator, element);
-		return Key(data, sizeof(element));
+	static inline ARTKey CreateARTKey(ArenaAllocator &allocator, const LogicalType &type, T element) {
+		auto data = ARTKey::CreateData<T>(allocator, element);
+		return ARTKey(data, sizeof(element));
 	}
 
 	template <class T>
-	static inline Key CreateKey(ArenaAllocator &allocator, const LogicalType &type, const Value &element) {
-		return CreateKey(allocator, type, element.GetValueUnsafe<T>());
+	static inline ARTKey CreateARTKey(ArenaAllocator &allocator, const LogicalType &type, const Value &element) {
+		return CreateARTKey(allocator, type, element.GetValueUnsafe<T>());
 	}
 
 	template <class T>
-	static inline void CreateKey(ArenaAllocator &allocator, const LogicalType &type, Key &key, T element) {
-		key.data = Key::CreateData<T>(allocator, element);
+	static inline void CreateARTKey(ArenaAllocator &allocator, const LogicalType &type, ARTKey &key, T element) {
+		key.data = ARTKey::CreateData<T>(allocator, element);
 		key.len = sizeof(element);
 	}
 
 	template <class T>
-	static inline void CreateKey(ArenaAllocator &allocator, const LogicalType &type, Key &key, const Value element) {
-		key.data = Key::CreateData<T>(allocator, element.GetValueUnsafe<T>());
+	static inline void CreateARTKey(ArenaAllocator &allocator, const LogicalType &type, ARTKey &key,
+	                                const Value element) {
+		key.data = ARTKey::CreateData<T>(allocator, element.GetValueUnsafe<T>());
 		key.len = sizeof(element);
 	}
 
@@ -57,14 +58,18 @@ public:
 	const data_t &operator[](size_t i) const {
 		return data[i];
 	}
-	bool operator>(const Key &k) const;
-	bool operator<(const Key &k) const;
-	bool operator>=(const Key &k) const;
-	bool operator==(const Key &k) const;
+	bool operator>(const ARTKey &k) const;
+	bool operator<(const ARTKey &k) const;
+	bool operator>=(const ARTKey &k) const;
+	bool operator==(const ARTKey &k) const;
 
-	bool ByteMatches(Key &other, idx_t &depth);
-	bool Empty();
-	void ConcatenateKey(ArenaAllocator &allocator, Key &concat_key);
+	inline bool ByteMatches(const ARTKey &other, const uint32_t &depth) const {
+		return data[depth] == other[depth];
+	}
+	inline bool Empty() const {
+		return len == 0;
+	}
+	void ConcatenateARTKey(ArenaAllocator &allocator, ARTKey &concat_key);
 
 private:
 	template <class T>
@@ -76,9 +81,9 @@ private:
 };
 
 template <>
-Key Key::CreateKey(ArenaAllocator &allocator, const LogicalType &type, string_t value);
+ARTKey ARTKey::CreateARTKey(ArenaAllocator &allocator, const LogicalType &type, string_t value);
 template <>
-Key Key::CreateKey(ArenaAllocator &allocator, const LogicalType &type, const char *value);
+ARTKey ARTKey::CreateARTKey(ArenaAllocator &allocator, const LogicalType &type, const char *value);
 template <>
-void Key::CreateKey(ArenaAllocator &allocator, const LogicalType &type, Key &key, string_t value);
+void ARTKey::CreateARTKey(ArenaAllocator &allocator, const LogicalType &type, ARTKey &key, string_t value);
 } // namespace duckdb