duckdb 0.6.2-dev971.0 → 0.7.1-dev2.0

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

@@ -4,7 +4,6 @@
 #include "duckdb/catalog/catalog_entry/list.hpp"
 #include "duckdb/catalog/catalog_set.hpp"
 #include "duckdb/catalog/default/default_schemas.hpp"
-#include "duckdb/catalog/dependency_manager.hpp"
 #include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/main/client_context.hpp"
@@ -32,36 +31,15 @@
 #include "duckdb/main/attached_database.hpp"
 #include "duckdb/main/database_manager.hpp"
 #include "duckdb/function/built_in_functions.hpp"
+#include "duckdb/catalog/similar_catalog_entry.hpp"
 #include <algorithm>
 
 namespace duckdb {
 
-Catalog::Catalog(AttachedDatabase &db)
-    : schemas(make_unique<CatalogSet>(*this, make_unique<DefaultSchemaGenerator>(*this))),
-      dependency_manager(make_unique<DependencyManager>(*this)), db(db) {
+Catalog::Catalog(AttachedDatabase &db) : db(db) {
 }
-Catalog::~Catalog() {
-}
-
-void Catalog::Initialize(bool load_builtin) {
-	// first initialize the base system catalogs
-	// these are never written to the WAL
-	// we start these at 1 because deleted entries default to 0
-	CatalogTransaction data(GetDatabase(), 1, 1);
-
-	// create the default schema
-	CreateSchemaInfo info;
-	info.schema = DEFAULT_SCHEMA;
-	info.internal = true;
-	CreateSchema(data, &info);
 
-	if (load_builtin) {
-		// initialize default functions
-		BuiltinFunctions builtin(data, *this);
-		builtin.Initialize();
-	}
-
-	Verify();
+Catalog::~Catalog() {
 }
 
 DatabaseInstance &Catalog::GetDatabase() {
@@ -103,22 +81,6 @@ Catalog &Catalog::GetCatalog(ClientContext &context, const string &catalog_name)
 //===--------------------------------------------------------------------===//
 // Schema
 //===--------------------------------------------------------------------===//
-CatalogEntry *Catalog::CreateSchema(CatalogTransaction transaction, CreateSchemaInfo *info) {
-	D_ASSERT(!info->schema.empty());
-	DependencyList dependencies;
-	auto entry = make_unique<SchemaCatalogEntry>(this, info->schema, info->internal);
-	auto result = entry.get();
-	if (!schemas->CreateEntry(transaction, info->schema, move(entry), dependencies)) {
-		if (info->on_conflict == OnCreateConflict::ERROR_ON_CONFLICT) {
-			throw CatalogException("Schema with name %s already exists!", info->schema);
-		} else {
-			D_ASSERT(info->on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT);
-		}
-		return nullptr;
-	}
-	return result;
-}
-
 CatalogEntry *Catalog::CreateSchema(ClientContext &context, CreateSchemaInfo *info) {
 	return CreateSchema(GetCatalogTransaction(context), info);
 }
@@ -127,16 +89,6 @@ CatalogTransaction Catalog::GetCatalogTransaction(ClientContext &context) {
 	return CatalogTransaction(*this, context);
 }
 
-void Catalog::DropSchema(ClientContext &context, DropInfo *info) {
-	D_ASSERT(!info->name.empty());
-	ModifyCatalog();
-	if (!schemas->DropEntry(GetCatalogTransaction(context), info->name, info->cascade)) {
-		if (!info->if_exists) {
-			throw CatalogException("Schema with name \"%s\" does not exist!", info->name);
-		}
-	}
-}
-
 //===--------------------------------------------------------------------===//
 // Table
 //===--------------------------------------------------------------------===//
@@ -146,7 +98,7 @@ CatalogEntry *Catalog::CreateTable(ClientContext &context, BoundCreateTableInfo
 
 CatalogEntry *Catalog::CreateTable(ClientContext &context, unique_ptr<CreateTableInfo> info) {
 	auto binder = Binder::CreateBinder(context);
-	auto bound_info = binder->BindCreateTableInfo(move(info));
+	auto bound_info = binder->BindCreateTableInfo(std::move(info));
 	return CreateTable(context, bound_info.get());
 }
 
@@ -303,7 +255,7 @@ CatalogEntry *Catalog::CreateCollation(CatalogTransaction transaction, SchemaCat
 // Lookup Structures
 //===--------------------------------------------------------------------===//
 struct CatalogLookup {
-	CatalogLookup(Catalog &catalog, string schema_p) : catalog(catalog), schema(move(schema_p)) {
+	CatalogLookup(Catalog &catalog, string schema_p) : catalog(catalog), schema(std::move(schema_p)) {
 	}
 
 	Catalog &catalog;
@@ -320,41 +272,6 @@ struct CatalogEntryLookup {
 	}
 };
 
-//! Return value of SimilarEntryInSchemas
-struct SimilarCatalogEntry {
-	//! The entry name. Empty if absent
-	string name;
-	//! The distance to the given name.
-	idx_t distance;
-	//! The schema of the entry.
-	SchemaCatalogEntry *schema;
-
-	DUCKDB_API bool Found() const {
-		return !name.empty();
-	}
-
-	DUCKDB_API string GetQualifiedName(bool qualify_catalog, bool qualify_schema) const;
-};
-
-string SimilarCatalogEntry::GetQualifiedName(bool qualify_catalog, bool qualify_schema) const {
-	D_ASSERT(Found());
-	string result;
-	if (qualify_catalog) {
-		result += schema->catalog->GetName();
-	}
-	if (qualify_schema) {
-		if (!result.empty()) {
-			result += ".";
-		}
-		result += schema->name;
-	}
-	if (!result.empty()) {
-		result += ".";
-	}
-	result += name;
-	return result;
-}
-
 //===--------------------------------------------------------------------===//
 // Generic
 //===--------------------------------------------------------------------===//
@@ -374,47 +291,30 @@ void Catalog::DropEntry(ClientContext &context, DropInfo *info) {
 	lookup.schema->DropEntry(context, info);
 }
 
-SchemaCatalogEntry *Catalog::GetSchema(CatalogTransaction transaction, const string &schema_name, bool if_exists,
-                                       QueryErrorContext error_context) {
-	D_ASSERT(!schema_name.empty());
-	auto entry = schemas->GetEntry(transaction, schema_name);
-	if (!entry && !if_exists) {
-		throw CatalogException(error_context.FormatError("Schema with name %s does not exist!", schema_name));
-	}
-	return (SchemaCatalogEntry *)entry;
-}
-
 SchemaCatalogEntry *Catalog::GetSchema(ClientContext &context, const string &schema_name, bool if_exists,
                                        QueryErrorContext error_context) {
 	return GetSchema(GetCatalogTransaction(context), schema_name, if_exists, error_context);
 }
 
-void Catalog::ScanSchemas(ClientContext &context, std::function<void(CatalogEntry *)> callback) {
-	// create all default schemas first
-	schemas->Scan(GetCatalogTransaction(context), [&](CatalogEntry *entry) { callback(entry); });
-}
-
 //===--------------------------------------------------------------------===//
 // Lookup
 //===--------------------------------------------------------------------===//
 SimilarCatalogEntry Catalog::SimilarEntryInSchemas(ClientContext &context, const string &entry_name, CatalogType type,
                                                    const unordered_set<SchemaCatalogEntry *> &schemas) {
-
-	vector<CatalogSet *> sets;
-	std::transform(schemas.begin(), schemas.end(), std::back_inserter(sets),
-	               [type](SchemaCatalogEntry *s) -> CatalogSet * { return &s->GetCatalogSet(type); });
-	pair<string, idx_t> most_similar {"", (idx_t)-1};
-	SchemaCatalogEntry *schema_of_most_similar = nullptr;
+	SimilarCatalogEntry result;
 	for (auto schema : schemas) {
 		auto transaction = schema->catalog->GetCatalogTransaction(context);
-		auto entry = schema->GetCatalogSet(type).SimilarEntry(transaction, entry_name);
-		if (!entry.first.empty() && (most_similar.first.empty() || most_similar.second > entry.second)) {
-			most_similar = entry;
-			schema_of_most_similar = schema;
+		auto entry = schema->GetSimilarEntry(transaction, type, entry_name);
+		if (!entry.Found()) {
+			// no similar entry found
+			continue;
+		}
+		if (!result.Found() || result.distance > entry.distance) {
+			result = entry;
+			result.schema = schema;
 		}
 	}
-
-	return {most_similar.first, most_similar.second, schema_of_most_similar};
+	return result;
 }
 
 string FindExtension(const string &function_name) {
@@ -540,7 +440,7 @@ CatalogEntryLookup Catalog::LookupEntryInternal(CatalogTransaction transaction,
 	if (!schema_entry) {
 		return {nullptr, nullptr};
 	}
-	auto entry = schema_entry->GetCatalogSet(type).GetEntry(transaction, name);
+	auto entry = schema_entry->GetEntry(transaction, type, name);
 	if (!entry) {
 		return {schema_entry, nullptr};
 	}
@@ -652,25 +552,30 @@ SchemaCatalogEntry *Catalog::GetSchema(ClientContext &context, const string &cat
 	return result;
 }
 
+LogicalType Catalog::GetType(ClientContext &context, const string &schema, const string &name, bool if_exists) {
+	auto type_entry = GetEntry<TypeCatalogEntry>(context, schema, name, if_exists);
+	if (!type_entry) {
+		return LogicalType::INVALID;
+	}
+	auto result_type = type_entry->user_type;
+	LogicalType::SetCatalog(result_type, type_entry);
+	return result_type;
+}
+
 LogicalType Catalog::GetType(ClientContext &context, const string &catalog_name, const string &schema,
                              const string &name) {
-	CatalogEntry *entry;
-	entry = GetEntry(context, CatalogType::TYPE_ENTRY, catalog_name, schema, name, true);
-	if (!entry) {
-		// look in the system catalog
-		entry = GetEntry(context, CatalogType::TYPE_ENTRY, SYSTEM_CATALOG, schema, name, true);
-		if (!entry) {
-			// repeat the search to get the error
-			GetEntry(context, CatalogType::TYPE_ENTRY, catalog_name, schema, name);
-			throw InternalException("Catalog::GetType - second type lookup somehow succeeded!?");
-		}
-	}
-	auto type_entry = (TypeCatalogEntry *)entry;
+	auto type_entry = Catalog::GetEntry<TypeCatalogEntry>(context, catalog_name, schema, name);
 	auto result_type = type_entry->user_type;
 	LogicalType::SetCatalog(result_type, type_entry);
 	return result_type;
 }
 
+vector<SchemaCatalogEntry *> Catalog::GetSchemas(ClientContext &context) {
+	vector<SchemaCatalogEntry *> schemas;
+	ScanSchemas(context, [&](CatalogEntry *entry) { schemas.push_back((SchemaCatalogEntry *)entry); });
+	return schemas;
+}
+
 vector<SchemaCatalogEntry *> Catalog::GetSchemas(ClientContext &context, const string &catalog_name) {
 	vector<Catalog *> catalogs;
 	if (IsInvalidCatalog(catalog_name)) {
@@ -689,7 +594,7 @@ vector<SchemaCatalogEntry *> Catalog::GetSchemas(ClientContext &context, const s
 	}
 	vector<SchemaCatalogEntry *> result;
 	for (auto catalog : catalogs) {
-		auto schemas = catalog->schemas->GetEntries<SchemaCatalogEntry>(catalog->GetCatalogTransaction(context));
+		auto schemas = catalog->GetSchemas(context);
 		result.insert(result.end(), schemas.begin(), schemas.end());
 	}
 	return result;
@@ -702,7 +607,7 @@ vector<SchemaCatalogEntry *> Catalog::GetAllSchemas(ClientContext &context) {
 	auto databases = db_manager.GetDatabases(context);
 	for (auto database : databases) {
 		auto &catalog = database->GetCatalog();
-		auto new_schemas = catalog.schemas->GetEntries<SchemaCatalogEntry>(catalog.GetCatalogTransaction(context));
+		auto new_schemas = catalog.GetSchemas(context);
 		result.insert(result.end(), new_schemas.begin(), new_schemas.end());
 	}
 	sort(result.begin(), result.end(), [&](SchemaCatalogEntry *x, SchemaCatalogEntry *y) {
@@ -728,9 +633,6 @@ void Catalog::Alter(ClientContext &context, AlterInfo *info) {
 }
 
 void Catalog::Verify() {
-#ifdef DEBUG
-	schemas->Verify(*this);
-#endif
 }
 
 //===--------------------------------------------------------------------===//
@@ -741,7 +643,7 @@ idx_t Catalog::GetCatalogVersion() {
 }
 
 idx_t Catalog::ModifyCatalog() {
-	return GetDatabase().GetDatabaseManager().catalog_version++;
+	return GetDatabase().GetDatabaseManager().ModifyCatalog();
 }
 
 bool Catalog::IsSystemCatalog() const {

package/src/duckdb/src/catalog/catalog_entry/column_dependency_manager.cpp

@@ -177,12 +177,12 @@ void ColumnDependencyManager::AdjustSingle(LogicalIndex idx, idx_t offset) {
 	}
 	if (has_dependents) {
 		D_ASSERT(!dependencies_map.count(new_idx));
-		dependencies_map[new_idx] = move(dependencies_map[idx]);
+		dependencies_map[new_idx] = std::move(dependencies_map[idx]);
 		dependencies_map.erase(idx);
 	}
 	if (has_dependencies) {
 		D_ASSERT(!dependents_map.count(new_idx));
-		dependents_map[new_idx] = move(dependents_map[idx]);
+		dependents_map[new_idx] = std::move(dependents_map[idx]);
 		dependents_map.erase(idx);
 	}
 }

package/src/duckdb/src/catalog/catalog_entry/duck_index_entry.cpp

@@ -0,0 +1,27 @@
+#include "duckdb/catalog/catalog_entry/duck_index_entry.hpp"
+#include "duckdb/storage/data_table.hpp"
+#include "duckdb/execution/index/art/art.hpp"
+
+namespace duckdb {
+
+DuckIndexEntry::DuckIndexEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateIndexInfo *info)
+    : IndexCatalogEntry(catalog, schema, info) {
+}
+
+DuckIndexEntry::~DuckIndexEntry() {
+	// remove the associated index from the info
+	if (!info || !index) {
+		return;
+	}
+	info->indexes.RemoveIndex(index);
+}
+
+string DuckIndexEntry::GetSchemaName() {
+	return info->schema;
+}
+
+string DuckIndexEntry::GetTableName() {
+	return info->table;
+}
+
+} // namespace duckdb

package/src/duckdb/src/catalog/catalog_entry/duck_schema_entry.cpp

@@ -0,0 +1,330 @@
+#include "duckdb/catalog/catalog_entry/duck_schema_entry.hpp"
+#include "duckdb/catalog/default/default_functions.hpp"
+#include "duckdb/catalog/default/default_types.hpp"
+#include "duckdb/catalog/default/default_views.hpp"
+#include "duckdb/catalog/catalog_entry/collate_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/copy_function_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/duck_index_entry.hpp"
+#include "duckdb/catalog/catalog_entry/pragma_function_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/sequence_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"
+#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/table_macro_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/catalog/dependency_list.hpp"
+#include "duckdb/planner/constraints/bound_foreign_key_constraint.hpp"
+#include "duckdb/parser/constraints/foreign_key_constraint.hpp"
+#include "duckdb/parser/parsed_data/alter_table_info.hpp"
+#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
+#include "duckdb/storage/data_table.hpp"
+#include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
+#include "duckdb/parser/parsed_data/create_collation_info.hpp"
+#include "duckdb/parser/parsed_data/create_copy_function_info.hpp"
+#include "duckdb/parser/parsed_data/create_index_info.hpp"
+#include "duckdb/parser/parsed_data/create_pragma_function_info.hpp"
+#include "duckdb/parser/parsed_data/create_schema_info.hpp"
+#include "duckdb/parser/parsed_data/create_sequence_info.hpp"
+#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
+#include "duckdb/parser/parsed_data/create_type_info.hpp"
+#include "duckdb/parser/parsed_data/create_view_info.hpp"
+#include "duckdb/parser/parsed_data/drop_info.hpp"
+
+namespace duckdb {
+
+void FindForeignKeyInformation(CatalogEntry *entry, AlterForeignKeyType alter_fk_type,
+                               vector<unique_ptr<AlterForeignKeyInfo>> &fk_arrays) {
+	if (entry->type != CatalogType::TABLE_ENTRY) {
+		return;
+	}
+	auto *table_entry = (TableCatalogEntry *)entry;
+	auto &constraints = table_entry->GetConstraints();
+	for (idx_t i = 0; i < constraints.size(); i++) {
+		auto &cond = constraints[i];
+		if (cond->type != ConstraintType::FOREIGN_KEY) {
+			continue;
+		}
+		auto &fk = (ForeignKeyConstraint &)*cond;
+		if (fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
+			AlterEntryData alter_data(entry->catalog->GetName(), fk.info.schema, fk.info.table, false);
+			fk_arrays.push_back(make_unique<AlterForeignKeyInfo>(std::move(alter_data), entry->name, fk.pk_columns,
+			                                                     fk.fk_columns, fk.info.pk_keys, fk.info.fk_keys,
+			                                                     alter_fk_type));
+		} else if (fk.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE &&
+		           alter_fk_type == AlterForeignKeyType::AFT_DELETE) {
+			throw CatalogException("Could not drop the table because this table is main key table of the table \"%s\"",
+			                       fk.info.table);
+		}
+	}
+}
+
+DuckSchemaEntry::DuckSchemaEntry(Catalog *catalog, string name_p, bool is_internal)
+    : SchemaCatalogEntry(catalog, std::move(name_p), is_internal),
+      tables(*catalog, make_unique<DefaultViewGenerator>(*catalog, this)), indexes(*catalog), table_functions(*catalog),
+      copy_functions(*catalog), pragma_functions(*catalog),
+      functions(*catalog, make_unique<DefaultFunctionGenerator>(*catalog, this)), sequences(*catalog),
+      collations(*catalog), types(*catalog, make_unique<DefaultTypeGenerator>(*catalog, this)) {
+}
+
+CatalogEntry *DuckSchemaEntry::AddEntryInternal(CatalogTransaction transaction, unique_ptr<StandardEntry> entry,
+                                                OnCreateConflict on_conflict, DependencyList dependencies) {
+	auto entry_name = entry->name;
+	auto entry_type = entry->type;
+	auto result = entry.get();
+
+	// first find the set for this entry
+	auto &set = GetCatalogSet(entry_type);
+	dependencies.AddDependency(this);
+	if (on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT) {
+		// CREATE OR REPLACE: first try to drop the entry
+		auto old_entry = set.GetEntry(transaction, entry_name);
+		if (old_entry) {
+			if (old_entry->type != entry_type) {
+				throw CatalogException("Existing object %s is of type %s, trying to replace with type %s", entry_name,
+				                       CatalogTypeToString(old_entry->type), CatalogTypeToString(entry_type));
+			}
+			(void)set.DropEntry(transaction, entry_name, false, entry->internal);
+		}
+	}
+	// now try to add the entry
+	if (!set.CreateEntry(transaction, entry_name, std::move(entry), dependencies)) {
+		// entry already exists!
+		if (on_conflict == OnCreateConflict::ERROR_ON_CONFLICT) {
+			throw CatalogException("%s with name \"%s\" already exists!", CatalogTypeToString(entry_type), entry_name);
+		} else {
+			return nullptr;
+		}
+	}
+	return result;
+}
+
+CatalogEntry *DuckSchemaEntry::CreateTable(CatalogTransaction transaction, BoundCreateTableInfo *info) {
+	auto table = make_unique<DuckTableEntry>(catalog, this, info);
+	auto &storage = table->GetStorage();
+	storage.info->cardinality = storage.GetTotalRows();
+
+	CatalogEntry *entry = AddEntryInternal(transaction, std::move(table), info->Base().on_conflict, info->dependencies);
+	if (!entry) {
+		return nullptr;
+	}
+
+	// add a foreign key constraint in main key table if there is a foreign key constraint
+	vector<unique_ptr<AlterForeignKeyInfo>> fk_arrays;
+	FindForeignKeyInformation(entry, AlterForeignKeyType::AFT_ADD, fk_arrays);
+	for (idx_t i = 0; i < fk_arrays.size(); i++) {
+		// alter primary key table
+		AlterForeignKeyInfo *fk_info = fk_arrays[i].get();
+		catalog->Alter(transaction.GetContext(), fk_info);
+
+		// make a dependency between this table and referenced table
+		auto &set = GetCatalogSet(CatalogType::TABLE_ENTRY);
+		info->dependencies.AddDependency(set.GetEntry(transaction, fk_info->name));
+	}
+	return entry;
+}
+
+CatalogEntry *DuckSchemaEntry::CreateFunction(CatalogTransaction transaction, CreateFunctionInfo *info) {
+	if (info->on_conflict == OnCreateConflict::ALTER_ON_CONFLICT) {
+		// check if the original entry exists
+		auto &catalog_set = GetCatalogSet(info->type);
+		auto current_entry = catalog_set.GetEntry(transaction, info->name);
+		if (current_entry) {
+			// the current entry exists - alter it instead
+			auto alter_info = info->GetAlterInfo();
+			Alter(transaction.GetContext(), alter_info.get());
+			return nullptr;
+		}
+	}
+	unique_ptr<StandardEntry> function;
+	switch (info->type) {
+	case CatalogType::SCALAR_FUNCTION_ENTRY:
+		function = make_unique_base<StandardEntry, ScalarFunctionCatalogEntry>(catalog, this,
+		                                                                       (CreateScalarFunctionInfo *)info);
+		break;
+	case CatalogType::MACRO_ENTRY:
+		// create a macro function
+		function = make_unique_base<StandardEntry, ScalarMacroCatalogEntry>(catalog, this, (CreateMacroInfo *)info);
+		break;
+
+	case CatalogType::TABLE_MACRO_ENTRY:
+		// create a macro table function
+		function = make_unique_base<StandardEntry, TableMacroCatalogEntry>(catalog, this, (CreateMacroInfo *)info);
+		break;
+	case CatalogType::AGGREGATE_FUNCTION_ENTRY:
+		D_ASSERT(info->type == CatalogType::AGGREGATE_FUNCTION_ENTRY);
+		// create an aggregate function
+		function = make_unique_base<StandardEntry, AggregateFunctionCatalogEntry>(catalog, this,
+		                                                                          (CreateAggregateFunctionInfo *)info);
+		break;
+	default:
+		throw InternalException("Unknown function type \"%s\"", CatalogTypeToString(info->type));
+	}
+	function->internal = info->internal;
+	return AddEntry(transaction, std::move(function), info->on_conflict);
+}
+
+CatalogEntry *DuckSchemaEntry::AddEntry(CatalogTransaction transaction, unique_ptr<StandardEntry> entry,
+                                        OnCreateConflict on_conflict) {
+	DependencyList dependencies;
+	return AddEntryInternal(transaction, std::move(entry), on_conflict, dependencies);
+}
+
+CatalogEntry *DuckSchemaEntry::CreateSequence(CatalogTransaction transaction, CreateSequenceInfo *info) {
+	auto sequence = make_unique<SequenceCatalogEntry>(catalog, this, info);
+	return AddEntry(transaction, std::move(sequence), info->on_conflict);
+}
+
+CatalogEntry *DuckSchemaEntry::CreateType(CatalogTransaction transaction, CreateTypeInfo *info) {
+	auto type_entry = make_unique<TypeCatalogEntry>(catalog, this, info);
+	return AddEntry(transaction, std::move(type_entry), info->on_conflict);
+}
+
+CatalogEntry *DuckSchemaEntry::CreateView(CatalogTransaction transaction, CreateViewInfo *info) {
+	auto view = make_unique<ViewCatalogEntry>(catalog, this, info);
+	return AddEntry(transaction, std::move(view), info->on_conflict);
+}
+
+CatalogEntry *DuckSchemaEntry::CreateIndex(ClientContext &context, CreateIndexInfo *info, TableCatalogEntry *table) {
+	DependencyList dependencies;
+	dependencies.AddDependency(table);
+	auto index = make_unique<DuckIndexEntry>(catalog, this, info);
+	return AddEntryInternal(GetCatalogTransaction(context), std::move(index), info->on_conflict, dependencies);
+}
+
+CatalogEntry *DuckSchemaEntry::CreateCollation(CatalogTransaction transaction, CreateCollationInfo *info) {
+	auto collation = make_unique<CollateCatalogEntry>(catalog, this, info);
+	collation->internal = info->internal;
+	return AddEntry(transaction, std::move(collation), info->on_conflict);
+}
+
+CatalogEntry *DuckSchemaEntry::CreateTableFunction(CatalogTransaction transaction, CreateTableFunctionInfo *info) {
+	auto table_function = make_unique<TableFunctionCatalogEntry>(catalog, this, info);
+	table_function->internal = info->internal;
+	return AddEntry(transaction, std::move(table_function), info->on_conflict);
+}
+
+CatalogEntry *DuckSchemaEntry::CreateCopyFunction(CatalogTransaction transaction, CreateCopyFunctionInfo *info) {
+	auto copy_function = make_unique<CopyFunctionCatalogEntry>(catalog, this, info);
+	copy_function->internal = info->internal;
+	return AddEntry(transaction, std::move(copy_function), info->on_conflict);
+}
+
+CatalogEntry *DuckSchemaEntry::CreatePragmaFunction(CatalogTransaction transaction, CreatePragmaFunctionInfo *info) {
+	auto pragma_function = make_unique<PragmaFunctionCatalogEntry>(catalog, this, info);
+	pragma_function->internal = info->internal;
+	return AddEntry(transaction, std::move(pragma_function), info->on_conflict);
+}
+
+void DuckSchemaEntry::Alter(ClientContext &context, AlterInfo *info) {
+	CatalogType type = info->GetCatalogType();
+	auto &set = GetCatalogSet(type);
+	auto transaction = GetCatalogTransaction(context);
+	if (info->type == AlterType::CHANGE_OWNERSHIP) {
+		if (!set.AlterOwnership(transaction, (ChangeOwnershipInfo *)info)) {
+			throw CatalogException("Couldn't change ownership!");
+		}
+	} else {
+		string name = info->name;
+		if (!set.AlterEntry(transaction, name, info)) {
+			throw CatalogException("Entry with name \"%s\" does not exist!", name);
+		}
+	}
+}
+
+void DuckSchemaEntry::Scan(ClientContext &context, CatalogType type,
+                           const std::function<void(CatalogEntry *)> &callback) {
+	auto &set = GetCatalogSet(type);
+	set.Scan(GetCatalogTransaction(context), callback);
+}
+
+void DuckSchemaEntry::Scan(CatalogType type, const std::function<void(CatalogEntry *)> &callback) {
+	auto &set = GetCatalogSet(type);
+	set.Scan(callback);
+}
+
+void DuckSchemaEntry::DropEntry(ClientContext &context, DropInfo *info) {
+	auto &set = GetCatalogSet(info->type);
+
+	// first find the entry
+	auto transaction = GetCatalogTransaction(context);
+	auto existing_entry = set.GetEntry(transaction, info->name);
+	if (!existing_entry) {
+		throw InternalException("Failed to drop entry \"%s\" - entry could not be found", info->name);
+	}
+	if (existing_entry->type != info->type) {
+		throw CatalogException("Existing object %s is of type %s, trying to replace with type %s", info->name,
+		                       CatalogTypeToString(existing_entry->type), CatalogTypeToString(info->type));
+	}
+
+	// if there is a foreign key constraint, get that information
+	vector<unique_ptr<AlterForeignKeyInfo>> fk_arrays;
+	FindForeignKeyInformation(existing_entry, AlterForeignKeyType::AFT_DELETE, fk_arrays);
+
+	if (!set.DropEntry(transaction, info->name, info->cascade, info->allow_drop_internal)) {
+		throw InternalException("Could not drop element because of an internal error");
+	}
+
+	// remove the foreign key constraint in main key table if main key table's name is valid
+	for (idx_t i = 0; i < fk_arrays.size(); i++) {
+		// alter primary key table
+		catalog->Alter(context, fk_arrays[i].get());
+	}
+}
+
+CatalogEntry *DuckSchemaEntry::GetEntry(CatalogTransaction transaction, CatalogType type, const string &name) {
+	return GetCatalogSet(type).GetEntry(transaction, name);
+}
+
+SimilarCatalogEntry DuckSchemaEntry::GetSimilarEntry(CatalogTransaction transaction, CatalogType type,
+                                                     const string &name) {
+	return GetCatalogSet(type).SimilarEntry(transaction, name);
+}
+
+CatalogSet &DuckSchemaEntry::GetCatalogSet(CatalogType type) {
+	switch (type) {
+	case CatalogType::VIEW_ENTRY:
+	case CatalogType::TABLE_ENTRY:
+		return tables;
+	case CatalogType::INDEX_ENTRY:
+		return indexes;
+	case CatalogType::TABLE_FUNCTION_ENTRY:
+	case CatalogType::TABLE_MACRO_ENTRY:
+		return table_functions;
+	case CatalogType::COPY_FUNCTION_ENTRY:
+		return copy_functions;
+	case CatalogType::PRAGMA_FUNCTION_ENTRY:
+		return pragma_functions;
+	case CatalogType::AGGREGATE_FUNCTION_ENTRY:
+	case CatalogType::SCALAR_FUNCTION_ENTRY:
+	case CatalogType::MACRO_ENTRY:
+		return functions;
+	case CatalogType::SEQUENCE_ENTRY:
+		return sequences;
+	case CatalogType::COLLATION_ENTRY:
+		return collations;
+	case CatalogType::TYPE_ENTRY:
+		return types;
+	default:
+		throw InternalException("Unsupported catalog type in schema");
+	}
+}
+
+void DuckSchemaEntry::Verify(Catalog &catalog) {
+	CatalogEntry::Verify(catalog);
+
+	tables.Verify(catalog);
+	indexes.Verify(catalog);
+	table_functions.Verify(catalog);
+	copy_functions.Verify(catalog);
+	pragma_functions.Verify(catalog);
+	functions.Verify(catalog);
+	sequences.Verify(catalog);
+	collations.Verify(catalog);
+	types.Verify(catalog);
+}
+
+} // namespace duckdb