duckdb 0.6.2-dev772.0 → 0.6.2-dev889.0

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

@@ -7,21 +7,27 @@
 #include "duckdb/main/database.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/catalog/mapping_value.hpp"
+#include "duckdb/catalog/dependency_list.hpp"
 
 namespace duckdb {
 
 DependencyManager::DependencyManager(Catalog &catalog) : catalog(catalog) {
 }
 
-void DependencyManager::AddObject(ClientContext &context, CatalogEntry *object,
-                                  unordered_set<CatalogEntry *> &dependencies) {
+void DependencyManager::AddObject(CatalogTransaction transaction, CatalogEntry *object, DependencyList &dependencies) {
 	// check for each object in the sources if they were not deleted yet
-	for (auto &dependency : dependencies) {
+	for (auto &dependency : dependencies.set) {
 		CatalogEntry *catalog_entry;
+		if (dependency->catalog != object->catalog) {
+			throw DependencyException(
+			    "Error adding dependency for object \"%s\" - dependency \"%s\" is in catalog "
+			    "\"%s\", which does not match the catalog \"%s\".\nCross catalog dependencies are not supported.",
+			    object->name, dependency->name, dependency->catalog->GetName(), object->catalog->GetName());
+		}
 		if (!dependency->set) {
 			throw InternalException("Dependency has no set");
 		}
-		if (!dependency->set->GetEntryInternal(context, dependency->name, nullptr, catalog_entry)) {
+		if (!dependency->set->GetEntryInternal(transaction, dependency->name, nullptr, catalog_entry)) {
 			throw InternalException("Dependency has already been deleted?");
 		}
 	}
@@ -29,15 +35,15 @@ void DependencyManager::AddObject(ClientContext &context, CatalogEntry *object,
 	auto dependency_type = object->type == CatalogType::INDEX_ENTRY ? DependencyType::DEPENDENCY_AUTOMATIC
 	                                                                : DependencyType::DEPENDENCY_REGULAR;
 	// add the object to the dependents_map of each object that it depends on
-	for (auto &dependency : dependencies) {
+	for (auto &dependency : dependencies.set) {
 		dependents_map[dependency].insert(Dependency(object, dependency_type));
 	}
 	// create the dependents map for this object: it starts out empty
 	dependents_map[object] = dependency_set_t();
-	dependencies_map[object] = dependencies;
+	dependencies_map[object] = dependencies.set;
 }
 
-void DependencyManager::DropObject(ClientContext &context, CatalogEntry *object, bool cascade) {
+void DependencyManager::DropObject(CatalogTransaction transaction, CatalogEntry *object, bool cascade) {
 	D_ASSERT(dependents_map.find(object) != dependents_map.end());
 
 	// first check the objects that depend on this object
@@ -45,13 +51,13 @@ void DependencyManager::DropObject(ClientContext &context, CatalogEntry *object,
 	for (auto &dep : dependent_objects) {
 		// look up the entry in the catalog set
 		auto &catalog_set = *dep.entry->set;
-		auto mapping_value = catalog_set.GetMapping(context, dep.entry->name, true /* get_latest */);
+		auto mapping_value = catalog_set.GetMapping(transaction, dep.entry->name, true /* get_latest */);
 		if (mapping_value == nullptr) {
 			continue;
 		}
 		CatalogEntry *dependency_entry;
 
-		if (!catalog_set.GetEntryInternal(context, mapping_value->index, dependency_entry)) {
+		if (!catalog_set.GetEntryInternal(transaction, mapping_value->index, dependency_entry)) {
 			// the dependent object was already deleted, no conflict
 			continue;
 		}
@@ -59,7 +65,7 @@ void DependencyManager::DropObject(ClientContext &context, CatalogEntry *object,
 		if (cascade || dep.dependency_type == DependencyType::DEPENDENCY_AUTOMATIC ||
 		    dep.dependency_type == DependencyType::DEPENDENCY_OWNS) {
 			// cascade: drop the dependent object
-			catalog_set.DropEntryInternal(context, mapping_value->index.Copy(), *dependency_entry, cascade);
+			catalog_set.DropEntryInternal(transaction, mapping_value->index.Copy(), *dependency_entry, cascade);
 		} else {
 			// no cascade and there are objects that depend on this object: throw error
 			throw DependencyException("Cannot drop entry \"%s\" because there are entries that "
@@ -69,7 +75,7 @@ void DependencyManager::DropObject(ClientContext &context, CatalogEntry *object,
 	}
 }
 
-void DependencyManager::AlterObject(ClientContext &context, CatalogEntry *old_obj, CatalogEntry *new_obj) {
+void DependencyManager::AlterObject(CatalogTransaction transaction, CatalogEntry *old_obj, CatalogEntry *new_obj) {
 	D_ASSERT(dependents_map.find(old_obj) != dependents_map.end());
 	D_ASSERT(dependencies_map.find(old_obj) != dependencies_map.end());
 
@@ -80,7 +86,7 @@ void DependencyManager::AlterObject(ClientContext &context, CatalogEntry *old_ob
 		// look up the entry in the catalog set
 		auto &catalog_set = *dep.entry->set;
 		CatalogEntry *dependency_entry;
-		if (!catalog_set.GetEntryInternal(context, dep.entry->name, nullptr, dependency_entry)) {
+		if (!catalog_set.GetEntryInternal(transaction, dep.entry->name, nullptr, dependency_entry)) {
 			// the dependent object was already deleted, no conflict
 			continue;
 		}
@@ -182,7 +188,7 @@ void DependencyManager::Scan(const std::function<void(CatalogEntry *, CatalogEnt
 	}
 }
 
-void DependencyManager::AddOwnership(ClientContext &context, CatalogEntry *owner, CatalogEntry *entry) {
+void DependencyManager::AddOwnership(CatalogTransaction transaction, CatalogEntry *owner, CatalogEntry *entry) {
 	// lock the catalog for writing
 	lock_guard<mutex> write_lock(catalog.write_lock);
 

package/src/duckdb/src/common/constants.cpp

@@ -27,6 +27,14 @@ uint64_t NextPowerOfTwo(uint64_t v) {
 	return v;
 }
 
+bool IsInvalidSchema(const string &str) {
+	return str.empty();
+}
+
+bool IsInvalidCatalog(const string &str) {
+	return str.empty();
+}
+
 bool IsRowIdColumnId(column_t column_id) {
 	return column_id == COLUMN_IDENTIFIER_ROW_ID;
 }

package/src/duckdb/src/common/enums/catalog_type.cpp

@@ -15,6 +15,8 @@ string CatalogTypeToString(CatalogType type) {
 		return "Table";
 	case CatalogType::SCHEMA_ENTRY:
 		return "Schema";
+	case CatalogType::DATABASE_ENTRY:
+		return "Database";
 	case CatalogType::TABLE_FUNCTION_ENTRY:
 		return "Table Function";
 	case CatalogType::SCALAR_FUNCTION_ENTRY:

package/src/duckdb/src/common/enums/logical_operator_type.cpp

@@ -96,6 +96,8 @@ string LogicalOperatorToString(LogicalOperatorType type) {
 		return "CREATE_VIEW";
 	case LogicalOperatorType::LOGICAL_CREATE_SCHEMA:
 		return "CREATE_SCHEMA";
+	case LogicalOperatorType::LOGICAL_ATTACH:
+		return "ATTACH";
 	case LogicalOperatorType::LOGICAL_DROP:
 		return "DROP";
 	case LogicalOperatorType::LOGICAL_PRAGMA:

package/src/duckdb/src/common/enums/physical_operator_type.cpp

@@ -127,6 +127,8 @@ string PhysicalOperatorToString(PhysicalOperatorType type) {
 		return "INOUT_FUNCTION";
 	case PhysicalOperatorType::CREATE_TYPE:
 		return "CREATE_TYPE";
+	case PhysicalOperatorType::ATTACH:
+		return "ATTACH";
 	case PhysicalOperatorType::RESULT_COLLECTOR:
 		return "RESULT_COLLECTOR";
 	case PhysicalOperatorType::INVALID:

package/src/duckdb/src/common/enums/statement_type.cpp

@@ -55,6 +55,8 @@ string StatementTypeToString(StatementType type) {
 		return "EXTENSION";
 	case StatementType::LOGICAL_PLAN_STATEMENT:
 		return "LOGICAL_PLAN";
+	case StatementType::ATTACH_STATEMENT:
+		return "ATTACH";
 	case StatementType::INVALID_STATEMENT:
 		break;
 	}

package/src/duckdb/src/common/file_system.cpp

@@ -39,7 +39,7 @@ FileSystem::~FileSystem() {
 }
 
 FileSystem &FileSystem::GetFileSystem(ClientContext &context) {
-	return *context.db->config.file_system;
+	return FileSystem::GetFileSystem(*context.db);
 }
 
 FileOpener *FileSystem::GetFileOpener(ClientContext &context) {

package/src/duckdb/src/common/string_util.cpp

@@ -19,7 +19,7 @@ bool StringUtil::Contains(const string &haystack, const string &needle) {
 
 void StringUtil::LTrim(string &str) {
 	auto it = str.begin();
-	while (CharacterIsSpace(*it)) {
+	while (it != str.end() && CharacterIsSpace(*it)) {
 		it++;
 	}
 	str.erase(str.begin(), it);
@@ -165,6 +165,10 @@ string StringUtil::Lower(const string &str) {
 	return (copy);
 }
 
+bool StringUtil::CIEquals(const string &l1, const string &l2) {
+	return StringUtil::Lower(l1) == StringUtil::Lower(l2);
+}
+
 vector<string> StringUtil::Split(const string &input, const string &split) {
 	vector<string> splits;
 

package/src/duckdb/src/execution/index/art/art.cpp

@@ -14,7 +14,7 @@ namespace duckdb {
 
 ART::ART(const vector<column_t> &column_ids, TableIOManager &table_io_manager,
          const vector<unique_ptr<Expression>> &unbound_expressions, IndexConstraintType constraint_type,
-         DatabaseInstance &db, idx_t block_id, idx_t block_offset)
+         AttachedDatabase &db, idx_t block_id, idx_t block_offset)
     : Index(IndexType::ART, table_io_manager, column_ids, unbound_expressions, constraint_type), db(db),
       estimated_art_size(0), estimated_key_size(16) {
 	if (!Radix::IsLittleEndian()) {

package/src/duckdb/src/execution/operator/helper/physical_transaction.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/execution/operator/helper/physical_transaction.hpp"
 #include "duckdb/main/client_context.hpp"
+#include "duckdb/main/valid_checker.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/execution/operator/join/physical_index_join.cpp

@@ -98,9 +98,9 @@ unique_ptr<OperatorState> PhysicalIndexJoin::GetOperatorState(ExecutionContext &
 
 void PhysicalIndexJoin::Output(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
                                OperatorState &state_p) const {
-	auto &transaction = Transaction::GetTransaction(context.client);
 	auto &phy_tbl_scan = (PhysicalTableScan &)*children[1];
 	auto &bind_tbl = (TableScanBindData &)*phy_tbl_scan.bind_data;
+	auto &transaction = Transaction::Get(context.client, *bind_tbl.table->catalog);
 	auto &state = (IndexJoinOperatorState &)state_p;
 
 	auto tbl = bind_tbl.table->storage.get();

package/src/duckdb/src/execution/operator/persistent/physical_batch_insert.cpp

@@ -264,8 +264,9 @@ unique_ptr<GlobalSinkState> PhysicalBatchInsert::GetGlobalSinkState(ClientContex
 	if (info) {
 		// CREATE TABLE AS
 		D_ASSERT(!insert_table);
-		auto &catalog = Catalog::GetCatalog(context);
-		result->table = (TableCatalogEntry *)catalog.CreateTable(context, schema, info.get());
+		auto &catalog = *schema->catalog;
+		result->table =
+		    (TableCatalogEntry *)catalog.CreateTable(catalog.GetCatalogTransaction(context), schema, info.get());
 	} else {
 		D_ASSERT(insert_table);
 		result->table = insert_table;

package/src/duckdb/src/execution/operator/persistent/physical_delete.cpp

@@ -37,7 +37,7 @@ SinkResultType PhysicalDelete::Sink(ExecutionContext &context, GlobalSinkState &
 	auto &ustate = (DeleteLocalState &)lstate;
 
 	// get rows and
-	auto &transaction = Transaction::GetTransaction(context.client);
+	auto &transaction = Transaction::Get(context.client, table.db);
 	auto &row_identifiers = input.data[row_id_index];
 
 	vector<column_t> column_ids;

package/src/duckdb/src/execution/operator/persistent/physical_export.cpp

@@ -115,7 +115,7 @@ void PhysicalExport::GetData(ExecutionContext &context, DataChunk &chunk, Global
 	vector<CatalogEntry *> indexes;
 	vector<CatalogEntry *> macros;
 
-	auto schema_list = Catalog::GetCatalog(ccontext).schemas->GetEntries<SchemaCatalogEntry>(context.client);
+	auto schema_list = Catalog::GetSchemas(ccontext, info->catalog);
 	for (auto &schema : schema_list) {
 		if (!schema->internal) {
 			schemas.push_back(schema);

package/src/duckdb/src/execution/operator/persistent/physical_insert.cpp

@@ -75,8 +75,9 @@ unique_ptr<GlobalSinkState> PhysicalInsert::GetGlobalSinkState(ClientContext &co
 	if (info) {
 		// CREATE TABLE AS
 		D_ASSERT(!insert_table);
-		auto &catalog = Catalog::GetCatalog(context);
-		result->table = (TableCatalogEntry *)catalog.CreateTable(context, schema, info.get());
+		auto &catalog = *schema->catalog;
+		result->table =
+		    (TableCatalogEntry *)catalog.CreateTable(catalog.GetCatalogTransaction(context), schema, info.get());
 	} else {
 		D_ASSERT(insert_table);
 		result->table = insert_table;
@@ -188,7 +189,7 @@ void PhysicalInsert::Combine(ExecutionContext &context, GlobalSinkState &gstate_
 		gstate.insert_count += append_count;
 		auto table = gstate.table;
 		table->storage->InitializeLocalAppend(gstate.append_state, context.client);
-		auto &transaction = Transaction::GetTransaction(context.client);
+		auto &transaction = Transaction::Get(context.client, *table->catalog);
 		lstate.local_collection->Scan(transaction, [&](DataChunk &insert_chunk) {
 			table->storage->LocalAppend(gstate.append_state, *table, context.client, insert_chunk);
 			return true;

package/src/duckdb/src/execution/operator/schema/physical_alter.cpp

@@ -25,7 +25,7 @@ void PhysicalAlter::GetData(ExecutionContext &context, DataChunk &chunk, GlobalS
 	if (state.finished) {
 		return;
 	}
-	auto &catalog = Catalog::GetCatalog(context.client);
+	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
 	catalog.Alter(context.client, info.get());
 	state.finished = true;
 }

package/src/duckdb/src/execution/operator/schema/physical_attach.cpp

@@ -0,0 +1,72 @@
+#include "duckdb/execution/operator/schema/physical_attach.hpp"
+#include "duckdb/parser/parsed_data/attach_info.hpp"
+#include "duckdb/catalog/catalog.hpp"
+#include "duckdb/main/database_manager.hpp"
+#include "duckdb/main/attached_database.hpp"
+#include "duckdb/main/database.hpp"
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// Source
+//===--------------------------------------------------------------------===//
+class AttachSourceState : public GlobalSourceState {
+public:
+	AttachSourceState() : finished(false) {
+	}
+
+	bool finished;
+};
+
+unique_ptr<GlobalSourceState> PhysicalAttach::GetGlobalSourceState(ClientContext &context) const {
+	return make_unique<AttachSourceState>();
+}
+
+void PhysicalAttach::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
+                             LocalSourceState &lstate) const {
+	auto &state = (AttachSourceState &)gstate;
+	if (state.finished) {
+		return;
+	}
+	// parse the options
+	auto &config = DBConfig::GetConfig(context.client);
+	AccessMode access_mode = config.options.access_mode;
+	for (auto &entry : info->options) {
+		if (entry.first == "readonly" || entry.first == "read_only") {
+			auto read_only = BooleanValue::Get(entry.second.DefaultCastAs(LogicalType::BOOLEAN));
+			if (read_only) {
+				access_mode = AccessMode::READ_ONLY;
+			} else {
+				access_mode = AccessMode::READ_WRITE;
+			}
+		} else if (entry.first == "read_write" || entry.first == "read_write") {
+			auto read_only = !BooleanValue::Get(entry.second.DefaultCastAs(LogicalType::BOOLEAN));
+			if (read_only) {
+				access_mode = AccessMode::READ_ONLY;
+			} else {
+				access_mode = AccessMode::READ_WRITE;
+			}
+		} else {
+			throw BinderException("Unrecognized option for attach \"%s\"", entry.first);
+		}
+	}
+	// attach the database
+	auto name = info->name;
+	auto path = info->path;
+	auto &db = DatabaseInstance::GetDatabase(context.client);
+	if (name.empty()) {
+		name = AttachedDatabase::ExtractDatabaseName(path);
+	}
+	auto &db_manager = DatabaseManager::Get(context.client);
+	auto existing_db = db_manager.GetDatabaseFromPath(context.client, path);
+	if (existing_db) {
+		throw BinderException("Database \"%s\" is already attached with alias \"%s\"", path, existing_db->GetName());
+	}
+	auto new_db = make_unique<AttachedDatabase>(db, Catalog::GetSystemCatalog(context.client), name, path, access_mode);
+	new_db->Initialize();
+
+	db_manager.AddDatabase(context.client, move(new_db));
+	state.finished = true;
+}
+
+} // namespace duckdb

package/src/duckdb/src/execution/operator/schema/physical_create_function.cpp

@@ -26,7 +26,8 @@ void PhysicalCreateFunction::GetData(ExecutionContext &context, DataChunk &chunk
 	if (state.finished) {
 		return;
 	}
-	Catalog::GetCatalog(context.client).CreateFunction(context.client, info.get());
+	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
+	catalog.CreateFunction(context.client, info.get());
 	state.finished = true;
 }
 

package/src/duckdb/src/execution/operator/schema/physical_create_index.cpp

@@ -6,6 +6,7 @@
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/storage/storage_manager.hpp"
+#include "duckdb/main/database_manager.hpp"
 
 namespace duckdb {
 
@@ -38,14 +39,13 @@ public:
 };
 
 unique_ptr<GlobalSinkState> PhysicalCreateIndex::GetGlobalSinkState(ClientContext &context) const {
-
 	auto state = make_unique<CreateIndexGlobalSinkState>();
 
 	// create the global index
 	switch (info->index_type) {
 	case IndexType::ART: {
 		state->global_index = make_unique<ART>(storage_ids, TableIOManager::Get(*table.storage), unbound_expressions,
-		                                       info->constraint_type, *context.db);
+		                                       info->constraint_type, table.storage->db);
 		break;
 	}
 	default:
@@ -64,7 +64,7 @@ unique_ptr<LocalSinkState> PhysicalCreateIndex::GetLocalSinkState(ExecutionConte
 	switch (info->index_type) {
 	case IndexType::ART: {
 		state->local_index = make_unique<ART>(storage_ids, TableIOManager::Get(*table.storage), unbound_expressions,
-		                                      info->constraint_type, *context.client.db);
+		                                      info->constraint_type, table.storage->db);
 		break;
 	}
 	default:

package/src/duckdb/src/execution/operator/schema/physical_create_schema.cpp

@@ -24,7 +24,11 @@ void PhysicalCreateSchema::GetData(ExecutionContext &context, DataChunk &chunk,
 	if (state.finished) {
 		return;
 	}
-	Catalog::GetCatalog(context.client).CreateSchema(context.client, info.get());
+	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
+	if (catalog.IsSystemCatalog()) {
+		throw BinderException("Cannot create schema in system catalog");
+	}
+	catalog.CreateSchema(context.client, info.get());
 	state.finished = true;
 }
 

package/src/duckdb/src/execution/operator/schema/physical_create_sequence.cpp

@@ -24,7 +24,8 @@ void PhysicalCreateSequence::GetData(ExecutionContext &context, DataChunk &chunk
 	if (state.finished) {
 		return;
 	}
-	Catalog::GetCatalog(context.client).CreateSequence(context.client, info.get());
+	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
+	catalog.CreateSequence(context.client, info.get());
 	state.finished = true;
 }
 

package/src/duckdb/src/execution/operator/schema/physical_create_table.cpp

@@ -34,8 +34,8 @@ void PhysicalCreateTable::GetData(ExecutionContext &context, DataChunk &chunk, G
 	if (state.finished) {
 		return;
 	}
-	auto &catalog = Catalog::GetCatalog(context.client);
-	catalog.CreateTable(context.client, schema, info.get());
+	auto &catalog = *schema->catalog;
+	catalog.CreateTable(catalog.GetCatalogTransaction(context.client), schema, info.get());
 	state.finished = true;
 }
 

package/src/duckdb/src/execution/operator/schema/physical_create_type.cpp

@@ -108,7 +108,7 @@ void PhysicalCreateType::GetData(ExecutionContext &context, DataChunk &chunk, Gl
 		info->type = LogicalType::ENUM(info->name, result, total_row_count);
 	}
 
-	auto &catalog = Catalog::GetCatalog(context.client);
+	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
 	catalog.CreateType(context.client, info.get());
 	state.finished = true;
 }

package/src/duckdb/src/execution/operator/schema/physical_create_view.cpp

@@ -24,7 +24,8 @@ void PhysicalCreateView::GetData(ExecutionContext &context, DataChunk &chunk, Gl
 	if (state.finished) {
 		return;
 	}
-	Catalog::GetCatalog(context.client).CreateView(context.client, info.get());
+	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
+	catalog.CreateView(context.client, info.get());
 	state.finished = true;
 }
 

package/src/duckdb/src/execution/operator/schema/physical_drop.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/execution/operator/schema/physical_drop.hpp"
 #include "duckdb/main/client_data.hpp"
+#include "duckdb/main/database_manager.hpp"
 
 namespace duckdb {
 
@@ -33,10 +34,17 @@ void PhysicalDrop::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSo
 		}
 		break;
 	}
-	default:
-		Catalog::GetCatalog(context.client).DropEntry(context.client, info.get());
+	case CatalogType::DATABASE_ENTRY: {
+		auto &db_manager = DatabaseManager::Get(context.client);
+		db_manager.DetachDatabase(context.client, info->name, info->if_exists);
 		break;
 	}
+	default: {
+		auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
+		catalog.DropEntry(context.client, info.get());
+		break;
+	}
+	}
 	state.finished = true;
 }
 

package/src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp

@@ -18,12 +18,13 @@
 
 namespace duckdb {
 
-static bool CanPlanIndexJoin(Transaction &transaction, TableScanBindData *bind_data, PhysicalTableScan &scan) {
+static bool CanPlanIndexJoin(ClientContext &context, TableScanBindData *bind_data, PhysicalTableScan &scan) {
 	if (!bind_data) {
 		// not a table scan
 		return false;
 	}
 	auto table = bind_data->table;
+	auto &transaction = Transaction::Get(context, *table->catalog);
 	auto &local_storage = LocalStorage::Get(transaction);
 	if (local_storage.Find(table->storage.get())) {
 		// transaction local appends: skip index join
@@ -146,7 +147,6 @@ static void CanUseIndexJoin(TableScanBindData *tbl, Expression &expr, Index **re
 
 void TransformIndexJoin(ClientContext &context, LogicalComparisonJoin &op, Index **left_index, Index **right_index,
                         PhysicalOperator *left, PhysicalOperator *right) {
-	auto &transaction = Transaction::GetTransaction(context);
 	// check if one of the tables has an index on column
 	if (op.join_type == JoinType::INNER && op.conditions.size() == 1) {
 		// check if one of the children are table scans and if they have an index in the join attribute
@@ -154,14 +154,14 @@ void TransformIndexJoin(ClientContext &context, LogicalComparisonJoin &op, Index
 		if (left->type == PhysicalOperatorType::TABLE_SCAN) {
 			auto &tbl_scan = (PhysicalTableScan &)*left;
 			auto tbl = dynamic_cast<TableScanBindData *>(tbl_scan.bind_data.get());
-			if (CanPlanIndexJoin(transaction, tbl, tbl_scan)) {
+			if (CanPlanIndexJoin(context, tbl, tbl_scan)) {
 				CanUseIndexJoin(tbl, *op.conditions[0].left, left_index);
 			}
 		}
 		if (right->type == PhysicalOperatorType::TABLE_SCAN) {
 			auto &tbl_scan = (PhysicalTableScan &)*right;
 			auto tbl = dynamic_cast<TableScanBindData *>(tbl_scan.bind_data.get());
-			if (CanPlanIndexJoin(transaction, tbl, tbl_scan)) {
+			if (CanPlanIndexJoin(context, tbl, tbl_scan)) {
 				CanUseIndexJoin(tbl, *op.conditions[0].right, right_index);
 			}
 		}

package/src/duckdb/src/execution/physical_plan/plan_create_index.cpp

@@ -25,7 +25,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateInde
 	    make_unique<PhysicalTableScan>(op.info->scan_types, op.function, move(op.bind_data), op.info->column_ids,
 	                                   op.info->names, move(table_filters), op.estimated_cardinality);
 
-	dependencies.insert(&op.table);
+	dependencies.AddDependency(&op.table);
 	op.info->column_ids.pop_back();
 
 	D_ASSERT(op.info->scan_types.size() - 1 <= op.info->names.size());

package/src/duckdb/src/execution/physical_plan/plan_create_table.cpp

@@ -14,9 +14,8 @@ namespace duckdb {
 
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateTable &op) {
 	auto &create_info = (CreateTableInfo &)*op.info->base;
-	auto &catalog = Catalog::GetCatalog(context);
-	auto existing_entry =
-	    catalog.GetEntry(context, CatalogType::TABLE_ENTRY, create_info.schema, create_info.table, true);
+	auto &catalog = *op.info->schema->catalog;
+	auto existing_entry = catalog.GetEntry<TableCatalogEntry>(context, create_info.schema, create_info.table, true);
 	bool replace = op.info->Base().on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT;
 	if ((!existing_entry || replace) && !op.children.empty()) {
 		auto plan = CreatePlan(*op.children[0]);

package/src/duckdb/src/execution/physical_plan/plan_delete.cpp

@@ -16,7 +16,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelete &op
 	// get the index of the row_id column
 	auto &bound_ref = (BoundReferenceExpression &)*op.expressions[0];
 
-	dependencies.insert(op.table);
+	dependencies.AddDependency(op.table);
 	auto del = make_unique<PhysicalDelete>(op.types, *op.table, *op.table->storage, bound_ref.index,
 	                                       op.estimated_cardinality, op.return_chunk);
 	del->children.push_back(move(plan));

package/src/duckdb/src/execution/physical_plan/plan_insert.cpp

@@ -50,7 +50,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalInsert &op
 		D_ASSERT(op.children.size() == 1);
 		plan = CreatePlan(*op.children[0]);
 	}
-	dependencies.insert(op.table);
+	dependencies.AddDependency(op.table);
 
 	bool parallel_streaming_insert = !PreserveInsertionOrder(*plan);
 	bool use_batch_index = UseBatchIndex(*plan);

package/src/duckdb/src/execution/physical_plan/plan_simple.cpp

@@ -2,6 +2,7 @@
 #include "duckdb/execution/operator/helper/physical_transaction.hpp"
 #include "duckdb/execution/operator/helper/physical_vacuum.hpp"
 #include "duckdb/execution/operator/schema/physical_alter.hpp"
+#include "duckdb/execution/operator/schema/physical_attach.hpp"
 #include "duckdb/execution/operator/schema/physical_create_schema.hpp"
 #include "duckdb/execution/operator/schema/physical_create_sequence.hpp"
 #include "duckdb/execution/operator/schema/physical_create_view.hpp"
@@ -33,6 +34,9 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalSimple &op
 	}
 	case LogicalOperatorType::LOGICAL_LOAD:
 		return make_unique<PhysicalLoad>(unique_ptr_cast<ParseInfo, LoadInfo>(move(op.info)), op.estimated_cardinality);
+	case LogicalOperatorType::LOGICAL_ATTACH:
+		return make_unique<PhysicalAttach>(unique_ptr_cast<ParseInfo, AttachInfo>(move(op.info)),
+		                                   op.estimated_cardinality);
 	default:
 		throw NotImplementedException("Unimplemented type for logical simple operator");
 	}

package/src/duckdb/src/execution/physical_plan/plan_update.cpp

@@ -10,7 +10,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalUpdate &op
 
 	auto plan = CreatePlan(*op.children[0]);
 
-	dependencies.insert(op.table);
+	dependencies.AddDependency(op.table);
 	auto update = make_unique<PhysicalUpdate>(op.types, *op.table, *op.table->storage, op.columns, move(op.expressions),
 	                                          move(op.bound_defaults), op.estimated_cardinality, op.return_chunk);
 

package/src/duckdb/src/execution/physical_plan_generator.cpp

@@ -13,7 +13,7 @@ namespace duckdb {
 
 class DependencyExtractor : public LogicalOperatorVisitor {
 public:
-	explicit DependencyExtractor(unordered_set<CatalogEntry *> &dependencies) : dependencies(dependencies) {
+	explicit DependencyExtractor(DependencyList &dependencies) : dependencies(dependencies) {
 	}
 
 protected:
@@ -26,7 +26,7 @@ protected:
 	}
 
 private:
-	unordered_set<CatalogEntry *> &dependencies;
+	DependencyList &dependencies;
 };
 
 PhysicalPlanGenerator::PhysicalPlanGenerator(ClientContext &context) : context(context) {
@@ -180,6 +180,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalOperator &
 	case LogicalOperatorType::LOGICAL_DROP:
 	case LogicalOperatorType::LOGICAL_VACUUM:
 	case LogicalOperatorType::LOGICAL_LOAD:
+	case LogicalOperatorType::LOGICAL_ATTACH:
 		plan = CreatePlan((LogicalSimple &)op);
 		break;
 	case LogicalOperatorType::LOGICAL_RECURSIVE_CTE: