duckdb 0.9.3-dev2.0 → 0.10.0

package/src/duckdb/src/function/table_function.cpp

@@ -18,7 +18,7 @@ TableFunction::TableFunction(string name, vector<LogicalType> arguments, table_f
       init_global(init_global), init_local(init_local), function(function), in_out_function(nullptr),
       in_out_function_final(nullptr), statistics(nullptr), dependency(nullptr), cardinality(nullptr),
       pushdown_complex_filter(nullptr), to_string(nullptr), table_scan_progress(nullptr), get_batch_index(nullptr),
-      get_batch_info(nullptr), serialize(nullptr), deserialize(nullptr), projection_pushdown(false),
+      get_bind_info(nullptr), serialize(nullptr), deserialize(nullptr), projection_pushdown(false),
       filter_pushdown(false), filter_prune(false) {
 }
 
@@ -31,7 +31,7 @@ TableFunction::TableFunction()
     : SimpleNamedParameterFunction("", {}), bind(nullptr), bind_replace(nullptr), init_global(nullptr),
       init_local(nullptr), function(nullptr), in_out_function(nullptr), statistics(nullptr), dependency(nullptr),
       cardinality(nullptr), pushdown_complex_filter(nullptr), to_string(nullptr), table_scan_progress(nullptr),
-      get_batch_index(nullptr), get_batch_info(nullptr), serialize(nullptr), deserialize(nullptr),
+      get_batch_index(nullptr), get_bind_info(nullptr), serialize(nullptr), deserialize(nullptr),
       projection_pushdown(false), filter_pushdown(false), filter_prune(false) {
 }
 

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

@@ -16,6 +16,7 @@
 #include "duckdb/common/atomic.hpp"
 #include "duckdb/common/optional_ptr.hpp"
 #include "duckdb/common/enums/on_entry_not_found.hpp"
+#include "duckdb/common/exception/catalog_exception.hpp"
 #include <functional>
 
 namespace duckdb {
@@ -238,7 +239,7 @@ public:
 			return nullptr;
 		}
 		if (entry->type != T::Type) {
-			throw CatalogException(error_context.FormatError("%s is not an %s", name, T::Name));
+			throw CatalogException(error_context, "%s is not an %s", name, T::Name);
 		}
 		return &entry->template Cast<T>();
 	}
@@ -282,7 +283,7 @@ public:
 			return nullptr;
 		}
 		if (entry->type != T::Type) {
-			throw CatalogException(error_context.FormatError("%s is not an %s", name, T::Name));
+			throw CatalogException(error_context, "%s is not an %s", name, T::Name);
 		}
 		return &entry->template Cast<T>();
 	}
@@ -306,7 +307,7 @@ public:
 	//! Autoload the extension required for `configuration_name` or throw a CatalogException
 	static void AutoloadExtensionByConfigName(ClientContext &context, const string &configuration_name);
 	//! Autoload the extension required for `function_name` or throw a CatalogException
-	static bool AutoLoadExtensionByCatalogEntry(ClientContext &context, CatalogType type, const string &entry_name);
+	static bool AutoLoadExtensionByCatalogEntry(DatabaseInstance &db, CatalogType type, const string &entry_name);
 	DUCKDB_API static bool TryAutoLoad(ClientContext &context, const string &extension_name) noexcept;
 
 protected:

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

@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/catalog/catalog_entry.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/catalog/catalog_entry/dependency/dependency_entry.hpp"
+
+namespace duckdb {
+
+class DependencyDependentEntry : public DependencyEntry {
+public:
+	~DependencyDependentEntry() override;
+	DependencyDependentEntry(Catalog &catalog, const DependencyInfo &info);
+
+public:
+	const CatalogEntryInfo &EntryInfo() const override;
+	const MangledEntryName &EntryMangledName() const override;
+	const CatalogEntryInfo &SourceInfo() const override;
+	const MangledEntryName &SourceMangledName() const override;
+};
+
+} // namespace duckdb

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

@@ -0,0 +1,66 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/catalog/catalog_entry.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/enums/catalog_type.hpp"
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/atomic.hpp"
+#include "duckdb/common/optional_ptr.hpp"
+#include "duckdb/catalog/catalog_entry.hpp"
+#include "duckdb/catalog/catalog_set.hpp"
+#include "duckdb/catalog/dependency.hpp"
+#include "duckdb/catalog/dependency_manager.hpp"
+#include <memory>
+
+namespace duckdb {
+
+class DependencyManager;
+
+class DependencySetCatalogEntry;
+
+//! Resembles a connection between an object and the CatalogEntry that can be retrieved from the Catalog using the
+//! identifiers listed here
+
+enum class DependencyEntryType : uint8_t { SUBJECT, DEPENDENT };
+
+class DependencyEntry : public InCatalogEntry {
+public:
+	~DependencyEntry() override;
+
+protected:
+	DependencyEntry(Catalog &catalog, DependencyEntryType type, const MangledDependencyName &name,
+	                const DependencyInfo &info);
+
+public:
+	const MangledEntryName &SubjectMangledName() const;
+	const DependencySubject &Subject() const;
+
+	const MangledEntryName &DependentMangledName() const;
+	const DependencyDependent &Dependent() const;
+
+	virtual const CatalogEntryInfo &EntryInfo() const = 0;
+	virtual const MangledEntryName &EntryMangledName() const = 0;
+	virtual const CatalogEntryInfo &SourceInfo() const = 0;
+	virtual const MangledEntryName &SourceMangledName() const = 0;
+
+public:
+	DependencyEntryType Side() const;
+
+protected:
+	const MangledEntryName dependent_name;
+	const MangledEntryName subject_name;
+	const DependencyDependent dependent;
+	const DependencySubject subject;
+
+private:
+	DependencyEntryType side;
+};
+
+} // namespace duckdb

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

@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/catalog/catalog_entry.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/catalog/catalog_entry/dependency/dependency_entry.hpp"
+
+namespace duckdb {
+
+class DependencySubjectEntry : public DependencyEntry {
+public:
+	~DependencySubjectEntry() override;
+	DependencySubjectEntry(Catalog &catalog, const DependencyInfo &info);
+
+public:
+	const CatalogEntryInfo &EntryInfo() const override;
+	const MangledEntryName &EntryMangledName() const override;
+	const CatalogEntryInfo &SourceInfo() const override;
+	const MangledEntryName &SourceMangledName() const override;
+};
+
+} // namespace duckdb

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

@@ -12,19 +12,39 @@
 
 namespace duckdb {
 
-//! An index catalog entry
+//! Wrapper class to allow copying a DuckIndexEntry (for altering the DuckIndexEntry metadata such as comments)
+struct IndexDataTableInfo {
+	IndexDataTableInfo(shared_ptr<DataTableInfo> &info_p, const string &index_name_p);
+	~IndexDataTableInfo();
+
+	//! Pointer to the DataTableInfo
+	shared_ptr<DataTableInfo> info;
+	//! The index to be removed on destruction
+	string index_name;
+};
+
+//! A duck index entry
 class DuckIndexEntry : public IndexCatalogEntry {
 public:
-	//! Create an IndexCatalogEntry and initialize storage for it
+	//! Create a DuckIndexEntry
 	DuckIndexEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateIndexInfo &info);
-	~DuckIndexEntry();
 
-	shared_ptr<DataTableInfo> info;
+	virtual unique_ptr<CatalogEntry> Copy(ClientContext &context) const override;
+
+	//! The indexed table information
+	shared_ptr<IndexDataTableInfo> info;
+
+	//! We need the initial size of the index after the CREATE INDEX statement,
+	//! as it is necessary to determine the auto checkpoint threshold
+	idx_t initial_index_size;
 
 public:
 	string GetSchemaName() const override;
 	string GetTableName() const override;
-	//! This drops in-memory index data and marks all blocks on disk as free blocks, allowing to reclaim them
+
+	DataTableInfo &GetDataTableInfo() const;
+
+	//! Drops in-memory index data and marks all blocks on disk as free blocks, allowing to reclaim them
 	void CommitDrop();
 };
 

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

