duckdb 0.7.2-dev2507.0 → 0.7.2-dev2675.0

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/type_catalog_entry.hpp

@@ -24,7 +24,7 @@ public:
 
 public:
 	//! Create a TypeCatalogEntry and initialize storage for it
-	TypeCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateTypeInfo *info);
+	TypeCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateTypeInfo &info);
 
 	LogicalType user_type;
 

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/view_catalog_entry.hpp

@@ -26,7 +26,7 @@ public:
 
 public:
 	//! Create a real TableCatalogEntry and initialize storage for it
-	ViewCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateViewInfo *info);
+	ViewCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateViewInfo &info);
 
 	//! The query of the view
 	unique_ptr<SelectStatement> query;
@@ -38,7 +38,7 @@ public:
 	vector<LogicalType> types;
 
 public:
-	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo *info) override;
+	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo &info) override;
 
 	//! Serialize the meta information of the ViewCatalogEntry a serializer
 	virtual void Serialize(Serializer &serializer) const;
@@ -50,6 +50,6 @@ public:
 	string ToSQL() const override;
 
 private:
-	void Initialize(CreateViewInfo *info);
+	void Initialize(CreateViewInfo &info);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/catalog/catalog_entry.hpp

@@ -12,6 +12,7 @@
 #include "duckdb/common/enums/catalog_type.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/atomic.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 #include <memory>
 
 namespace duckdb {
@@ -19,21 +20,21 @@ struct AlterInfo;
 class Catalog;
 class CatalogSet;
 class ClientContext;
+class SchemaCatalogEntry;
 
 //! Abstract base class of an entry in the catalog
 class CatalogEntry {
 public:
-	CatalogEntry(CatalogType type, Catalog *catalog, string name);
+	CatalogEntry(CatalogType type, Catalog &catalog, string name);
+	CatalogEntry(CatalogType type, string name, idx_t oid);
 	virtual ~CatalogEntry();
 
 	//! The oid of the entry
 	idx_t oid;
 	//! The type of this catalog entry
 	CatalogType type;
-	//! Reference to the catalog this entry belongs to
-	Catalog *catalog;
 	//! Reference to the catalog set this entry is stored in
-	CatalogSet *set;
+	optional_ptr<CatalogSet> set;
 	//! The name of the entry
 	string name;
 	//! Whether or not the object is deleted
@@ -47,11 +48,11 @@ public:
 	//! Child entry
 	unique_ptr<CatalogEntry> child;
 	//! Parent entry (the node that dependents_map this node)
-	CatalogEntry *parent;
+	optional_ptr<CatalogEntry> parent;
 
 public:
-	virtual unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo *info);
-	virtual void UndoAlter(ClientContext &context, AlterInfo *info);
+	virtual unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo &info);
+	virtual void UndoAlter(ClientContext &context, AlterInfo &info);
 
 	virtual unique_ptr<CatalogEntry> Copy(ClientContext &context) const;
 
@@ -62,6 +63,9 @@ public:
 	//! Convert the catalog entry to a SQL string that can be used to re-construct the catalog entry
 	virtual string ToSQL() const;
 
+	virtual Catalog &ParentCatalog();
+	virtual SchemaCatalogEntry &ParentSchema();
+
 	virtual void Verify(Catalog &catalog);
 
 public:
@@ -76,4 +80,21 @@ public:
 		return (const TARGET &)*this;
 	}
 };
+
+class InCatalogEntry : public CatalogEntry {
+public:
+	InCatalogEntry(CatalogType type, Catalog &catalog, string name);
+	~InCatalogEntry() override;
+
+	//! The catalog the entry belongs to
+	Catalog &catalog;
+
+public:
+	Catalog &ParentCatalog() override {
+		return catalog;
+	}
+
+	void Verify(Catalog &catalog) override;
+};
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/catalog/catalog_set.hpp

@@ -79,7 +79,7 @@ public:
 	DUCKDB_API bool CreateEntry(ClientContext &context, const string &name, unique_ptr<CatalogEntry> value,
 	                            DependencyList &dependencies);
 
-	DUCKDB_API bool AlterEntry(CatalogTransaction transaction, const string &name, AlterInfo *alter_info);
+	DUCKDB_API bool AlterEntry(CatalogTransaction transaction, const string &name, AlterInfo &alter_info);
 
 	DUCKDB_API bool DropEntry(CatalogTransaction transaction, const string &name, bool cascade,
 	                          bool allow_drop_internal = false);
@@ -88,13 +88,13 @@ public:
 
 	DUCKDB_API DuckCatalog &GetCatalog();
 
-	bool AlterOwnership(CatalogTransaction transaction, ChangeOwnershipInfo *info);
+	bool AlterOwnership(CatalogTransaction transaction, ChangeOwnershipInfo &info);
 
-	void CleanupEntry(CatalogEntry *catalog_entry);
+	void CleanupEntry(CatalogEntry &catalog_entry);
 
 	//! Returns the entry with the specified name
-	DUCKDB_API CatalogEntry *GetEntry(CatalogTransaction transaction, const string &name);
-	DUCKDB_API CatalogEntry *GetEntry(ClientContext &context, const string &name);
+	DUCKDB_API optional_ptr<CatalogEntry> GetEntry(CatalogTransaction transaction, const string &name);
+	DUCKDB_API optional_ptr<CatalogEntry> GetEntry(ClientContext &context, const string &name);
 
 	//! Gets the entry that is most similar to the given name (i.e. smallest levenshtein distance), or empty string if
 	//! none is found. The returned pair consists of the entry name and the distance (smaller means closer).
@@ -105,15 +105,15 @@ public:
 	void Undo(CatalogEntry &entry);
 
 	//! Scan the catalog set, invoking the callback method for every committed entry
-	DUCKDB_API void Scan(const std::function<void(CatalogEntry *)> &callback);
+	DUCKDB_API void Scan(const std::function<void(CatalogEntry &)> &callback);
 	//! Scan the catalog set, invoking the callback method for every entry
-	DUCKDB_API void Scan(CatalogTransaction transaction, const std::function<void(CatalogEntry *)> &callback);
-	DUCKDB_API void Scan(ClientContext &context, const std::function<void(CatalogEntry *)> &callback);
+	DUCKDB_API void Scan(CatalogTransaction transaction, const std::function<void(CatalogEntry &)> &callback);
+	DUCKDB_API void Scan(ClientContext &context, const std::function<void(CatalogEntry &)> &callback);
 
 	template <class T>
