duckdb 0.6.2-dev781.0 → 0.6.2-dev891.0

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

@@ -7,6 +7,7 @@ namespace duckdb {
 
 IndexCatalogEntry::IndexCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateIndexInfo *info)
     : StandardEntry(CatalogType::INDEX_ENTRY, schema, catalog, info->index_name), index(nullptr), sql(info->sql) {
+	this->temporary = info->temporary;
 }
 
 IndexCatalogEntry::~IndexCatalogEntry() {

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

@@ -36,6 +36,7 @@
 #include "duckdb/planner/constraints/bound_foreign_key_constraint.hpp"
 #include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
 #include "duckdb/storage/data_table.hpp"
+#include "duckdb/catalog/dependency_list.hpp"
 
 #include <sstream>
 
@@ -54,9 +55,10 @@ void FindForeignKeyInformation(CatalogEntry *entry, AlterForeignKeyType alter_fk
 		}
 		auto &fk = (ForeignKeyConstraint &)*cond;
 		if (fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
-			fk_arrays.push_back(make_unique<AlterForeignKeyInfo>(fk.info.schema, fk.info.table, false, entry->name,
-			                                                     fk.pk_columns, fk.fk_columns, fk.info.pk_keys,
-			                                                     fk.info.fk_keys, alter_fk_type));
+			AlterEntryData alter_data(entry->catalog->GetName(), fk.info.schema, fk.info.table, false);
+			fk_arrays.push_back(make_unique<AlterForeignKeyInfo>(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\"",
@@ -74,33 +76,32 @@ SchemaCatalogEntry::SchemaCatalogEntry(Catalog *catalog, string name_p, bool int
 	this->internal = internal;
 }
 
-CatalogEntry *SchemaCatalogEntry::AddEntry(ClientContext &context, unique_ptr<StandardEntry> entry,
-                                           OnCreateConflict on_conflict, unordered_set<CatalogEntry *> dependencies) {
+CatalogTransaction SchemaCatalogEntry::GetCatalogTransaction(ClientContext &context) {
+	return CatalogTransaction(*catalog, context);
+}
+
+CatalogEntry *SchemaCatalogEntry::AddEntry(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);
-
-	if (name != TEMP_SCHEMA) {
-		dependencies.insert(this);
-	} else {
-		entry->temporary = true;
-	}
+	dependencies.AddDependency(this);
 	if (on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT) {
 		// CREATE OR REPLACE: first try to drop the entry
-		auto old_entry = set.GetEntry(context, entry_name);
+		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(context, entry_name, false);
+			(void)set.DropEntry(transaction, entry_name, false, entry->internal);
 		}
 	}
 	// now try to add the entry
-	if (!set.CreateEntry(context, entry_name, move(entry), dependencies)) {
+	if (!set.CreateEntry(transaction, entry_name, 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);
@@ -111,27 +112,27 @@ CatalogEntry *SchemaCatalogEntry::AddEntry(ClientContext &context, unique_ptr<St
 	return result;
 }
 
-CatalogEntry *SchemaCatalogEntry::AddEntry(ClientContext &context, unique_ptr<StandardEntry> entry,
+CatalogEntry *SchemaCatalogEntry::AddEntry(CatalogTransaction transaction, unique_ptr<StandardEntry> entry,
                                            OnCreateConflict on_conflict) {
-	unordered_set<CatalogEntry *> dependencies;
-	return AddEntry(context, move(entry), on_conflict, dependencies);
+	DependencyList dependencies;
+	return AddEntry(transaction, move(entry), on_conflict, dependencies);
 }
 
-CatalogEntry *SchemaCatalogEntry::CreateSequence(ClientContext &context, CreateSequenceInfo *info) {
+CatalogEntry *SchemaCatalogEntry::CreateSequence(CatalogTransaction transaction, CreateSequenceInfo *info) {
 	auto sequence = make_unique<SequenceCatalogEntry>(catalog, this, info);
-	return AddEntry(context, move(sequence), info->on_conflict);
+	return AddEntry(transaction, move(sequence), info->on_conflict);
 }
 
-CatalogEntry *SchemaCatalogEntry::CreateType(ClientContext &context, CreateTypeInfo *info) {
+CatalogEntry *SchemaCatalogEntry::CreateType(CatalogTransaction transaction, CreateTypeInfo *info) {
 	auto type_entry = make_unique<TypeCatalogEntry>(catalog, this, info);
-	return AddEntry(context, move(type_entry), info->on_conflict);
+	return AddEntry(transaction, move(type_entry), info->on_conflict);
 }
 
-CatalogEntry *SchemaCatalogEntry::CreateTable(ClientContext &context, BoundCreateTableInfo *info) {
+CatalogEntry *SchemaCatalogEntry::CreateTable(CatalogTransaction transaction, BoundCreateTableInfo *info) {
 	auto table = make_unique<TableCatalogEntry>(catalog, this, info);
 	table->storage->info->cardinality = table->storage->GetTotalRows();
 
-	CatalogEntry *entry = AddEntry(context, move(table), info->Base().on_conflict, info->dependencies);
+	CatalogEntry *entry = AddEntry(transaction, move(table), info->Base().on_conflict, info->dependencies);
 	if (!entry) {
 		return nullptr;
 	}
@@ -142,60 +143,60 @@ CatalogEntry *SchemaCatalogEntry::CreateTable(ClientContext &context, BoundCreat
 	for (idx_t i = 0; i < fk_arrays.size(); i++) {
 		// alter primary key table
 		AlterForeignKeyInfo *fk_info = fk_arrays[i].get();
-		catalog->Alter(context, fk_info);
+		catalog->Alter(transaction.GetContext(), fk_info);
 
 		// make a dependency between this table and referenced table
 		auto &set = GetCatalogSet(CatalogType::TABLE_ENTRY);
-		info->dependencies.insert(set.GetEntry(context, fk_info->name));
+		info->dependencies.AddDependency(set.GetEntry(transaction, fk_info->name));
 	}
 	return entry;
 }
 
-CatalogEntry *SchemaCatalogEntry::CreateView(ClientContext &context, CreateViewInfo *info) {
+CatalogEntry *SchemaCatalogEntry::CreateView(CatalogTransaction transaction, CreateViewInfo *info) {
 	auto view = make_unique<ViewCatalogEntry>(catalog, this, info);
-	return AddEntry(context, move(view), info->on_conflict);
+	return AddEntry(transaction, move(view), info->on_conflict);
 }
 
 CatalogEntry *SchemaCatalogEntry::CreateIndex(ClientContext &context, CreateIndexInfo *info, TableCatalogEntry *table) {
-	unordered_set<CatalogEntry *> dependencies;
-	dependencies.insert(table);
+	DependencyList dependencies;
+	dependencies.AddDependency(table);
 	auto index = make_unique<IndexCatalogEntry>(catalog, this, info);
-	return AddEntry(context, move(index), info->on_conflict, dependencies);
+	return AddEntry(GetCatalogTransaction(context), move(index), info->on_conflict, dependencies);
 }
 
-CatalogEntry *SchemaCatalogEntry::CreateCollation(ClientContext &context, CreateCollationInfo *info) {
+CatalogEntry *SchemaCatalogEntry::CreateCollation(CatalogTransaction transaction, CreateCollationInfo *info) {
 	auto collation = make_unique<CollateCatalogEntry>(catalog, this, info);
 	collation->internal = info->internal;
-	return AddEntry(context, move(collation), info->on_conflict);
+	return AddEntry(transaction, move(collation), info->on_conflict);
 }
 
-CatalogEntry *SchemaCatalogEntry::CreateTableFunction(ClientContext &context, CreateTableFunctionInfo *info) {
+CatalogEntry *SchemaCatalogEntry::CreateTableFunction(CatalogTransaction transaction, CreateTableFunctionInfo *info) {
 	auto table_function = make_unique<TableFunctionCatalogEntry>(catalog, this, info);
 	table_function->internal = info->internal;
-	return AddEntry(context, move(table_function), info->on_conflict);
+	return AddEntry(transaction, move(table_function), info->on_conflict);
 }
 
-CatalogEntry *SchemaCatalogEntry::CreateCopyFunction(ClientContext &context, CreateCopyFunctionInfo *info) {
+CatalogEntry *SchemaCatalogEntry::CreateCopyFunction(CatalogTransaction transaction, CreateCopyFunctionInfo *info) {
 	auto copy_function = make_unique<CopyFunctionCatalogEntry>(catalog, this, info);
 	copy_function->internal = info->internal;
-	return AddEntry(context, move(copy_function), info->on_conflict);
+	return AddEntry(transaction, move(copy_function), info->on_conflict);
 }
 
-CatalogEntry *SchemaCatalogEntry::CreatePragmaFunction(ClientContext &context, CreatePragmaFunctionInfo *info) {
+CatalogEntry *SchemaCatalogEntry::CreatePragmaFunction(CatalogTransaction transaction, CreatePragmaFunctionInfo *info) {
 	auto pragma_function = make_unique<PragmaFunctionCatalogEntry>(catalog, this, info);
 	pragma_function->internal = info->internal;
-	return AddEntry(context, move(pragma_function), info->on_conflict);
+	return AddEntry(transaction, move(pragma_function), info->on_conflict);
 }
 
-CatalogEntry *SchemaCatalogEntry::CreateFunction(ClientContext &context, CreateFunctionInfo *info) {
+CatalogEntry *SchemaCatalogEntry::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(context, info->name);
+		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(context, alter_info.get());
+			Alter(transaction.GetContext(), alter_info.get());
 			return nullptr;
 		}
 	}
@@ -224,14 +225,15 @@ CatalogEntry *SchemaCatalogEntry::CreateFunction(ClientContext &context, CreateF
 		throw InternalException("Unknown function type \"%s\"", CatalogTypeToString(info->type));
 	}
 	function->internal = info->internal;
-	return AddEntry(context, move(function), info->on_conflict);
+	return AddEntry(transaction, move(function), info->on_conflict);
 }
 
 void SchemaCatalogEntry::DropEntry(ClientContext &context, DropInfo *info) {
 	auto &set = GetCatalogSet(info->type);
 
 	// first find the entry
-	auto existing_entry = set.GetEntry(context, info->name);
+	auto transaction = GetCatalogTransaction(context);
+	auto existing_entry = set.GetEntry(transaction, info->name);
 	if (!existing_entry) {
 		if (!info->if_exists) {
 			throw CatalogException("%s with name \"%s\" does not exist!", CatalogTypeToString(info->type), info->name);
@@ -247,27 +249,28 @@ void SchemaCatalogEntry::DropEntry(ClientContext &context, DropInfo *info) {
 	vector<unique_ptr<AlterForeignKeyInfo>> fk_arrays;
 	FindForeignKeyInformation(existing_entry, AlterForeignKeyType::AFT_DELETE, fk_arrays);
 
-	if (!set.DropEntry(context, info->name, info->cascade)) {
+	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 tablee
-		Catalog::GetCatalog(context).Alter(context, fk_arrays[i].get());
+		// alter primary key table
+		catalog->Alter(context, fk_arrays[i].get());
 	}
 }
 
 void SchemaCatalogEntry::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(context, (ChangeOwnershipInfo *)info)) {
+		if (!set.AlterOwnership(transaction, (ChangeOwnershipInfo *)info)) {
 			throw CatalogException("Couldn't change ownership!");
 		}
 	} else {
 		string name = info->name;
-		if (!set.AlterEntry(context, name, info)) {
+		if (!set.AlterEntry(transaction, name, info)) {
 			throw CatalogException("Entry with name \"%s\" does not exist!", name);
 		}
 	}
@@ -276,7 +279,7 @@ void SchemaCatalogEntry::Alter(ClientContext &context, AlterInfo *info) {
 void SchemaCatalogEntry::Scan(ClientContext &context, CatalogType type,
                               const std::function<void(CatalogEntry *)> &callback) {
 	auto &set = GetCatalogSet(type);
-	set.Scan(context, callback);
+	set.Scan(GetCatalogTransaction(context), callback);
 }
 
 void SchemaCatalogEntry::Scan(CatalogType type, const std::function<void(CatalogEntry *)> &callback) {
@@ -335,4 +338,18 @@ CatalogSet &SchemaCatalogEntry::GetCatalogSet(CatalogType type) {
 	}
 }
 
+void SchemaCatalogEntry::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

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

@@ -99,9 +99,8 @@ TableCatalogEntry::TableCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schem
 		for (auto &col_def : columns.Physical()) {
 			storage_columns.push_back(col_def.Copy());
 		}
-		storage =
-		    make_shared<DataTable>(catalog->db, StorageManager::GetStorageManager(catalog->db).GetTableIOManager(info),
-		                           schema->name, name, move(storage_columns), move(info->data));
+		storage = make_shared<DataTable>(catalog->GetAttached(), StorageManager::Get(*catalog).GetTableIOManager(info),
+		                                 schema->name, name, move(storage_columns), move(info->data));
 
 		// create the unique indexes for the UNIQUE and PRIMARY KEY and FOREIGN KEY constraints
 		idx_t indexes_idx = 0;
@@ -237,7 +236,7 @@ unique_ptr<CatalogEntry> TableCatalogEntry::RenameColumn(ClientContext &context,
 	if (rename_idx.index == COLUMN_IDENTIFIER_ROW_ID) {
 		throw CatalogException("Cannot rename rowid column");
 	}
-	auto create_info = make_unique<CreateTableInfo>(schema->name, name);
+	auto create_info = make_unique<CreateTableInfo>(schema, name);
 	create_info->temporary = temporary;
 	for (auto &col : columns.Logical()) {
 		auto copy = col.Copy();
@@ -309,7 +308,7 @@ unique_ptr<CatalogEntry> TableCatalogEntry::AddColumn(ClientContext &context, Ad
 		return nullptr;
 	}
 
-	auto create_info = make_unique<CreateTableInfo>(schema->name, name);
+	auto create_info = make_unique<CreateTableInfo>(schema, name);
 	create_info->temporary = temporary;
 
 	for (auto &col : columns.Logical()) {
@@ -318,7 +317,7 @@ unique_ptr<CatalogEntry> TableCatalogEntry::AddColumn(ClientContext &context, Ad
 	for (auto &constraint : constraints) {
 		create_info->constraints.push_back(constraint->Copy());
 	}
-	Binder::BindLogicalType(context, info.new_column.TypeMutable(), schema->name);
+	Binder::BindLogicalType(context, info.new_column.TypeMutable(), catalog->GetName(), schema->name);
 	info.new_column.SetOid(columns.LogicalColumnCount());
 	info.new_column.SetStorageOid(columns.PhysicalColumnCount());
 	auto col = info.new_column.Copy();
@@ -342,7 +341,7 @@ unique_ptr<CatalogEntry> TableCatalogEntry::RemoveColumn(ClientContext &context,
 		return nullptr;
 	}
 
-	auto create_info = make_unique<CreateTableInfo>(schema->name, name);
+	auto create_info = make_unique<CreateTableInfo>(schema, name);
 	create_info->temporary = temporary;
 
 	logical_index_set_t removed_columns;
@@ -452,7 +451,7 @@ unique_ptr<CatalogEntry> TableCatalogEntry::RemoveColumn(ClientContext &context,
 }
 
 unique_ptr<CatalogEntry> TableCatalogEntry::SetDefault(ClientContext &context, SetDefaultInfo &info) {
-	auto create_info = make_unique<CreateTableInfo>(schema->name, name);
+	auto create_info = make_unique<CreateTableInfo>(schema, name);
 	auto default_idx = GetColumnIndex(info.column_name);
 	if (default_idx.index == COLUMN_IDENTIFIER_ROW_ID) {
 		throw CatalogException("Cannot SET DEFAULT for rowid column");
@@ -483,7 +482,7 @@ unique_ptr<CatalogEntry> TableCatalogEntry::SetDefault(ClientContext &context, S
 
 unique_ptr<CatalogEntry> TableCatalogEntry::SetNotNull(ClientContext &context, SetNotNullInfo &info) {
 
-	auto create_info = make_unique<CreateTableInfo>(schema->name, name);
+	auto create_info = make_unique<CreateTableInfo>(schema, name);
 	create_info->columns = columns.Copy();
 
 	auto not_null_idx = GetColumnIndex(info.column_name);
@@ -521,7 +520,7 @@ unique_ptr<CatalogEntry> TableCatalogEntry::SetNotNull(ClientContext &context, S
 }
 
 unique_ptr<CatalogEntry> TableCatalogEntry::DropNotNull(ClientContext &context, DropNotNullInfo &info) {
-	auto create_info = make_unique<CreateTableInfo>(schema->name, name);
+	auto create_info = make_unique<CreateTableInfo>(schema, name);
 	create_info->columns = columns.Copy();
 
 	auto not_null_idx = GetColumnIndex(info.column_name);
@@ -544,11 +543,11 @@ unique_ptr<CatalogEntry> TableCatalogEntry::DropNotNull(ClientContext &context,
 
 unique_ptr<CatalogEntry> TableCatalogEntry::ChangeColumnType(ClientContext &context, ChangeColumnTypeInfo &info) {
 	if (info.target_type.id() == LogicalTypeId::USER) {
-		auto &catalog = Catalog::GetCatalog(context);
-		info.target_type = catalog.GetType(context, schema->name, UserType::GetTypeName(info.target_type));
+		info.target_type =
+		    Catalog::GetType(context, catalog->GetName(), schema->name, UserType::GetTypeName(info.target_type));
 	}
 	auto change_idx = GetColumnIndex(info.column_name);
-	auto create_info = make_unique<CreateTableInfo>(schema->name, name);
+	auto create_info = make_unique<CreateTableInfo>(schema, name);
 	create_info->temporary = temporary;
 
 	for (auto &col : columns.Logical()) {
@@ -636,7 +635,7 @@ unique_ptr<CatalogEntry> TableCatalogEntry::ChangeColumnType(ClientContext &cont
 
 unique_ptr<CatalogEntry> TableCatalogEntry::AddForeignKeyConstraint(ClientContext &context, AlterForeignKeyInfo &info) {
 	D_ASSERT(info.type == AlterForeignKeyType::AFT_ADD);
-	auto create_info = make_unique<CreateTableInfo>(schema->name, name);
+	auto create_info = make_unique<CreateTableInfo>(schema, name);
 	create_info->temporary = temporary;
 
 	create_info->columns = columns.Copy();
@@ -661,7 +660,7 @@ unique_ptr<CatalogEntry> TableCatalogEntry::AddForeignKeyConstraint(ClientContex
 unique_ptr<CatalogEntry> TableCatalogEntry::DropForeignKeyConstraint(ClientContext &context,
                                                                      AlterForeignKeyInfo &info) {
 	D_ASSERT(info.type == AlterForeignKeyType::AFT_DELETE);
-	auto create_info = make_unique<CreateTableInfo>(schema->name, name);
+	auto create_info = make_unique<CreateTableInfo>(schema, name);
 	create_info->temporary = temporary;
 
 	create_info->columns = columns.Copy();
@@ -810,7 +809,7 @@ string TableCatalogEntry::ToSQL() {
 }
 
 unique_ptr<CatalogEntry> TableCatalogEntry::Copy(ClientContext &context) {
-	auto create_info = make_unique<CreateTableInfo>(schema->name, name);
+	auto create_info = make_unique<CreateTableInfo>(schema, name);
 	create_info->columns = columns.Copy();
 
 	for (idx_t i = 0; i < constraints.size(); i++) {

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

@@ -80,7 +80,7 @@ string ViewCatalogEntry::ToSQL() {
 
 unique_ptr<CatalogEntry> ViewCatalogEntry::Copy(ClientContext &context) {
 	D_ASSERT(!internal);
-	auto create_info = make_unique<CreateViewInfo>(schema->name, name);
+	auto create_info = make_unique<CreateViewInfo>(schema, name);
 	create_info->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
 	for (idx_t i = 0; i < aliases.size(); i++) {
 		create_info->aliases.push_back(aliases[i]);

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

@@ -5,8 +5,8 @@
 namespace duckdb {
 
 CatalogEntry::CatalogEntry(CatalogType type, Catalog *catalog_p, string name_p)
-    : oid(catalog_p->ModifyCatalog()), type(type), catalog(catalog_p), set(nullptr), name(move(name_p)), deleted(false),
-      temporary(false), internal(false), parent(nullptr) {
+    : oid(catalog_p ? catalog_p->ModifyCatalog() : 0), type(type), catalog(catalog_p), set(nullptr), name(move(name_p)),
+      deleted(false), temporary(false), internal(false), parent(nullptr) {
 }
 
 CatalogEntry::~CatalogEntry() {
@@ -32,4 +32,8 @@ string CatalogEntry::ToSQL() {
 }
 // LCOV_EXCL_STOP
 
+void CatalogEntry::Verify(Catalog &catalog_p) {
+	D_ASSERT(&catalog_p == catalog);
+}
+
 } // namespace duckdb

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

@@ -8,61 +8,216 @@
 
 namespace duckdb {
 
+CatalogSearchEntry::CatalogSearchEntry(string catalog_p, string schema_p)
+    : catalog(move(catalog_p)), schema(move(schema_p)) {
+}
+
+string CatalogSearchEntry::ToString() const {
+	if (catalog.empty()) {
+		return WriteOptionallyQuoted(schema);
+	} else {
+		return WriteOptionallyQuoted(catalog) + "." + WriteOptionallyQuoted(schema);
+	}
+}
+
+string CatalogSearchEntry::WriteOptionallyQuoted(const string &input) {
+	for (idx_t i = 0; i < input.size(); i++) {
+		if (input[i] == '.' || input[i] == ',') {
+			return "\"" + input + "\"";
+		}
+	}
+	return input;
+}
+
+string CatalogSearchEntry::ListToString(const vector<CatalogSearchEntry> &input) {
+	string result;
+	for (auto &entry : input) {
+		if (!result.empty()) {
+			result += ",";
+		}
+		result += entry.ToString();
+	}
+	return result;
+}
+
+CatalogSearchEntry CatalogSearchEntry::ParseInternal(const string &input, idx_t &idx) {
+	string catalog;
+	string schema;
+	string entry;
+	bool finished = false;
+normal:
+	for (; idx < input.size(); idx++) {
+		if (input[idx] == '"') {
+			idx++;
+			goto quoted;
+		} else if (input[idx] == '.') {
+			goto separator;
+		} else if (input[idx] == ',') {
+			finished = true;
+			goto separator;
+		}
+		entry += input[idx];
+	}
+	finished = true;
+	goto separator;
+quoted:
+	//! look for another quote
+	for (; idx < input.size(); idx++) {
+		if (input[idx] == '"') {
+			//! unquote
+			idx++;
+			goto normal;
+		}
+		entry += input[idx];
+	}
+	throw ParserException("Unterminated quote in qualified name!");
+separator:
+	if (entry.empty()) {
+		throw ParserException("Unexpected dot - empty CatalogSearchEntry");
+	}
+	if (schema.empty()) {
+		// if we parse one entry it is the schema
+		schema = move(entry);
+	} else if (catalog.empty()) {
+		// if we parse two entries it is [catalog.schema]
+		catalog = move(schema);
+		schema = move(entry);
+	} else {
+		throw ParserException("Too many dots - expected [schema] or [catalog.schema] for CatalogSearchEntry");
+	}
+	entry = "";
+	idx++;
+	if (finished) {
+		goto final;
+	}
+	goto normal;
+final:
+	if (schema.empty()) {
+		throw ParserException("Unexpected end of entry - empty CatalogSearchEntry");
+	}
+	return CatalogSearchEntry(move(catalog), move(schema));
+}
+
+CatalogSearchEntry CatalogSearchEntry::Parse(const string &input) {
+	idx_t pos = 0;
+	auto result = ParseInternal(input, pos);
+	if (pos < input.size()) {
+		throw ParserException("Failed to convert entry \"%s\" to CatalogSearchEntry - expected a single entry", input);
+	}
+	return result;
+}
+
+vector<CatalogSearchEntry> CatalogSearchEntry::ParseList(const string &input) {
+	idx_t pos = 0;
+	vector<CatalogSearchEntry> result;
+	while (pos < input.size()) {
+		auto entry = ParseInternal(input, pos);
+		result.push_back(entry);
+	}
+	return result;
+}
+
 CatalogSearchPath::CatalogSearchPath(ClientContext &context_p) : context(context_p) {
 	Reset();
 }
 
 void CatalogSearchPath::Reset() {
-	SetPaths(ParsePaths(""));
+	vector<CatalogSearchEntry> empty;
+	SetPaths(empty);
 }
 
-void CatalogSearchPath::Set(vector<string> &new_paths, bool is_set_schema) {
+void CatalogSearchPath::Set(vector<CatalogSearchEntry> new_paths, bool is_set_schema) {
 	if (is_set_schema && new_paths.size() != 1) {
 		throw CatalogException("SET schema can set only 1 schema. This has %d", new_paths.size());
 	}
-	auto &catalog = Catalog::GetCatalog(context);
-	for (const auto &path : new_paths) {
-		if (!catalog.GetSchema(context, StringUtil::Lower(path), true)) {
-			throw CatalogException("SET %s: No schema named %s found.", is_set_schema ? "schema" : "search_path", path);
+	for (auto &path : new_paths) {
+		if (!Catalog::GetSchema(context, path.catalog, path.schema, true)) {
+			if (path.catalog.empty()) {
+				// only schema supplied - check if this is a database instead
+				auto schema = Catalog::GetSchema(context, path.schema, DEFAULT_SCHEMA, true);
+				if (schema) {
+					path.catalog = move(path.schema);
+					path.schema = schema->name;
+					continue;
+				}
+			}
+			throw CatalogException("SET %s: No catalog + schema named %s found.",
+			                       is_set_schema ? "schema" : "search_path", path.ToString());
 		}
 	}
 	this->set_paths = move(new_paths);
 	SetPaths(set_paths);
 }
 
-void CatalogSearchPath::Set(const string &new_value, bool is_set_schema) {
-	auto new_paths = ParsePaths(new_value);
-	Set(new_paths, is_set_schema);
+void CatalogSearchPath::Set(CatalogSearchEntry new_value, bool is_set_schema) {
+	vector<CatalogSearchEntry> new_paths {move(new_value)};
+	Set(move(new_paths), is_set_schema);
 }
 
-const vector<string> &CatalogSearchPath::Get() {
+const vector<CatalogSearchEntry> &CatalogSearchPath::Get() {
 	return paths;
 }
 
-const string &CatalogSearchPath::GetOrDefault(const string &name) {
-	return name == INVALID_SCHEMA ? GetDefault() : name; // NOLINT
+string CatalogSearchPath::GetDefaultSchema(const string &catalog) {
+	for (auto &path : paths) {
+		if (path.catalog == TEMP_CATALOG) {
+			continue;
+		}
+		if (StringUtil::CIEquals(path.catalog, catalog)) {
+			return path.schema;
+		}
+	}
+	return DEFAULT_SCHEMA;
+}
+
+string CatalogSearchPath::GetDefaultCatalog(const string &schema) {
+	for (auto &path : paths) {
+		if (path.catalog == TEMP_CATALOG) {
+			continue;
+		}
+		if (StringUtil::CIEquals(path.schema, schema)) {
+			return path.catalog;
+		}
+	}
+	return INVALID_CATALOG;
+}
+
+vector<string> CatalogSearchPath::GetCatalogsForSchema(const string &schema) {
+	vector<string> schemas;
+	for (auto &path : paths) {
+		if (StringUtil::CIEquals(path.schema, schema)) {
+			schemas.push_back(path.catalog);
+		}
+	}
+	return schemas;
+}
+
+vector<string> CatalogSearchPath::GetSchemasForCatalog(const string &catalog) {
+	vector<string> schemas;
+	for (auto &path : paths) {
+		if (StringUtil::CIEquals(path.catalog, catalog)) {
+			schemas.push_back(path.schema);
+		}
+	}
+	return schemas;
 }
 
-const string &CatalogSearchPath::GetDefault() {
+const CatalogSearchEntry &CatalogSearchPath::GetDefault() {
 	const auto &paths = Get();
 	D_ASSERT(paths.size() >= 2);
-	D_ASSERT(paths[0] == TEMP_SCHEMA);
 	return paths[1];
 }
 
-void CatalogSearchPath::SetPaths(vector<string> new_paths) {
+void CatalogSearchPath::SetPaths(vector<CatalogSearchEntry> new_paths) {
 	paths.clear();
 	paths.reserve(new_paths.size() + 3);
-	paths.emplace_back(TEMP_SCHEMA);
+	paths.emplace_back(TEMP_CATALOG, DEFAULT_SCHEMA);
 	for (auto &path : new_paths) {
 		paths.push_back(move(path));
 	}
-	paths.emplace_back(DEFAULT_SCHEMA);
-	paths.emplace_back("pg_catalog");
-}
-
-vector<string> CatalogSearchPath::ParsePaths(const string &value) {
-	return StringUtil::SplitWithQuote(StringUtil::Lower(value));
+	paths.emplace_back(INVALID_CATALOG, DEFAULT_SCHEMA);
+	paths.emplace_back(SYSTEM_CATALOG, DEFAULT_SCHEMA);
+	paths.emplace_back(SYSTEM_CATALOG, "pg_catalog");
 }
 
 } // namespace duckdb