@@ -15,7 +15,7 @@ namespace duckdb {
 //! A schema in the catalog
 class DuckSchemaEntry : public SchemaCatalogEntry {
 public:
-	DuckSchemaEntry(Catalog &catalog, string name, bool is_internal);
+	DuckSchemaEntry(Catalog &catalog, CreateSchemaInfo &info);
 
 private:
 	//! The catalog set holding the tables
@@ -64,6 +64,8 @@ public:
 	optional_ptr<CatalogEntry> GetEntry(CatalogTransaction transaction, CatalogType type, const string &name) override;
 	SimilarCatalogEntry GetSimilarEntry(CatalogTransaction transaction, CatalogType type, const string &name) override;
 
+	unique_ptr<CatalogEntry> Copy(ClientContext &context) const override;
+
 	void Verify(Catalog &catalog) override;
 
 private:

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

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/catalog/catalog_entry/dtable_catalog_entry.hpp
+// duckdb/catalog/catalog_entry/duck_table_entry.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -57,6 +57,7 @@ private:
 	unique_ptr<CatalogEntry> DropNotNull(ClientContext &context, DropNotNullInfo &info);
 	unique_ptr<CatalogEntry> AddForeignKeyConstraint(ClientContext &context, AlterForeignKeyInfo &info);
 	unique_ptr<CatalogEntry> DropForeignKeyConstraint(ClientContext &context, AlterForeignKeyInfo &info);
+	unique_ptr<CatalogEntry> SetColumnComment(ClientContext &context, SetColumnCommentInfo &info);
 
 	void UpdateConstraintsOnColumnDrop(const LogicalIndex &removed_index, const vector<LogicalIndex> &adjusted_indices,
 	                                   const RemoveColumnInfo &info, CreateTableInfo &create_info, bool is_generated);

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

@@ -10,12 +10,10 @@
 
 #include "duckdb/catalog/standard_entry.hpp"
 #include "duckdb/parser/parsed_data/create_index_info.hpp"
-#include "duckdb/storage/metadata/metadata_writer.hpp"
 
 namespace duckdb {
 
 struct DataTableInfo;
-class Index;
 
 //! An index catalog entry
 class IndexCatalogEntry : public StandardEntry {
@@ -24,21 +22,37 @@ public:
 	static constexpr const char *Name = "index";
 
 public:
-	//! Create an IndexCatalogEntry and initialize storage for it
+	//! Create an IndexCatalogEntry
 	IndexCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateIndexInfo &info);
 
-	optional_ptr<Index> index;
+	//! The SQL of the CREATE INDEX statement
 	string sql;
+	//! Additional index options
+	case_insensitive_map_t<Value> options;
+
+	//! The index type (ART, B+-tree, Skip-List, ...)
+	string index_type;
+	//! The index constraint type
+	IndexConstraintType index_constraint_type;
+	//! The column ids of the indexed table
+	vector<column_t> column_ids;
+	//! The set of expressions to index by
 	vector<unique_ptr<ParsedExpression>> expressions;
 	vector<unique_ptr<ParsedExpression>> parsed_expressions;
-	case_insensitive_map_t<Value> options;
 
 public:
+	//! Returns the CreateIndexInfo
 	unique_ptr<CreateInfo> GetInfo() const override;
+	//! Returns the original CREATE INDEX SQL
 	string ToSQL() const override;
 
 	virtual string GetSchemaName() const = 0;
 	virtual string GetTableName() const = 0;
+
+	//! Returns true, if this index is UNIQUE
+	bool IsUnique();
+	//! Returns true, if this index is a PRIMARY KEY
+	bool IsPrimary();
 };
 
 } // namespace duckdb

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

@@ -9,4 +9,5 @@
 #include "duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"

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

@@ -23,5 +23,7 @@ public:
 
 public:
 	ScalarMacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info);
+
+	unique_ptr<CatalogEntry> Copy(ClientContext &context) const override;
 };
 } // namespace duckdb

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