-	vector<T *> GetEntries(CatalogTransaction transaction) {
-		vector<T *> result;
-		Scan(transaction, [&](CatalogEntry *entry) { result.push_back((T *)entry); });
+	vector<reference<T>> GetEntries(CatalogTransaction transaction) {
+		vector<reference<T>> result;
+		Scan(transaction, [&](CatalogEntry &entry) { result.push_back(entry.Cast<T>()); });
 		return result;
 	}
 
@@ -132,15 +132,15 @@ private:
 	//! Adjust User dependency
 	void AdjustUserDependency(CatalogEntry &entry, ColumnDefinition &column, bool remove);
 	//! Given a root entry, gets the entry valid for this transaction
-	CatalogEntry *GetEntryForTransaction(CatalogTransaction transaction, CatalogEntry *current);
-	CatalogEntry *GetCommittedEntry(CatalogEntry *current);
-	bool GetEntryInternal(CatalogTransaction transaction, const string &name, EntryIndex *entry_index,
-	                      CatalogEntry *&entry);
-	bool GetEntryInternal(CatalogTransaction transaction, EntryIndex &entry_index, CatalogEntry *&entry);
+	CatalogEntry &GetEntryForTransaction(CatalogTransaction transaction, CatalogEntry &current);
+	CatalogEntry &GetCommittedEntry(CatalogEntry &current);
+	optional_ptr<CatalogEntry> GetEntryInternal(CatalogTransaction transaction, const string &name,
+	                                            EntryIndex *entry_index);
+	optional_ptr<CatalogEntry> GetEntryInternal(CatalogTransaction transaction, EntryIndex &entry_index);
 	//! Drops an entry from the catalog set; must hold the catalog_lock to safely call this
 	void DropEntryInternal(CatalogTransaction transaction, EntryIndex entry_index, CatalogEntry &entry, bool cascade);
-	CatalogEntry *CreateEntryInternal(CatalogTransaction transaction, unique_ptr<CatalogEntry> entry);
-	MappingValue *GetMapping(CatalogTransaction transaction, const string &name, bool get_latest = false);
+	optional_ptr<CatalogEntry> CreateEntryInternal(CatalogTransaction transaction, unique_ptr<CatalogEntry> entry);
+	optional_ptr<MappingValue> GetMapping(CatalogTransaction transaction, const string &name, bool get_latest = false);
 	void PutMapping(CatalogTransaction transaction, const string &name, EntryIndex entry_index);
 	void DeleteMapping(CatalogTransaction transaction, const string &name);
 	void DropEntryDependencies(CatalogTransaction transaction, EntryIndex &entry_index, CatalogEntry &entry,
@@ -149,7 +149,8 @@ private:
 	//! Create all default entries
 	void CreateDefaultEntries(CatalogTransaction transaction, unique_lock<mutex> &lock);
 	//! Attempt to create a default entry with the specified name. Returns the entry if successful, nullptr otherwise.
-	CatalogEntry *CreateDefaultEntry(CatalogTransaction transaction, const string &name, unique_lock<mutex> &lock);
+	optional_ptr<CatalogEntry> CreateDefaultEntry(CatalogTransaction transaction, const string &name,
+	                                              unique_lock<mutex> &lock);
 
 	EntryIndex PutEntry(idx_t entry_index, unique_ptr<CatalogEntry> entry);
 	void PutEntry(EntryIndex index, unique_ptr<CatalogEntry> entry);

package/src/duckdb/src/include/duckdb/catalog/duck_catalog.hpp

@@ -33,13 +33,13 @@ public:
 	}
 
 public:
-	DUCKDB_API CatalogEntry *CreateSchema(CatalogTransaction transaction, CreateSchemaInfo *info) override;
-	DUCKDB_API void ScanSchemas(ClientContext &context, std::function<void(CatalogEntry *)> callback) override;
-	DUCKDB_API void ScanSchemas(std::function<void(CatalogEntry *)> callback);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateSchema(CatalogTransaction transaction, CreateSchemaInfo &info) override;
+	DUCKDB_API void ScanSchemas(ClientContext &context, std::function<void(SchemaCatalogEntry &)> callback) override;
+	DUCKDB_API void ScanSchemas(std::function<void(SchemaCatalogEntry &)> callback);
 
-	DUCKDB_API SchemaCatalogEntry *GetSchema(CatalogTransaction transaction, const string &schema_name,
-	                                         bool if_exists = false,
-	                                         QueryErrorContext error_context = QueryErrorContext()) override;
+	DUCKDB_API optional_ptr<SchemaCatalogEntry>
+	GetSchema(CatalogTransaction transaction, const string &schema_name, OnEntryNotFound if_not_found,
+	          QueryErrorContext error_context = QueryErrorContext()) override;
 
 	DUCKDB_API unique_ptr<PhysicalOperator> PlanCreateTableAs(ClientContext &context, LogicalCreateTable &op,
 	                                                          unique_ptr<PhysicalOperator> plan) override;
@@ -59,9 +59,9 @@ public:
 	DUCKDB_API string GetDBPath() override;
 
 private:
-	DUCKDB_API void DropSchema(CatalogTransaction transaction, DropInfo *info);
-	DUCKDB_API void DropSchema(ClientContext &context, DropInfo *info) override;
-	CatalogEntry *CreateSchemaInternal(CatalogTransaction transaction, CreateSchemaInfo *info);
+	DUCKDB_API void DropSchema(CatalogTransaction transaction, DropInfo &info);
+	DUCKDB_API void DropSchema(ClientContext &context, DropInfo &info) override;
+	optional_ptr<CatalogEntry> CreateSchemaInternal(CatalogTransaction transaction, CreateSchemaInfo &info);
 	void Verify() override;
 
 private:

package/src/duckdb/src/include/duckdb/catalog/similar_catalog_entry.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
 namespace duckdb {
 class SchemaCatalogEntry;
@@ -20,7 +21,7 @@ struct SimilarCatalogEntry {
 	//! The distance to the given name.
 	idx_t distance = idx_t(-1);
 	//! The schema of the entry.
-	SchemaCatalogEntry *schema = nullptr;
+	optional_ptr<SchemaCatalogEntry> schema;
 
 	DUCKDB_API bool Found() const {
 		return !name.empty();

package/src/duckdb/src/include/duckdb/catalog/standard_entry.hpp

@@ -14,15 +14,21 @@ namespace duckdb {
 class SchemaCatalogEntry;
 
 //! A StandardEntry is a catalog entry that is a member of a schema
-class StandardEntry : public CatalogEntry {
+class StandardEntry : public InCatalogEntry {
 public:
-	StandardEntry(CatalogType type, SchemaCatalogEntry *schema, Catalog *catalog, string name)
-	    : CatalogEntry(type, catalog, name), schema(schema) {
+	StandardEntry(CatalogType type, SchemaCatalogEntry &schema, Catalog &catalog, string name)
+	    : InCatalogEntry(type, catalog, name), schema(schema) {
 	}
 	~StandardEntry() override {
 	}
 
 	//! The schema the entry belongs to
-	SchemaCatalogEntry *schema;
+	SchemaCatalogEntry &schema;
+
+public:
+	SchemaCatalogEntry &ParentSchema() override {
+		return schema;
+	}
 };
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/on_entry_not_found.hpp

@@ -0,0 +1,17 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/on_entry_not_found.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/constants.hpp"
+
+namespace duckdb {
+
+enum class OnEntryNotFound : uint8_t { THROW_EXCEPTION = 0, RETURN_NULL = 1 };
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/queue.hpp

@@ -12,4 +12,4 @@
 
 namespace duckdb {
 using std::queue;
-}
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types.hpp

@@ -10,6 +10,7 @@
 
 #include "duckdb/common/assert.hpp"
 #include "duckdb/common/constants.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 #include "duckdb/common/vector.hpp"
 
 #include <limits>
@@ -326,8 +327,6 @@ struct LogicalType {
 	DUCKDB_API string GetAlias() const;
 
 	DUCKDB_API static LogicalType MaxLogicalType(const LogicalType &left, const LogicalType &right);
-	DUCKDB_API static void SetCatalog(LogicalType &type, TypeCatalogEntry* catalog_entry);
-	DUCKDB_API static TypeCatalogEntry* GetCatalog(const LogicalType &type);
 
 	DUCKDB_API static ExtraTypeInfoType GetExtraTypeInfoType(const ExtraTypeInfo &type);
 
@@ -426,8 +425,8 @@ struct EnumType{
 	DUCKDB_API static const Vector &GetValuesInsertOrder(const LogicalType &type);
 	DUCKDB_API static idx_t GetSize(const LogicalType &type);
 	DUCKDB_API static const string GetValue(const Value &val);
-	DUCKDB_API static void SetCatalog(LogicalType &type, TypeCatalogEntry* catalog_entry);
-	DUCKDB_API static TypeCatalogEntry* GetCatalog(const LogicalType &type);
+	DUCKDB_API static void SetCatalog(LogicalType &type, optional_ptr<TypeCatalogEntry> catalog_entry);
+	DUCKDB_API static optional_ptr<TypeCatalogEntry> GetCatalog(const LogicalType &type);
 	DUCKDB_API static string GetSchemaName(const LogicalType &type);
 	DUCKDB_API static PhysicalType GetPhysicalType(const LogicalType &type);
 	DUCKDB_API static void Serialize(FieldWriter& writer, const ExtraTypeInfo& type_info, bool serialize_internals);

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

@@ -8,56 +8,54 @@
 
 #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;
-
+// 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
@@ -72,22 +70,25 @@ public:
 	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;
 
+	//! 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);
@@ -96,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