duckdb 0.9.3-dev2.0 → 0.10.0

package/src/duckdb/src/catalog/catalog_set.cpp

@@ -4,7 +4,6 @@
 #include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
 #include "duckdb/catalog/dependency_manager.hpp"
 #include "duckdb/catalog/duck_catalog.hpp"
-#include "duckdb/catalog/mapping_value.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/serializer/memory_stream.hpp"
 #include "duckdb/common/serializer/binary_serializer.hpp"
@@ -13,33 +12,72 @@
 #include "duckdb/parser/parsed_data/alter_table_info.hpp"
 #include "duckdb/transaction/duck_transaction.hpp"
 #include "duckdb/transaction/transaction_manager.hpp"
+#include "duckdb/catalog/dependency_list.hpp"
+#include "duckdb/common/exception/transaction_exception.hpp"
 
 namespace duckdb {
 
-//! Class responsible to keep track of state when removing entries from the catalog.
-//! When deleting, many types of errors can be thrown, since we want to avoid try/catch blocks
-//! this class makes sure that whatever elements were modified are returned to a correct state
-//! when exceptions are thrown.
-//! The idea here is to use RAII (Resource acquisition is initialization) to mimic a try/catch/finally block.
-//! If any exception is raised when this object exists, then its destructor will be called
-//! and the entry will return to its previous state during deconstruction.
-class EntryDropper {
-public:
-	//! Both constructor and destructor are privates because they should only be called by DropEntryDependencies
-	explicit EntryDropper(EntryIndex &entry_index_p) : entry_index(entry_index_p) {
-		old_deleted = entry_index.GetEntry()->deleted;
+void CatalogEntryMap::AddEntry(unique_ptr<CatalogEntry> entry) {
+	auto name = entry->name;
+
+	if (entries.find(name) != entries.end()) {
+		throw InternalException("Entry with name \"%s\" already exists", name);
 	}
+	entries.insert(make_pair(name, std::move(entry)));
+}
 
-	~EntryDropper() {
-		entry_index.GetEntry()->deleted = old_deleted;
+void CatalogEntryMap::UpdateEntry(unique_ptr<CatalogEntry> catalog_entry) {
+	auto name = catalog_entry->name;
+
+	auto entry = entries.find(name);
+	if (entry == entries.end()) {
+		throw InternalException("Entry with name \"%s\" does not exist", name);
+	}
+
+	auto existing = std::move(entry->second);
+	entry->second = std::move(catalog_entry);
+	entry->second->SetChild(std::move(existing));
+}
+
+case_insensitive_tree_t<unique_ptr<CatalogEntry>> &CatalogEntryMap::Entries() {
+	return entries;
+}
+
+void CatalogEntryMap::DropEntry(CatalogEntry &entry) {
+	auto &name = entry.name;
+	auto chain = GetEntry(name);
+	if (!chain) {
+		throw InternalException("Attempting to drop entry with name \"%s\" but no chain with that name exists", name);
+	}
+	auto child = entry.TakeChild();
+	if (!entry.HasParent()) {
+		// This is the top of the chain
+		D_ASSERT(chain.get() == &entry);
+		auto it = entries.find(name);
+		D_ASSERT(it != entries.end());
+
+		// Remove the entry
+		it->second.reset();
+		if (child) {
+			// Replace it with its child
+			it->second = std::move(child);
+		} else {
+			entries.erase(it);
+		}
+	} else {
+		// Just replace the entry with its child
+		auto &parent = entry.Parent();
+		parent.SetChild(std::move(child));
 	}
+}
 
-private:
-	//! Keeps track of the state of the entry before starting the delete
-	bool old_deleted;
-	//! Index of entry to be deleted
-	EntryIndex &entry_index;
-};
+optional_ptr<CatalogEntry> CatalogEntryMap::GetEntry(const string &name) {
+	auto entry = entries.find(name);
+	if (entry == entries.end()) {
+		return nullptr;
+	}
+	return entry->second.get();
+}
 
 CatalogSet::CatalogSet(Catalog &catalog_p, unique_ptr<DefaultGenerator> defaults)
     : catalog(catalog_p.Cast<DuckCatalog>()), defaults(std::move(defaults)) {
@@ -48,115 +86,142 @@ CatalogSet::CatalogSet(Catalog &catalog_p, unique_ptr<DefaultGenerator> defaults
 CatalogSet::~CatalogSet() {
 }
 
-EntryIndex CatalogSet::PutEntry(idx_t entry_index, unique_ptr<CatalogEntry> entry) {
-	if (entries.find(entry_index) != entries.end()) {
-		throw InternalException("Entry with entry index \"%llu\" already exists", entry_index);
+bool IsDependencyEntry(CatalogEntry &entry) {
+	return entry.type == CatalogType::DEPENDENCY_ENTRY;
+}
+
+bool CatalogSet::StartChain(CatalogTransaction transaction, const string &name, unique_lock<mutex> &read_lock) {
+	D_ASSERT(!map.GetEntry(name));
+
+	// check if there is a default entry
+	auto entry = CreateDefaultEntry(transaction, name, read_lock);
+	if (entry) {
+		return false;
 	}
-	entries.insert(make_pair(entry_index, EntryValue(std::move(entry))));
-	return EntryIndex(*this, entry_index);
+
+	// first create a dummy deleted entry for this entry
+	// so transactions started before the commit of this transaction don't
+	// see it yet
+	auto dummy_node = make_uniq<InCatalogEntry>(CatalogType::INVALID, catalog, name);
+	dummy_node->timestamp = 0;
+	dummy_node->deleted = true;
+	dummy_node->set = this;
+
+	map.AddEntry(std::move(dummy_node));
+	return true;
 }
 
-void CatalogSet::PutEntry(EntryIndex index, unique_ptr<CatalogEntry> catalog_entry) {
-	auto entry = entries.find(index.GetIndex());
-	if (entry == entries.end()) {
-		throw InternalException("Entry with entry index \"%llu\" does not exist", index.GetIndex());
+bool CatalogSet::VerifyVacancy(CatalogTransaction transaction, CatalogEntry &entry) {
+	// if it does, we have to check version numbers
+	if (HasConflict(transaction, entry.timestamp)) {
+		// current version has been written to by a currently active
+		// transaction
+		throw TransactionException("Catalog write-write conflict on create with \"%s\"", entry.name);
 	}
-	catalog_entry->child = std::move(entry->second.entry);
-	catalog_entry->child->parent = catalog_entry.get();
-	entry->second.entry = std::move(catalog_entry);
+	// there is a current version that has been committed
+	// if it has not been deleted there is a conflict
+	if (!entry.deleted) {
+		return false;
+	}
+	return true;
 }
 
-bool CatalogSet::CreateEntry(CatalogTransaction transaction, const string &name, unique_ptr<CatalogEntry> value,
-                             DependencyList &dependencies) {
-	if (value->internal && !catalog.IsSystemCatalog() && name != DEFAULT_SCHEMA) {
+void CatalogSet::CheckCatalogEntryInvariants(CatalogEntry &value, const string &name) {
+	if (value.internal && !catalog.IsSystemCatalog() && name != DEFAULT_SCHEMA) {
 		throw InternalException("Attempting to create internal entry \"%s\" in non-system catalog - internal entries "
 		                        "can only be created in the system catalog",
 		                        name);
 	}
-	if (!value->internal) {
-		if (!value->temporary && catalog.IsSystemCatalog()) {
+	if (!value.internal) {
+		if (!value.temporary && catalog.IsSystemCatalog() && !IsDependencyEntry(value)) {
 			throw InternalException(
 			    "Attempting to create non-internal entry \"%s\" in system catalog - the system catalog "
 			    "can only contain internal entries",
 			    name);
 		}
-		if (value->temporary && !catalog.IsTemporaryCatalog()) {
+		if (value.temporary && !catalog.IsTemporaryCatalog()) {
 			throw InternalException("Attempting to create temporary entry \"%s\" in non-temporary catalog", name);
 		}
-		if (!value->temporary && catalog.IsTemporaryCatalog() && name != DEFAULT_SCHEMA) {
+		if (!value.temporary && catalog.IsTemporaryCatalog() && name != DEFAULT_SCHEMA) {
 			throw InvalidInputException("Cannot create non-temporary entry \"%s\" in temporary catalog", name);
 		}
 	}
-	// lock the catalog for writing
-	lock_guard<mutex> write_lock(catalog.GetWriteLock());
-	// lock this catalog set to disallow reading
-	unique_lock<mutex> read_lock(catalog_lock);
+}
 
-	// first check if the entry exists in the unordered set
-	idx_t index;
-	auto mapping_value = GetMapping(transaction, name);
-	if (mapping_value == nullptr || mapping_value->deleted) {
-		// if it does not: entry has never been created
+optional_ptr<CatalogEntry> CatalogSet::CreateCommittedEntry(unique_ptr<CatalogEntry> entry) {
+	auto existing_entry = map.GetEntry(entry->name);
+	if (existing_entry) {
+		// Return null if an entry by that name already exists
+		return nullptr;
+	}
 
-		// check if there is a default entry
-		auto entry = CreateDefaultEntry(transaction, name, read_lock);
-		if (entry) {
-			return false;
-		}
+	auto catalog_entry = entry.get();
 
-		// first create a dummy deleted entry for this entry
-		// so transactions started before the commit of this transaction don't
-		// see it yet
-		auto dummy_node = make_uniq<InCatalogEntry>(CatalogType::INVALID, value->ParentCatalog(), name);
-		dummy_node->timestamp = 0;
-		dummy_node->deleted = true;
-		dummy_node->set = this;
-
-		auto entry_index = PutEntry(current_entry++, std::move(dummy_node));
-		index = entry_index.GetIndex();
-		PutMapping(transaction, name, std::move(entry_index));
-	} else {
-		index = mapping_value->index.GetIndex();
-		auto &current = *mapping_value->index.GetEntry();
-		// if it does, we have to check version numbers
-		if (HasConflict(transaction, current.timestamp)) {
-			// current version has been written to by a currently active
-			// transaction
-			throw TransactionException("Catalog write-write conflict on create with \"%s\"", current.name);
+	entry->set = this;
+	// Set the timestamp to the first committed transaction
+	entry->timestamp = 0;
+	map.AddEntry(std::move(entry));
+
+	return catalog_entry;
+}
+
+bool CatalogSet::CreateEntryInternal(CatalogTransaction transaction, const string &name, unique_ptr<CatalogEntry> value,
+                                     unique_lock<mutex> &read_lock, bool should_be_empty) {
+	auto entry_value = map.GetEntry(name);
+	if (!entry_value) {
+		// Add a dummy node to start the chain
+		if (!StartChain(transaction, name, read_lock)) {
+			return false;
 		}
-		// there is a current version that has been committed
-		// if it has not been deleted there is a conflict
-		if (!current.deleted) {
+	} else if (should_be_empty) {
+		// Verify that the chain is deleted, not altered by another transaction
+		if (!VerifyVacancy(transaction, *entry_value)) {
 			return false;
 		}
 	}
-	// create a new entry and replace the currently stored one
-	// set the timestamp to the timestamp of the current transaction
-	// and point it at the dummy node
-	value->timestamp = transaction.transaction_id;
-	value->set = this;
-
-	// now add the dependency set of this object to the dependency manager
-	catalog.GetDependencyManager().AddObject(transaction, *value, dependencies);
 
+	// Finally add the new entry to the chain
 	auto value_ptr = value.get();
-	EntryIndex entry_index(*this, index);
-	PutEntry(std::move(entry_index), std::move(value));
+	map.UpdateEntry(std::move(value));
 	// push the old entry in the undo buffer for this transaction
 	if (transaction.transaction) {
 		auto &dtransaction = transaction.transaction->Cast<DuckTransaction>();
-		dtransaction.PushCatalogEntry(*value_ptr->child);
+		dtransaction.PushCatalogEntry(value_ptr->Child());
 	}
 	return true;
 }
 
+bool CatalogSet::CreateEntry(CatalogTransaction transaction, const string &name, unique_ptr<CatalogEntry> value,
+                             const DependencyList &dependencies) {
+	CheckCatalogEntryInvariants(*value, name);
+
+	// Set the timestamp to the timestamp of the current transaction
+	value->timestamp = transaction.transaction_id;
+	value->set = this;
+	// now add the dependency set of this object to the dependency manager
+	catalog.GetDependencyManager().AddObject(transaction, *value, dependencies);
+
+	// lock the catalog for writing
+	lock_guard<mutex> write_lock(catalog.GetWriteLock());
+	// lock this catalog set to disallow reading
+	unique_lock<mutex> read_lock(catalog_lock);
+
+	return CreateEntryInternal(transaction, name, std::move(value), read_lock);
+}
+
 bool CatalogSet::CreateEntry(ClientContext &context, const string &name, unique_ptr<CatalogEntry> value,
-                             DependencyList &dependencies) {
+                             const DependencyList &dependencies) {
 	return CreateEntry(catalog.GetCatalogTransaction(context), name, std::move(value), dependencies);
 }
 
-optional_ptr<CatalogEntry> CatalogSet::GetEntryInternal(CatalogTransaction transaction, EntryIndex &entry_index) {
-	auto &catalog_entry = *entry_index.GetEntry();
+optional_ptr<CatalogEntry> CatalogSet::GetEntryInternal(CatalogTransaction transaction, const string &name) {
+	auto entry_value = map.GetEntry(name);
+	if (!entry_value) {
+		// the entry does not exist, check if we can create a default entry
+		return nullptr;
+	}
+	auto &catalog_entry = *entry_value;
+
 	// if it does: we have to retrieve the entry and to check version numbers
 	if (HasConflict(transaction, catalog_entry.timestamp)) {
 		// current version has been written to by a currently active
@@ -172,162 +237,181 @@ optional_ptr<CatalogEntry> CatalogSet::GetEntryInternal(CatalogTransaction trans
 	return &catalog_entry;
 }
 
-optional_ptr<CatalogEntry> CatalogSet::GetEntryInternal(CatalogTransaction transaction, const string &name,
-                                                        EntryIndex *entry_index) {
-	auto mapping_value = GetMapping(transaction, name);
-	if (mapping_value == nullptr || mapping_value->deleted) {
-		// the entry does not exist, check if we can create a default entry
-		return nullptr;
-	}
-	if (entry_index) {
-		*entry_index = mapping_value->index.Copy();
-	}
-	return GetEntryInternal(transaction, mapping_value->index);
-}
-
 bool CatalogSet::AlterOwnership(CatalogTransaction transaction, ChangeOwnershipInfo &info) {
-	auto entry = GetEntryInternal(transaction, info.name, nullptr);
+	// lock the catalog for writing
+	unique_lock<mutex> write_lock(catalog.GetWriteLock());
+
+	auto entry = GetEntryInternal(transaction, info.name);
 	if (!entry) {
 		return false;
 	}
 
 	auto &owner_entry = catalog.GetEntry(transaction.GetContext(), info.owner_schema, info.owner_name);
+	write_lock.unlock();
 	catalog.GetDependencyManager().AddOwnership(transaction, owner_entry, *entry);
 	return true;
 }
 
+bool CatalogSet::RenameEntryInternal(CatalogTransaction transaction, CatalogEntry &old, const string &new_name,
+                                     AlterInfo &alter_info, unique_lock<mutex> &read_lock) {
+	auto &original_name = old.name;
+
+	auto &context = *transaction.context;
+	auto entry_value = map.GetEntry(new_name);
+	if (entry_value) {
+		auto &existing_entry = GetEntryForTransaction(transaction, *entry_value);
+		if (!existing_entry.deleted) {
+			// There exists an entry by this name that is not deleted
+			old.UndoAlter(context, alter_info);
+			throw CatalogException("Could not rename \"%s\" to \"%s\": another entry with this name already exists!",
+			                       original_name, new_name);
+		}
+	}
+
+	// Add a RENAMED_ENTRY before adding a DELETED_ENTRY, this makes it so that when this is committed
+	// we know that this was not a DROP statement.
+	auto renamed_tombstone = make_uniq<InCatalogEntry>(CatalogType::RENAMED_ENTRY, old.ParentCatalog(), original_name);
+	renamed_tombstone->timestamp = transaction.transaction_id;
+	renamed_tombstone->deleted = false;
+	renamed_tombstone->set = this;
+	if (!CreateEntryInternal(transaction, original_name, std::move(renamed_tombstone), read_lock,
+	                         /*should_be_empty = */ false)) {
+		return false;
+	}
+	if (!DropEntryInternal(transaction, original_name, false)) {
+		return false;
+	}
+
+	// Add the renamed entry
+	// Start this off with a RENAMED_ENTRY node, for commit/cleanup/rollback purposes
+	auto renamed_node = make_uniq<InCatalogEntry>(CatalogType::RENAMED_ENTRY, catalog, new_name);
+	renamed_node->timestamp = transaction.transaction_id;
+	renamed_node->deleted = false;
+	renamed_node->set = this;
+	return CreateEntryInternal(transaction, new_name, std::move(renamed_node), read_lock);
+}
+
 bool CatalogSet::AlterEntry(CatalogTransaction transaction, const string &name, AlterInfo &alter_info) {
 	// lock the catalog for writing
-	lock_guard<mutex> write_lock(catalog.GetWriteLock());
+	unique_lock<mutex> write_lock(catalog.GetWriteLock());
 	// lock this catalog set to disallow reading
-	lock_guard<mutex> read_lock(catalog_lock);
+	unique_lock<mutex> read_lock(catalog_lock);
 
-	// first check if the entry exists in the unordered set
-	EntryIndex entry_index;
-	auto entry = GetEntryInternal(transaction, name, &entry_index);
+	// If the entry does not exist, we error
+	auto entry = GetEntryInternal(transaction, name);
 	if (!entry) {
 		return false;
 	}
 	if (!alter_info.allow_internal && entry->internal) {
 		throw CatalogException("Cannot alter entry \"%s\" because it is an internal system entry", entry->name);
 	}
-
-	// create a new entry and replace the currently stored one
-	// set the timestamp to the timestamp of the current transaction
-	// and point it to the updated table node
-	string original_name = entry->name;
 	if (!transaction.context) {
 		throw InternalException("Cannot AlterEntry without client context");
 	}
+
 	auto &context = *transaction.context;
-	auto value = entry->AlterEntry(context, alter_info);
-	if (!value) {
-		// alter failed, but did not result in an error
-		return true;
-	}
 
-	if (value->name != original_name) {
-		auto mapping_value = GetMapping(transaction, value->name);
-		if (mapping_value && !mapping_value->deleted) {
-			auto &original_entry = GetEntryForTransaction(transaction, *mapping_value->index.GetEntry());
-			if (!original_entry.deleted) {
-				entry->UndoAlter(context, alter_info);
-				string rename_err_msg =
-				    "Could not rename \"%s\" to \"%s\": another entry with this name already exists!";
-				throw CatalogException(rename_err_msg, original_name, value->name);
-			}
+	unique_ptr<CatalogEntry> value;
+	if (alter_info.type == AlterType::SET_COMMENT) {
+		// Copy the existing entry; we are only changing metadata here
+		value = entry->Copy(context);
+		value->comment = alter_info.Cast<SetCommentInfo>().comment_value;
+	} else {
+		// Use the existing entry to create the altered entry
+		value = entry->AlterEntry(context, alter_info);
+		if (!value) {
+			// alter failed, but did not result in an error
+			return true;
 		}
 	}
 
-	if (value->name != original_name) {
-		// Do PutMapping and DeleteMapping after dependency check
-		PutMapping(transaction, value->name, entry_index.Copy());
-		DeleteMapping(transaction, original_name);
-	}
-
+	// Mark this entry as being created by this transaction
 	value->timestamp = transaction.transaction_id;
 	value->set = this;
-	auto new_entry = value.get();
-	PutEntry(std::move(entry_index), std::move(value));
 
-	// serialize the AlterInfo into a temporary buffer
-	MemoryStream stream;
-	BinarySerializer serializer(stream);
-	serializer.Begin();
-	serializer.WriteProperty(100, "column_name", alter_info.GetColumnName());
-	serializer.WriteProperty(101, "alter_info", &alter_info);
-	serializer.End();
+	if (!StringUtil::CIEquals(value->name, entry->name)) {
+		if (!RenameEntryInternal(transaction, *entry, value->name, alter_info, read_lock)) {
+			return false;
+		}
+	}
+	auto new_entry = value.get();
+	map.UpdateEntry(std::move(value));
 
 	// push the old entry in the undo buffer for this transaction
 	if (transaction.transaction) {
+		// serialize the AlterInfo into a temporary buffer
+		MemoryStream stream;
+		BinarySerializer serializer(stream);
+		serializer.Begin();
+		serializer.WriteProperty(100, "column_name", alter_info.GetColumnName());
+		serializer.WriteProperty(101, "alter_info", &alter_info);
+		serializer.End();
+
 		auto &dtransaction = transaction.transaction->Cast<DuckTransaction>();
-		dtransaction.PushCatalogEntry(*new_entry->child, stream.GetData(), stream.GetPosition());
+		dtransaction.PushCatalogEntry(new_entry->Child(), stream.GetData(), stream.GetPosition());
 	}
 
+	read_lock.unlock();
+	write_lock.unlock();
+
 	// Check the dependency manager to verify that there are no conflicting dependencies with this alter
-	// Note that we do this AFTER the new entry has been entirely set up in the catalog set
-	// that is because in case the alter fails because of a dependency conflict, we need to be able to cleanly roll back
-	// to the old entry.
 	catalog.GetDependencyManager().AlterObject(transaction, *entry, *new_entry);
 
 	return true;
 }
 
-void CatalogSet::DropEntryDependencies(CatalogTransaction transaction, EntryIndex &entry_index, CatalogEntry &entry,
-                                       bool cascade) {
-	// Stores the deleted value of the entry before starting the process
-	EntryDropper dropper(entry_index);
-
-	// To correctly delete the object and its dependencies, it temporarily is set to deleted.
-	entry_index.GetEntry()->deleted = true;
-
+bool CatalogSet::DropDependencies(CatalogTransaction transaction, const string &name, bool cascade,
+                                  bool allow_drop_internal) {
+	auto entry = GetEntry(transaction, name);
+	if (!entry) {
+		return false;
+	}
+	if (entry->internal && !allow_drop_internal) {
+		throw CatalogException("Cannot drop entry \"%s\" because it is an internal system entry", entry->name);
+	}
 	// check any dependencies of this object
-	D_ASSERT(entry.ParentCatalog().IsDuckCatalog());
-	auto &duck_catalog = entry.ParentCatalog().Cast<DuckCatalog>();
-	duck_catalog.GetDependencyManager().DropObject(transaction, entry, cascade);
-
-	// dropper destructor is called here
-	// the destructor makes sure to return the value to the previous state
-	// dropper.~EntryDropper()
+	D_ASSERT(entry->ParentCatalog().IsDuckCatalog());
+	auto &duck_catalog = entry->ParentCatalog().Cast<DuckCatalog>();
+	duck_catalog.GetDependencyManager().DropObject(transaction, *entry, cascade);
+	return true;
 }
 
-void CatalogSet::DropEntryInternal(CatalogTransaction transaction, EntryIndex entry_index, CatalogEntry &entry,
-                                   bool cascade) {
-	DropEntryDependencies(transaction, entry_index, entry, cascade);
+bool CatalogSet::DropEntryInternal(CatalogTransaction transaction, const string &name, bool allow_drop_internal) {
+	// lock the catalog for writing
+	// we can only delete an entry that exists
+	auto entry = GetEntryInternal(transaction, name);
+	if (!entry) {
+		return false;
+	}
+	if (entry->internal && !allow_drop_internal) {
+		throw CatalogException("Cannot drop entry \"%s\" because it is an internal system entry", entry->name);
+	}
 
-	// create a new entry and replace the currently stored one
+	// create a new tombstone entry and replace the currently stored one
 	// set the timestamp to the timestamp of the current transaction
-	// and point it at the dummy node
-	auto value = make_uniq<InCatalogEntry>(CatalogType::DELETED_ENTRY, entry.ParentCatalog(), entry.name);
+	// and point it at the tombstone node
+	auto value = make_uniq<InCatalogEntry>(CatalogType::DELETED_ENTRY, entry->ParentCatalog(), entry->name);
 	value->timestamp = transaction.transaction_id;
 	value->set = this;
 	value->deleted = true;
 	auto value_ptr = value.get();
-	PutEntry(std::move(entry_index), std::move(value));
+	map.UpdateEntry(std::move(value));
 
 	// push the old entry in the undo buffer for this transaction
 	if (transaction.transaction) {
 		auto &dtransaction = transaction.transaction->Cast<DuckTransaction>();
-		dtransaction.PushCatalogEntry(*value_ptr->child);
+		dtransaction.PushCatalogEntry(value_ptr->Child());
 	}
+	return true;
 }
 
 bool CatalogSet::DropEntry(CatalogTransaction transaction, const string &name, bool cascade, bool allow_drop_internal) {
-	// lock the catalog for writing
-	lock_guard<mutex> write_lock(catalog.GetWriteLock());
-	lock_guard<mutex> read_lock(catalog_lock);
-	// we can only delete an entry that exists
-	EntryIndex entry_index;
-	auto entry = GetEntryInternal(transaction, name, &entry_index);
-	if (!entry) {
+	if (!DropDependencies(transaction, name, cascade, allow_drop_internal)) {
 		return false;
 	}
-	if (entry->internal && !allow_drop_internal) {
-		throw CatalogException("Cannot drop entry \"%s\" because it is an internal system entry", entry->name);
-	}
-
-	DropEntryInternal(transaction, std::move(entry_index), *entry, cascade);
-	return true;
+	lock_guard<mutex> write_lock(catalog.GetWriteLock());
+	lock_guard<mutex> read_lock(catalog_lock);
+	return DropEntryInternal(transaction, name, allow_drop_internal);
 }
 
 bool CatalogSet::DropEntry(ClientContext &context, const string &name, bool cascade, bool allow_drop_internal) {
@@ -340,79 +424,31 @@ DuckCatalog &CatalogSet::GetCatalog() {
 
 void CatalogSet::CleanupEntry(CatalogEntry &catalog_entry) {
 	// destroy the backed up entry: it is no longer required
-	D_ASSERT(catalog_entry.parent);
-	if (catalog_entry.parent->type != CatalogType::UPDATED_ENTRY) {
-		lock_guard<mutex> write_lock(catalog.GetWriteLock());
-		lock_guard<mutex> lock(catalog_lock);
-		if (!catalog_entry.deleted) {
-			// delete the entry from the dependency manager, if it is not deleted yet
-			D_ASSERT(catalog_entry.ParentCatalog().IsDuckCatalog());
-			catalog_entry.ParentCatalog().Cast<DuckCatalog>().GetDependencyManager().EraseObject(catalog_entry);
-		}
-		auto parent = catalog_entry.parent;
-		parent->child = std::move(catalog_entry.child);
-		if (parent->deleted && !parent->child && !parent->parent) {
-			auto mapping_entry = mapping.find(parent->name);
-			D_ASSERT(mapping_entry != mapping.end());
-			auto &entry = mapping_entry->second->index.GetEntry();
-			D_ASSERT(entry);
-			if (entry.get() == parent.get()) {
-				mapping.erase(mapping_entry);
-			}
-		}
+	lock_guard<mutex> write_lock(catalog.GetWriteLock());
+	lock_guard<mutex> lock(catalog_lock);
+	auto &parent = catalog_entry.Parent();
+	map.DropEntry(catalog_entry);
+	if (parent.deleted && !parent.HasChild() && !parent.HasParent()) {
+		// The entry's parent is a tombstone and the entry had no child
+		// clean up the mapping and the tombstone entry as well
+		D_ASSERT(map.GetEntry(parent.name).get() == &parent);
+		map.DropEntry(parent);
 	}
 }
 
-bool CatalogSet::HasConflict(CatalogTransaction transaction, transaction_t timestamp) {
-	return (timestamp >= TRANSACTION_ID_START && timestamp != transaction.transaction_id) ||
-	       (timestamp < TRANSACTION_ID_START && timestamp > transaction.start_time);
+bool CatalogSet::CreatedByOtherActiveTransaction(CatalogTransaction transaction, transaction_t timestamp) {
+	// True if this transaction is not committed yet and the entry was made by another active (not committed)
+	// transaction
+	return (timestamp >= TRANSACTION_ID_START && timestamp != transaction.transaction_id);
 }
 
-optional_ptr<MappingValue> CatalogSet::GetMapping(CatalogTransaction transaction, const string &name, bool get_latest) {
-	optional_ptr<MappingValue> mapping_value;
-	auto entry = mapping.find(name);
-	if (entry != mapping.end()) {
-		mapping_value = entry->second.get();
-	} else {
-
-		return nullptr;
-	}
-	if (get_latest) {
-		return mapping_value;
-	}
-	while (mapping_value->child) {
-		if (UseTimestamp(transaction, mapping_value->timestamp)) {
-			break;
-		}
-		mapping_value = mapping_value->child.get();
-		D_ASSERT(mapping_value);
-	}
-	return mapping_value;
-}
-
-void CatalogSet::PutMapping(CatalogTransaction transaction, const string &name, EntryIndex entry_index) {
-	auto entry = mapping.find(name);
-	auto new_value = make_uniq<MappingValue>(std::move(entry_index));
-	new_value->timestamp = transaction.transaction_id;
-	if (entry != mapping.end()) {
-		if (HasConflict(transaction, entry->second->timestamp)) {
-			throw TransactionException("Catalog write-write conflict on name \"%s\"", name);
-		}
-		new_value->child = std::move(entry->second);
-		new_value->child->parent = new_value.get();
-	}
-	mapping[name] = std::move(new_value);
+bool CatalogSet::CommittedAfterStarting(CatalogTransaction transaction, transaction_t timestamp) {
+	// The entry has been committed after this transaction started, this is not our source of truth.
+	return (timestamp < TRANSACTION_ID_START && timestamp > transaction.start_time);
 }
 
-void CatalogSet::DeleteMapping(CatalogTransaction transaction, const string &name) {
-	auto entry = mapping.find(name);
-	D_ASSERT(entry != mapping.end());
-	auto delete_marker = make_uniq<MappingValue>(entry->second->index.Copy());
-	delete_marker->deleted = true;
-	delete_marker->timestamp = transaction.transaction_id;
-	delete_marker->child = std::move(entry->second);
-	delete_marker->child->parent = delete_marker.get();
-	mapping[name] = std::move(delete_marker);
+bool CatalogSet::HasConflict(CatalogTransaction transaction, transaction_t timestamp) {
+	return CreatedByOtherActiveTransaction(transaction, timestamp) || CommittedAfterStarting(transaction, timestamp);
 }
 
 bool CatalogSet::UseTimestamp(CatalogTransaction transaction, transaction_t timestamp) {
@@ -429,23 +465,23 @@ bool CatalogSet::UseTimestamp(CatalogTransaction transaction, transaction_t time
 
 CatalogEntry &CatalogSet::GetEntryForTransaction(CatalogTransaction transaction, CatalogEntry &current) {
 	reference<CatalogEntry> entry(current);
-	while (entry.get().child) {
+	while (entry.get().HasChild()) {
 		if (UseTimestamp(transaction, entry.get().timestamp)) {
 			break;
 		}
-		entry = *entry.get().child;
+		entry = entry.get().Child();
 	}
 	return entry.get();
 }
 
 CatalogEntry &CatalogSet::GetCommittedEntry(CatalogEntry &current) {
 	reference<CatalogEntry> entry(current);
-	while (entry.get().child) {
+	while (entry.get().HasChild()) {
 		if (entry.get().timestamp < TRANSACTION_ID_START) {
 			// this entry is committed: use it
 			break;
 		}
-		entry = *entry.get().child;
+		entry = entry.get().Child();
 	}
 	return entry.get();
 }
@@ -455,38 +491,18 @@ SimilarCatalogEntry CatalogSet::SimilarEntry(CatalogTransaction transaction, con
 	CreateDefaultEntries(transaction, lock);
 
 	SimilarCatalogEntry result;
-	for (auto &kv : mapping) {
-		auto mapping_value = GetMapping(transaction, kv.first);
-		if (mapping_value && !mapping_value->deleted) {
-			auto ldist = StringUtil::SimilarityScore(kv.first, name);
-			if (ldist < result.distance) {
-				result.distance = ldist;
-				result.name = kv.first;
-			}
+	for (auto &kv : map.Entries()) {
+		auto ldist = StringUtil::SimilarityScore(kv.first, name);
+		if (ldist < result.distance) {
+			result.distance = ldist;
+			result.name = kv.first;
 		}
 	}
 	return result;
 }
 
-optional_ptr<CatalogEntry> CatalogSet::CreateEntryInternal(CatalogTransaction transaction,
-                                                           unique_ptr<CatalogEntry> entry) {
-	if (mapping.find(entry->name) != mapping.end()) {
-		return nullptr;
-	}
-	auto &name = entry->name;
-	auto catalog_entry = entry.get();
-
-	entry->set = this;
-	entry->timestamp = 0;
-
-	auto entry_index = PutEntry(current_entry++, std::move(entry));
-	PutMapping(transaction, name, std::move(entry_index));
-	mapping[name]->timestamp = 0;
-	return catalog_entry;
-}
-
 optional_ptr<CatalogEntry> CatalogSet::CreateDefaultEntry(CatalogTransaction transaction, const string &name,
-                                                          unique_lock<mutex> &lock) {
+                                                          unique_lock<mutex> &read_lock) {
 	// no entry found with this name, check for defaults
 	if (!defaults || defaults->created_all_entries) {
 		// no defaults either: return null
@@ -498,41 +514,51 @@ optional_ptr<CatalogEntry> CatalogSet::CreateDefaultEntry(CatalogTransaction tra
 		// no context - cannot create default entry
 		return nullptr;
 	}
-	lock.unlock();
+	read_lock.unlock();
 	auto entry = defaults->CreateDefaultEntry(*transaction.context, name);
 
-	lock.lock();
+	read_lock.lock();
 	if (!entry) {
 		// no default entry
 		return nullptr;
 	}
 	// there is a default entry! create it
-	auto result = CreateEntryInternal(transaction, std::move(entry));
+	auto result = CreateCommittedEntry(std::move(entry));
 	if (result) {
 		return result;
 	}
 	// we found a default entry, but failed
 	// this means somebody else created the entry first
 	// just retry?
-	lock.unlock();
+	read_lock.unlock();
 	return GetEntry(transaction, name);
 }
 
-optional_ptr<CatalogEntry> CatalogSet::GetEntry(CatalogTransaction transaction, const string &name) {
-	unique_lock<mutex> lock(catalog_lock);
-	auto mapping_value = GetMapping(transaction, name);
-	if (mapping_value != nullptr && !mapping_value->deleted) {
+CatalogSet::EntryLookup CatalogSet::GetEntryDetailed(CatalogTransaction transaction, const string &name) {
+	unique_lock<mutex> read_lock(catalog_lock);
+	auto entry_value = map.GetEntry(name);
+	if (entry_value) {
 		// we found an entry for this name
 		// check the version numbers
 
-		auto &catalog_entry = *mapping_value->index.GetEntry();
+		auto &catalog_entry = *entry_value;
 		auto &current = GetEntryForTransaction(transaction, catalog_entry);
-		if (current.deleted || (current.name != name && !UseTimestamp(transaction, mapping_value->timestamp))) {
-			return nullptr;
+		if (current.deleted) {
+			return EntryLookup {nullptr, EntryLookup::FailureReason::DELETED};
 		}
-		return &current;
+		D_ASSERT(StringUtil::CIEquals(name, current.name));
+		return EntryLookup {&current, EntryLookup::FailureReason::SUCCESS};
+	}
+	auto default_entry = CreateDefaultEntry(transaction, name, read_lock);
+	if (!default_entry) {
+		return EntryLookup {default_entry, EntryLookup::FailureReason::NOT_PRESENT};
 	}
-	return CreateDefaultEntry(transaction, name, lock);
+	return EntryLookup {default_entry, EntryLookup::FailureReason::SUCCESS};
+}
+
+optional_ptr<CatalogEntry> CatalogSet::GetEntry(CatalogTransaction transaction, const string &name) {
+	auto lookup = GetEntryDetailed(transaction, name);
+	return lookup.result;
 }
 
 optional_ptr<CatalogEntry> CatalogSet::GetEntry(ClientContext &context, const string &name) {
@@ -541,7 +567,6 @@ optional_ptr<CatalogEntry> CatalogSet::GetEntry(ClientContext &context, const st
 
 void CatalogSet::UpdateTimestamp(CatalogEntry &entry, transaction_t timestamp) {
 	entry.timestamp = timestamp;
-	mapping[entry.name]->timestamp = timestamp;
 }
 
 void CatalogSet::Undo(CatalogEntry &entry) {
@@ -552,69 +577,41 @@ void CatalogSet::Undo(CatalogEntry &entry) {
 	// and entry->parent has to be removed ("rolled back")
 
 	// i.e. we have to place (entry) as (entry->parent) again
-	auto &to_be_removed_node = *entry.parent;
-
-	if (!to_be_removed_node.deleted) {
-		// delete the entry from the dependency manager as well
-		auto &dependency_manager = catalog.GetDependencyManager();
-		dependency_manager.EraseObject(to_be_removed_node);
-	}
-	if (!StringUtil::CIEquals(entry.name, to_be_removed_node.name)) {
-		// rename: clean up the new name when the rename is rolled back
-		auto removed_entry = mapping.find(to_be_removed_node.name);
-		if (removed_entry->second->child) {
-			removed_entry->second->child->parent = nullptr;
-			mapping[to_be_removed_node.name] = std::move(removed_entry->second->child);
-		} else {
-			mapping.erase(removed_entry);
-		}
+	auto &to_be_removed_node = entry.Parent();
+
+	D_ASSERT(StringUtil::CIEquals(entry.name, to_be_removed_node.name));
+	if (!to_be_removed_node.HasParent()) {
+		to_be_removed_node.Child().SetAsRoot();
 	}
-	if (to_be_removed_node.parent) {
-		// if the to be removed node has a parent, set the child pointer to the
-		// to be restored node
-		to_be_removed_node.parent->child = std::move(to_be_removed_node.child);
-		entry.parent = to_be_removed_node.parent;
-	} else {
-		// otherwise we need to update the base entry tables
-		auto &name = entry.name;
-		to_be_removed_node.child->SetAsRoot();
-		mapping[name]->index.GetEntry() = std::move(to_be_removed_node.child);
-		entry.parent = nullptr;
-	}
-
-	// restore the name if it was deleted
-	auto restored_entry = mapping.find(entry.name);
-	if (restored_entry->second->deleted || entry.type == CatalogType::INVALID) {
-		if (restored_entry->second->child) {
-			restored_entry->second->child->parent = nullptr;
-			mapping[entry.name] = std::move(restored_entry->second->child);
-		} else {
-			mapping.erase(restored_entry);
-		}
+	map.DropEntry(to_be_removed_node);
+
+	if (entry.type == CatalogType::INVALID) {
+		// This was the root of the entry chain
+		map.DropEntry(entry);
 	}
 	// we mark the catalog as being modified, since this action can lead to e.g. tables being dropped
 	catalog.ModifyCatalog();
 }
 
-void CatalogSet::CreateDefaultEntries(CatalogTransaction transaction, unique_lock<mutex> &lock) {
+void CatalogSet::CreateDefaultEntries(CatalogTransaction transaction, unique_lock<mutex> &read_lock) {
 	if (!defaults || defaults->created_all_entries || !transaction.context) {
 		return;
 	}
 	// this catalog set has a default set defined:
 	auto default_entries = defaults->GetDefaultEntries();
 	for (auto &default_entry : default_entries) {
-		auto map_entry = mapping.find(default_entry);
-		if (map_entry == mapping.end()) {
+		auto entry_value = map.GetEntry(default_entry);
+		if (!entry_value) {
 			// we unlock during the CreateEntry, since it might reference other catalog sets...
 			// specifically for views this can happen since the view will be bound
-			lock.unlock();
+			read_lock.unlock();
 			auto entry = defaults->CreateDefaultEntry(*transaction.context, default_entry);
 			if (!entry) {
 				throw InternalException("Failed to create default entry for %s", default_entry);
 			}
 
-			lock.lock();
-			CreateEntryInternal(transaction, std::move(entry));
+			read_lock.lock();
+			CreateCommittedEntry(std::move(entry));
 		}
 	}
 	defaults->created_all_entries = true;
@@ -625,8 +622,8 @@ void CatalogSet::Scan(CatalogTransaction transaction, const std::function<void(C
 	unique_lock<mutex> lock(catalog_lock);
 	CreateDefaultEntries(transaction, lock);
 
-	for (auto &kv : entries) {
-		auto &entry = *kv.second.entry.get();
+	for (auto &kv : map.Entries()) {
+		auto &entry = *kv.second;
 		auto &entry_for_transaction = GetEntryForTransaction(transaction, entry);
 		if (!entry_for_transaction.deleted) {
 			callback(entry_for_transaction);
@@ -638,12 +635,30 @@ void CatalogSet::Scan(ClientContext &context, const std::function<void(CatalogEn
 	Scan(catalog.GetCatalogTransaction(context), callback);
 }
 
+void CatalogSet::ScanWithPrefix(CatalogTransaction transaction, const std::function<void(CatalogEntry &)> &callback,
+                                const string &prefix) {
+	// lock the catalog set
+	unique_lock<mutex> lock(catalog_lock);
+	CreateDefaultEntries(transaction, lock);
+
+	auto &entries = map.Entries();
+	auto it = entries.lower_bound(prefix);
+	auto end = entries.upper_bound(prefix + char(255));
+	for (; it != end; it++) {
+		auto &entry = *it->second;
+		auto &entry_for_transaction = GetEntryForTransaction(transaction, entry);
+		if (!entry_for_transaction.deleted) {
+			callback(entry_for_transaction);
+		}
+	}
+}
+
 void CatalogSet::Scan(const std::function<void(CatalogEntry &)> &callback) {
 	// lock the catalog set
 	lock_guard<mutex> lock(catalog_lock);
-	for (auto &kv : entries) {
-		auto entry = kv.second.entry.get();
-		auto &commited_entry = GetCommittedEntry(*entry);
+	for (auto &kv : map.Entries()) {
+		auto &entry = *kv.second;
+		auto &commited_entry = GetCommittedEntry(entry);
 		if (!commited_entry.deleted) {
 			callback(commited_entry);
 		}