@@ -44,7 +44,7 @@ public:
 	static constexpr const char *Name = "schema";
 
 public:
-	SchemaCatalogEntry(Catalog &catalog, string name, bool is_internal);
+	SchemaCatalogEntry(Catalog &catalog, CreateSchemaInfo &info);
 
 public:
 	unique_ptr<CreateInfo> GetInfo() const override;

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

@@ -14,6 +14,7 @@
 #include "duckdb/parser/parsed_data/alter_table_info.hpp"
 
 namespace duckdb {
+class DuckTransaction;
 
 struct SequenceValue {
 	SequenceValue() : usage_count(0), counter(-1) {
@@ -25,18 +26,9 @@ struct SequenceValue {
 	int64_t counter;
 };
 
-//! A sequence catalog entry
-class SequenceCatalogEntry : public StandardEntry {
-public:
-	static constexpr const CatalogType Type = CatalogType::SEQUENCE_ENTRY;
-	static constexpr const char *Name = "sequence";
-
-public:
-	//! Create a real TableCatalogEntry and initialize storage for it
-	SequenceCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateSequenceInfo &info);
+struct SequenceData {
+	explicit SequenceData(CreateSequenceInfo &info);
 
-	//! Lock for getting a value on the sequence
-	mutex lock;
 	//! The amount of times the sequence has been used
 	uint64_t usage_count;
 	//! The sequence counter
@@ -53,10 +45,33 @@ public:
 	int64_t max_value;
 	//! Whether or not the sequence cycles
 	bool cycle;
+};
+
+//! A sequence catalog entry
+class SequenceCatalogEntry : public StandardEntry {
+public:
+	static constexpr const CatalogType Type = CatalogType::SEQUENCE_ENTRY;
+	static constexpr const char *Name = "sequence";
+
+public:
+	//! Create a real TableCatalogEntry and initialize storage for it
+	SequenceCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateSequenceInfo &info);
 
 public:
+	virtual unique_ptr<CatalogEntry> Copy(ClientContext &context) const override;
 	unique_ptr<CreateInfo> GetInfo() const override;
 
+	SequenceData GetData() const;
+	int64_t CurrentValue();
+	int64_t NextValue(DuckTransaction &transaction);
+	void ReplayValue(uint64_t usage_count, int64_t counter);
+
 	string ToSQL() const override;
+
+private:
+	//! Lock for getting a value on the sequence
+	mutable mutex lock;
+	//! Sequence data
+	SequenceData data;
 };
 } // namespace duckdb

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

@@ -32,6 +32,7 @@ struct ChangeColumnTypeInfo;
 struct AlterForeignKeyInfo;
 struct SetNotNullInfo;
 struct DropNotNullInfo;
+struct SetColumnCommentInfo;
 
 class TableFunction;
 struct FunctionData;

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

@@ -22,6 +22,8 @@ public:
 
 public:
 	TableMacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info);
+
+	unique_ptr<CatalogEntry> Copy(ClientContext &context) const override;
 };
 
 } // namespace duckdb

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

@@ -28,6 +28,7 @@ public:
 
 public:
 	unique_ptr<CreateInfo> GetInfo() const override;
+	unique_ptr<CatalogEntry> Copy(ClientContext &context) const override;
 
 	string ToSQL() const override;
 };

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

@@ -36,6 +36,8 @@ public:
 	vector<string> aliases;
 	//! The returned types of the view
 	vector<LogicalType> types;
+	//! The returned names of the view
+	vector<string> names;
 
 public:
 	unique_ptr<CreateInfo> GetInfo() const override;

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

@@ -13,6 +13,8 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/atomic.hpp"
 #include "duckdb/common/optional_ptr.hpp"
+#include "duckdb/common/exception/catalog_exception.hpp"
+#include "duckdb/common/types/value.hpp"
 #include <memory>
 
 namespace duckdb {
@@ -23,6 +25,7 @@ class ClientContext;
 class SchemaCatalogEntry;
 class Serializer;
 class Deserializer;
+class Value;
 
 struct CreateInfo;
 
@@ -49,6 +52,10 @@ public:
 	bool internal;
 	//! Timestamp at which the catalog entry was created
 	atomic<transaction_t> timestamp;
+	//! (optional) comment on this entry
+	Value comment;
+
+private:
 	//! Child entry
 	unique_ptr<CatalogEntry> child;
 	//! Parent entry (the node that dependents_map this node)
@@ -77,6 +84,14 @@ public:
 	void Serialize(Serializer &serializer) const;
 	static unique_ptr<CreateInfo> Deserialize(Deserializer &deserializer);
 
+public:
+	void SetChild(unique_ptr<CatalogEntry> child);
+	unique_ptr<CatalogEntry> TakeChild();
+	bool HasChild() const;
+	bool HasParent() const;
+	CatalogEntry &Child();
+	CatalogEntry &Parent();
+
 public:
 	template <class TARGET>
 	TARGET &Cast() {

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

@@ -27,46 +27,36 @@ struct AlterInfo;
 
 class ClientContext;
 class DependencyList;
-struct MappingValue;
-struct EntryIndex;
 
 class DuckCatalog;
 class TableCatalogEntry;
 class SequenceCatalogEntry;
 
-typedef unordered_map<CatalogSet *, unique_lock<mutex>> set_lock_map_t;
-
-struct EntryValue {
-	EntryValue() {
-		throw InternalException("EntryValue called without a catalog entry");
+class CatalogEntryMap {
+public:
+	CatalogEntryMap() {
 	}
 
-	explicit EntryValue(unique_ptr<CatalogEntry> entry_p) : entry(std::move(entry_p)), reference_count(0) {
-	}
-	//! enable move constructors
-	EntryValue(EntryValue &&other) noexcept {
-		Swap(other);
-	}
-	EntryValue &operator=(EntryValue &&other) noexcept {
-		Swap(other);
-		return *this;
-	}
-	void Swap(EntryValue &other) {
-		std::swap(entry, other.entry);
-		idx_t count = reference_count;
-		reference_count = other.reference_count.load();
-		other.reference_count = count;
-	}
+public:
+	void AddEntry(unique_ptr<CatalogEntry> entry);
+	void UpdateEntry(unique_ptr<CatalogEntry> entry);
+	void DropEntry(CatalogEntry &entry);
+	case_insensitive_tree_t<unique_ptr<CatalogEntry>> &Entries();
+	optional_ptr<CatalogEntry> GetEntry(const string &name);
 
-	unique_ptr<CatalogEntry> entry;
-	atomic<idx_t> reference_count;
+private:
+	//! Mapping of string to catalog entry
+	case_insensitive_tree_t<unique_ptr<CatalogEntry>> entries;
 };
 
 //! The Catalog Set stores (key, value) map of a set of CatalogEntries
 class CatalogSet {
-	friend class DependencyManager;
-	friend class EntryDropper;
-	friend struct EntryIndex;
+public:
+	struct EntryLookup {
+		enum class FailureReason { SUCCESS, DELETED, NOT_PRESENT };
+		optional_ptr<CatalogEntry> result;
+		FailureReason reason;
+	};
 
 public:
 	DUCKDB_API explicit CatalogSet(Catalog &catalog, unique_ptr<DefaultGenerator> defaults = nullptr);
@@ -75,9 +65,9 @@ public:
 	//! Create an entry in the catalog set. Returns whether or not it was
 	//! successful.
 	DUCKDB_API bool CreateEntry(CatalogTransaction transaction, const string &name, unique_ptr<CatalogEntry> value,
-	                            DependencyList &dependencies);
+	                            const DependencyList &dependencies);
 	DUCKDB_API bool CreateEntry(ClientContext &context, const string &name, unique_ptr<CatalogEntry> value,
-	                            DependencyList &dependencies);
+	                            const DependencyList &dependencies);
 
 	DUCKDB_API bool AlterEntry(CatalogTransaction transaction, const string &name, AlterInfo &alter_info);
 
@@ -93,6 +83,7 @@ public:
 	void CleanupEntry(CatalogEntry &catalog_entry);
 
 	//! Returns the entry with the specified name
+	DUCKDB_API EntryLookup GetEntryDetailed(CatalogTransaction transaction, 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);
 
@@ -107,6 +98,8 @@ public:
 	//! Scan the catalog set, invoking the callback method for every committed entry
 	DUCKDB_API void Scan(const std::function<void(CatalogEntry &)> &callback);
 	//! Scan the catalog set, invoking the callback method for every entry
+	DUCKDB_API void ScanWithPrefix(CatalogTransaction transaction, const std::function<void(CatalogEntry &)> &callback,
+	                               const string &prefix);
 	DUCKDB_API void Scan(CatalogTransaction transaction, const std::function<void(CatalogEntry &)> &callback);
 	DUCKDB_API void Scan(ClientContext &context, const std::function<void(CatalogEntry &)> &callback);
 
@@ -117,6 +110,8 @@ public:
 		return result;
 	}
 
+	DUCKDB_API bool CreatedByOtherActiveTransaction(CatalogTransaction transaction, transaction_t timestamp);
+	DUCKDB_API bool CommittedAfterStarting(CatalogTransaction transaction, transaction_t timestamp);
 	DUCKDB_API bool HasConflict(CatalogTransaction transaction, transaction_t timestamp);
 	DUCKDB_API bool UseTimestamp(CatalogTransaction transaction, transaction_t timestamp);
 
@@ -129,20 +124,13 @@ public:
 	void Verify(Catalog &catalog);
 
 private:
+	bool DropDependencies(CatalogTransaction transaction, const string &name, bool cascade,
+	                      bool allow_drop_internal = false);
 	//! Given a root entry, gets the entry valid for this transaction
 	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);
-	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,
-	                           bool cascade);
+	optional_ptr<CatalogEntry> GetEntryInternal(CatalogTransaction transaction, const string &name);
+	optional_ptr<CatalogEntry> CreateCommittedEntry(unique_ptr<CatalogEntry> entry);
 
 	//! Create all default entries
 	void CreateDefaultEntries(CatalogTransaction transaction, unique_lock<mutex> &lock);
@@ -150,19 +138,23 @@ private:
 	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);
+	bool DropEntryInternal(CatalogTransaction transaction, const string &name, bool allow_drop_internal = false);
+
+	bool CreateEntryInternal(CatalogTransaction transaction, const string &name, unique_ptr<CatalogEntry> value,
+	                         unique_lock<mutex> &read_lock, bool should_be_empty = true);
+	void CheckCatalogEntryInvariants(CatalogEntry &value, const string &name);
+	//! Verify that the previous entry in the chain is dropped.
+	bool VerifyVacancy(CatalogTransaction transaction, CatalogEntry &entry);
+	//! Start the catalog entry chain with a dummy node
+	bool StartChain(CatalogTransaction transaction, const string &name, unique_lock<mutex> &read_lock);
+	bool RenameEntryInternal(CatalogTransaction transaction, CatalogEntry &old, const string &new_name,
+	                         AlterInfo &alter_info, unique_lock<mutex> &read_lock);
 
 private:
 	DuckCatalog &catalog;
 	//! The catalog lock is used to make changes to the data
 	mutex catalog_lock;
-	//! The set of catalog entries
-	unordered_map<idx_t, EntryValue> entries;
-	//! Mapping of string to catalog entry
-	case_insensitive_map_t<unique_ptr<MappingValue>> mapping;
-	//! The current catalog entry index
-	idx_t current_entry = 0;
+	CatalogEntryMap map;
 	//! The generator used to generate default internal entries
 	unique_ptr<DefaultGenerator> defaults;
 };

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

@@ -29,6 +29,7 @@ struct CatalogTransaction {
 
 	ClientContext &GetContext();
 
+	static CatalogTransaction GetSystemCatalogTransaction(ClientContext &context);
 	static CatalogTransaction GetSystemTransaction(DatabaseInstance &db);
 };