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

package/src/duckdb/src/planner/binder/statement/bind_create_table.cpp

@@ -217,7 +217,7 @@ void Binder::BindDefaultValues(ColumnList &columns, vector<unique_ptr<Expression
 	}
 }
 
-static void ExtractExpressionDependencies(Expression &expr, unordered_set<CatalogEntry *> &dependencies) {
+static void ExtractExpressionDependencies(Expression &expr, DependencyList &dependencies) {
 	if (expr.type == ExpressionType::BOUND_FUNCTION) {
 		auto &function = (BoundFunctionExpression &)expr;
 		if (function.function.dependency) {
@@ -241,12 +241,10 @@ static void ExtractDependencies(BoundCreateTableInfo &info) {
 		}
 	}
 }
-
-unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateInfo> info) {
+unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateInfo> info, SchemaCatalogEntry *schema) {
 	auto &base = (CreateTableInfo &)*info;
-
 	auto result = make_unique<BoundCreateTableInfo>(move(info));
-	result->schema = BindSchema(*result->base);
+	result->schema = schema;
 	if (base.query) {
 		// construct the result object
 		auto query_obj = Bind(*base.query);
@@ -284,16 +282,22 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 		if (column.Type().id() == LogicalTypeId::VARCHAR) {
 			ExpressionBinder::TestCollation(context, StringType::GetCollation(column.Type()));
 		}
-		BindLogicalType(context, column.TypeMutable());
+		BindLogicalType(context, column.TypeMutable(), result->schema->catalog->GetName());
 		// We add a catalog dependency
 		auto type_dependency = LogicalType::GetCatalog(column.Type());
 		if (type_dependency) {
 			// Only if the USER comes from a create type
-			result->dependencies.insert(type_dependency);
+			result->dependencies.AddDependency(type_dependency);
 		}
 	}
 	properties.allow_stream_result = false;
 	return result;
 }
 
+unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateInfo> info) {
+	auto &base = (CreateTableInfo &)*info;
+	auto schema = BindCreateSchema(base);
+	return BindCreateTableInfo(move(info), schema);
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/binder/statement/bind_delete.cpp

@@ -28,7 +28,7 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) {
 
 	if (!table->temporary) {
 		// delete from persistent table: not read only!
-		properties.read_only = false;
+		properties.modified_databases.insert(table->catalog->GetName());
 	}
 
 	// Add CTEs as bindable

package/src/duckdb/src/planner/binder/statement/bind_drop.cpp

@@ -16,10 +16,12 @@ BoundStatement Binder::Bind(DropStatement &stmt) {
 		// it also does not require a valid transaction
 		properties.requires_valid_transaction = false;
 		break;
-	case CatalogType::SCHEMA_ENTRY:
+	case CatalogType::SCHEMA_ENTRY: {
 		// dropping a schema is never read-only because there are no temporary schemas
-		properties.read_only = false;
+		auto &catalog = Catalog::GetCatalog(context, stmt.info->catalog);
+		properties.modified_databases.insert(catalog.GetName());
 		break;
+	}
 	case CatalogType::VIEW_ENTRY:
 	case CatalogType::SEQUENCE_ENTRY:
 	case CatalogType::MACRO_ENTRY:
@@ -27,18 +29,24 @@ BoundStatement Binder::Bind(DropStatement &stmt) {
 	case CatalogType::INDEX_ENTRY:
 	case CatalogType::TABLE_ENTRY:
 	case CatalogType::TYPE_ENTRY: {
-		auto entry = (StandardEntry *)Catalog::GetCatalog(context).GetEntry(context, stmt.info->type, stmt.info->schema,
-		                                                                    stmt.info->name, true);
+		BindSchemaOrCatalog(stmt.info->catalog, stmt.info->schema);
+		auto entry = (StandardEntry *)Catalog::GetEntry(context, stmt.info->type, stmt.info->catalog, stmt.info->schema,
+		                                                stmt.info->name, true);
 		if (!entry) {
 			break;
 		}
+		stmt.info->catalog = entry->catalog->GetName();
 		if (!entry->temporary) {
 			// we can only drop temporary tables in read-only mode
-			properties.read_only = false;
+			properties.modified_databases.insert(stmt.info->catalog);
 		}
 		stmt.info->schema = entry->schema->name;
 		break;
 	}
+	case CatalogType::DATABASE_ENTRY:
+		// attaching and detaching is read-only
+		stmt.info->catalog = SYSTEM_CATALOG;
+		break;
 	default:
 		throw BinderException("Unknown catalog type for drop statement!");
 	}

package/src/duckdb/src/planner/binder/statement/bind_export.cpp

@@ -96,15 +96,16 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 	result.names = {"Success"};
 
 	// lookup the format in the catalog
-	auto &catalog = Catalog::GetCatalog(context);
-	auto copy_function = catalog.GetEntry<CopyFunctionCatalogEntry>(context, DEFAULT_SCHEMA, stmt.info->format);
+	auto copy_function =
+	    Catalog::GetEntry<CopyFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, stmt.info->format);
 	if (!copy_function->function.copy_to_bind) {
 		throw NotImplementedException("COPY TO is not supported for FORMAT \"%s\"", stmt.info->format);
 	}
 
 	// gather a list of all the tables
+	string catalog = stmt.database.empty() ? INVALID_CATALOG : stmt.database;
 	vector<TableCatalogEntry *> tables;
-	auto schemas = catalog.schemas->GetEntries<SchemaCatalogEntry>(context);
+	auto schemas = Catalog::GetSchemas(context, catalog);
 	for (auto &schema : schemas) {
 		schema->Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry *entry) {
 			if (entry->type == CatalogType::TABLE_ENTRY) {
@@ -153,6 +154,7 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 			id++;
 		}
 		info->is_from = false;
+		info->catalog = catalog;
 		info->schema = table->schema->name;
 		info->table = table->name;
 
@@ -161,6 +163,7 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 			info->select_list.push_back(col.GetName());
 		}
 
+		exported_data.database_name = catalog;
 		exported_data.table_name = info->table;
 		exported_data.schema_name = info->schema;
 		exported_data.file_path = info->file_path;

package/src/duckdb/src/planner/binder/statement/bind_extension.cpp

@@ -11,7 +11,7 @@ BoundStatement Binder::Bind(ExtensionStatement &stmt) {
 	D_ASSERT(stmt.extension.plan_function);
 	auto parse_result = stmt.extension.plan_function(stmt.extension.parser_info.get(), context, move(stmt.parse_data));
 
-	properties.read_only = parse_result.read_only;
+	properties.modified_databases = parse_result.modified_databases;
 	properties.requires_valid_transaction = parse_result.requires_valid_transaction;
 	properties.return_type = parse_result.return_type;
 

package/src/duckdb/src/planner/binder/statement/bind_insert.cpp

@@ -30,11 +30,12 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	result.names = {"Count"};
 	result.types = {LogicalType::BIGINT};
 
-	auto table = Catalog::GetCatalog(context).GetEntry<TableCatalogEntry>(context, stmt.schema, stmt.table);
+	BindSchemaOrCatalog(stmt.catalog, stmt.schema);
+	auto table = Catalog::GetEntry<TableCatalogEntry>(context, stmt.catalog, stmt.schema, stmt.table);
 	D_ASSERT(table);
 	if (!table->temporary) {
 		// inserting into a non-temporary table: alters underlying database
-		properties.read_only = false;
+		properties.modified_databases.insert(table->catalog->GetName());
 	}
 
 	auto insert = make_unique<LogicalInsert>(table, GenerateTableIndex());

package/src/duckdb/src/planner/binder/statement/bind_pragma.cpp

@@ -8,9 +8,9 @@
 namespace duckdb {
 
 BoundStatement Binder::Bind(PragmaStatement &stmt) {
-	auto &catalog = Catalog::GetCatalog(context);
 	// bind the pragma function
-	auto entry = catalog.GetEntry<PragmaFunctionCatalogEntry>(context, DEFAULT_SCHEMA, stmt.info->name, false);
+	auto entry =
+	    Catalog::GetEntry<PragmaFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, stmt.info->name, false);
 	string error;
 	FunctionBinder function_binder(context);
 	idx_t bound_idx = function_binder.BindFunction(entry->name, entry->functions, *stmt.info, error);

package/src/duckdb/src/planner/binder/statement/bind_prepare.cpp

@@ -11,8 +11,6 @@ BoundStatement Binder::Bind(PrepareStatement &stmt) {
 	this->bound_tables = prepared_planner.binder->bound_tables;
 
 	auto prepare = make_unique<LogicalPrepare>(stmt.name, move(prepared_data), move(prepared_planner.plan));
-	// we can prepare in read-only mode: prepared statements are not written to the catalog
-	properties.read_only = true;
 	// we can always prepare, even if the transaction has been invalidated
 	// this is required because most clients ALWAYS invoke prepared statements
 	properties.requires_valid_transaction = false;

package/src/duckdb/src/planner/binder/statement/bind_simple.cpp

@@ -2,6 +2,7 @@
 #include "duckdb/parser/statement/transaction_statement.hpp"
 #include "duckdb/planner/operator/logical_simple.hpp"
 #include "duckdb/catalog/catalog.hpp"
+#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
 #include "duckdb/planner/binder.hpp"
@@ -15,12 +16,16 @@ BoundStatement Binder::Bind(AlterStatement &stmt) {
 	BoundStatement result;
 	result.names = {"Success"};
 	result.types = {LogicalType::BOOLEAN};
-	Catalog &catalog = Catalog::GetCatalog(context);
-	auto entry = catalog.GetEntry(context, stmt.info->GetCatalogType(), stmt.info->schema, stmt.info->name,
-	                              stmt.info->if_exists);
-	if (entry && !entry->temporary) {
-		// we can only alter temporary tables/views in read-only mode
-		properties.read_only = false;
+	BindSchemaOrCatalog(stmt.info->catalog, stmt.info->schema);
+	auto entry = Catalog::GetEntry(context, stmt.info->GetCatalogType(), stmt.info->catalog, stmt.info->schema,
+	                               stmt.info->name, stmt.info->if_exists);
+	if (entry) {
+		if (!entry->temporary) {
+			// we can only alter temporary tables/views in read-only mode
+			properties.modified_databases.insert(entry->catalog->GetName());
+		}
+		stmt.info->catalog = entry->catalog->GetName();
+		stmt.info->schema = ((StandardEntry *)entry)->schema->name;
 	}
 	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_ALTER, move(stmt.info));
 	properties.return_type = StatementReturnType::NOTHING;

package/src/duckdb/src/planner/binder/statement/bind_update.cpp

@@ -157,7 +157,7 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 
 	if (!table->temporary) {
 		// update of persistent table: not read only!
-		properties.read_only = false;
+		properties.modified_databases.insert(table->catalog->GetName());
 	}
 	auto update = make_unique<LogicalUpdate>(table);
 

package/src/duckdb/src/planner/binder/tableref/bind_basetableref.cpp

@@ -63,11 +63,15 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 	}
 	// not a CTE
 	// extract a table or view from the catalog
-	auto &catalog = Catalog::GetCatalog(context);
-	auto table_or_view =
-	    catalog.GetEntry(context, CatalogType::TABLE_ENTRY, ref.schema_name, ref.table_name, true, error_context);
+	BindSchemaOrCatalog(ref.catalog_name, ref.schema_name);
+	auto table_or_view = Catalog::GetEntry(context, CatalogType::TABLE_ENTRY, ref.catalog_name, ref.schema_name,
+	                                       ref.table_name, true, error_context);
 	if (!table_or_view) {
-		auto table_name = ref.schema_name.empty() ? ref.table_name : (ref.schema_name + "." + ref.table_name);
+		string table_name = ref.catalog_name;
+		if (!ref.schema_name.empty()) {
+			table_name += (!table_name.empty() ? "." : "") + ref.schema_name;
+		}
+		table_name += (!table_name.empty() ? "." : "") + ref.table_name;
 		// table could not be found: try to bind a replacement scan
 		auto &config = DBConfig::GetConfig(context);
 		if (context.config.use_replacement_scans) {
@@ -95,8 +99,8 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 			return make_unique_base<BoundTableRef, BoundEmptyTableRef>(table_index);
 		}
 		// could not find an alternative: bind again to get the error
-		table_or_view = Catalog::GetCatalog(context).GetEntry(context, CatalogType::TABLE_ENTRY, ref.schema_name,
-		                                                      ref.table_name, false, error_context);
+		table_or_view = Catalog::GetEntry(context, CatalogType::TABLE_ENTRY, ref.catalog_name, ref.schema_name,
+		                                  ref.table_name, false, error_context);
 	}
 	switch (table_or_view->type) {
 	case CatalogType::TABLE_ENTRY: {

package/src/duckdb/src/planner/binder/tableref/bind_table_function.cpp

@@ -186,10 +186,8 @@ unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
 	TableFunctionCatalogEntry *function = nullptr;
 
 	// fetch the function from the catalog
-	auto &catalog = Catalog::GetCatalog(context);
-
-	auto func_catalog = catalog.GetEntry(context, CatalogType::TABLE_FUNCTION_ENTRY, fexpr->schema,
-	                                     fexpr->function_name, false, error_context);
+	auto func_catalog = Catalog::GetEntry(context, CatalogType::TABLE_FUNCTION_ENTRY, fexpr->catalog, fexpr->schema,
+	                                      fexpr->function_name, false, error_context);
 
 	if (func_catalog->type == CatalogType::TABLE_FUNCTION_ENTRY) {
 		function = (TableFunctionCatalogEntry *)func_catalog;

package/src/duckdb/src/planner/binder.cpp

@@ -87,6 +87,8 @@ BoundStatement Binder::Bind(SQLStatement &statement) {
 		return Bind((ExecuteStatement &)statement);
 	case StatementType::LOGICAL_PLAN_STATEMENT:
 		return Bind((LogicalPlanStatement &)statement);
+	case StatementType::ATTACH_STATEMENT:
+		return Bind((AttachStatement &)statement);
 	default: // LCOV_EXCL_START
 		throw NotImplementedException("Unimplemented statement type \"%s\" for Bind",
 		                              StatementTypeToString(statement.type));
@@ -259,6 +261,7 @@ void Binder::AddBoundView(ViewCatalogEntry *view) {
 }
 
 idx_t Binder::GenerateTableIndex() {
+	D_ASSERT(parent.get() != this);
 	if (parent) {
 		return parent->GenerateTableIndex();
 	}
@@ -327,6 +330,12 @@ bool Binder::HasMatchingBinding(const string &table_name, const string &column_n
 
 bool Binder::HasMatchingBinding(const string &schema_name, const string &table_name, const string &column_name,
                                 string &error_message) {
+	string empty_catalog;
+	return HasMatchingBinding(empty_catalog, schema_name, table_name, column_name, error_message);
+}
+
+bool Binder::HasMatchingBinding(const string &catalog_name, const string &schema_name, const string &table_name,
+                                const string &column_name, string &error_message) {
 	Binding *binding = nullptr;
 	D_ASSERT(!lambda_bindings);
 	if (macro_binding && table_name == macro_binding->alias) {
@@ -338,12 +347,18 @@ bool Binder::HasMatchingBinding(const string &schema_name, const string &table_n
 	if (!binding) {
 		return false;
 	}
-	if (!schema_name.empty()) {
+	if (!catalog_name.empty() || !schema_name.empty()) {
 		auto catalog_entry = binding->GetStandardEntry();
 		if (!catalog_entry) {
 			return false;
 		}
-		if (catalog_entry->schema->name != schema_name || catalog_entry->name != table_name) {
+		if (!catalog_name.empty() && catalog_entry->catalog->GetName() != catalog_name) {
+			return false;
+		}
+		if (!schema_name.empty() && catalog_entry->schema->name != schema_name) {
+			return false;
+		}
+		if (catalog_entry->name != table_name) {
 			return false;
 		}
 	}

package/src/duckdb/src/planner/logical_operator.cpp

@@ -282,9 +282,6 @@ unique_ptr<LogicalOperator> LogicalOperator::Deserialize(Deserializer &deseriali
 	case LogicalOperatorType::LOGICAL_UPDATE:
 		result = LogicalUpdate::Deserialize(state, reader);
 		break;
-	case LogicalOperatorType::LOGICAL_ALTER:
-		result = LogicalSimple::Deserialize(state, reader);
-		break;
 	case LogicalOperatorType::LOGICAL_CREATE_TABLE:
 		result = LogicalCreateTable::Deserialize(state, reader);
 		break;
@@ -303,15 +300,9 @@ unique_ptr<LogicalOperator> LogicalOperator::Deserialize(Deserializer &deseriali
 	case LogicalOperatorType::LOGICAL_CREATE_MACRO:
 		result = LogicalCreate::Deserialize(state, reader);
 		break;
-	case LogicalOperatorType::LOGICAL_DROP:
-		result = LogicalSimple::Deserialize(state, reader);
-		break;
 	case LogicalOperatorType::LOGICAL_PRAGMA:
 		result = LogicalPragma::Deserialize(state, reader);
 		break;
-	case LogicalOperatorType::LOGICAL_TRANSACTION:
-		result = LogicalSimple::Deserialize(state, reader);
-		break;
 	case LogicalOperatorType::LOGICAL_CREATE_TYPE:
 		result = LogicalCreate::Deserialize(state, reader);
 		break;
@@ -330,16 +321,18 @@ unique_ptr<LogicalOperator> LogicalOperator::Deserialize(Deserializer &deseriali
 	case LogicalOperatorType::LOGICAL_EXPORT:
 		result = LogicalExport::Deserialize(state, reader);
 		break;
-	case LogicalOperatorType::LOGICAL_VACUUM:
-		result = LogicalSimple::Deserialize(state, reader);
-		break;
 	case LogicalOperatorType::LOGICAL_SET:
 		result = LogicalSet::Deserialize(state, reader);
 		break;
 	case LogicalOperatorType::LOGICAL_RESET:
 		result = LogicalReset::Deserialize(state, reader);
 		break;
+	case LogicalOperatorType::LOGICAL_ALTER:
+	case LogicalOperatorType::LOGICAL_VACUUM:
 	case LogicalOperatorType::LOGICAL_LOAD:
+	case LogicalOperatorType::LOGICAL_ATTACH:
+	case LogicalOperatorType::LOGICAL_TRANSACTION:
+	case LogicalOperatorType::LOGICAL_DROP:
 		result = LogicalSimple::Deserialize(state, reader);
 		break;
 	case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR:

package/src/duckdb/src/planner/operator/logical_copy_to_file.cpp

@@ -34,12 +34,11 @@ unique_ptr<LogicalOperator> LogicalCopyToFile::Deserialize(LogicalDeserializatio
 	auto has_bind_data = reader.ReadRequired<bool>();
 
 	auto &context = state.gstate.context;
-	auto &catalog = Catalog::GetCatalog(context);
-	auto func_catalog = catalog.GetEntry(context, CatalogType::COPY_FUNCTION_ENTRY, DEFAULT_SCHEMA, copy_func_name);
-	if (!func_catalog || func_catalog->type != CatalogType::COPY_FUNCTION_ENTRY) {
+	auto copy_func_catalog_entry =
+	    Catalog::GetEntry<CopyFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, copy_func_name);
+	if (!copy_func_catalog_entry) {
 		throw InternalException("Cant find catalog entry for function %s", copy_func_name);
 	}
-	auto copy_func_catalog_entry = (CopyFunctionCatalogEntry *)func_catalog;
 	CopyFunction copy_func = copy_func_catalog_entry->function;
 
 	unique_ptr<FunctionData> bind_data;

package/src/duckdb/src/planner/operator/logical_create.cpp

@@ -10,10 +10,7 @@ unique_ptr<LogicalOperator> LogicalCreate::Deserialize(LogicalDeserializationSta
 	auto &context = state.gstate.context;
 	auto info = CreateInfo::Deserialize(reader.GetSource());
 
-	auto &catalog = Catalog::GetCatalog(context);
-	// TODO(stephwang): review if below is necessary or just not pass schema_catalog_entry
-	SchemaCatalogEntry *schema_catalog_entry = catalog.GetSchema(context, info->schema, true);
-
+	auto schema_catalog_entry = Catalog::GetSchema(context, INVALID_CATALOG, info->schema, true);
 	return make_unique<LogicalCreate>(state.type, move(info), schema_catalog_entry);
 }
 

package/src/duckdb/src/planner/operator/logical_create_index.cpp

@@ -20,9 +20,9 @@ unique_ptr<LogicalOperator> LogicalCreateIndex::Deserialize(LogicalDeserializati
 
 	auto &context = state.gstate.context;
 	auto catalog_info = TableCatalogEntry::Deserialize(reader.GetSource(), context);
-	auto &catalog = Catalog::GetCatalog(context);
-	TableCatalogEntry *table = catalog.GetEntry<TableCatalogEntry>(context, catalog_info->schema, catalog_info->table);
 
+	auto table =
+	    Catalog::GetEntry<TableCatalogEntry>(context, INVALID_CATALOG, catalog_info->schema, catalog_info->table);
 	auto unbound_expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
 
 	auto create_info = reader.ReadOptional<CreateInfo>(nullptr);

package/src/duckdb/src/planner/operator/logical_delete.cpp

@@ -13,9 +13,8 @@ unique_ptr<LogicalOperator> LogicalDelete::Deserialize(LogicalDeserializationSta
 	auto &context = state.gstate.context;
 	auto info = TableCatalogEntry::Deserialize(reader.GetSource(), context);
 
-	auto &catalog = Catalog::GetCatalog(context);
-
-	TableCatalogEntry *table_catalog_entry = catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->table);
+	auto table_catalog_entry =
+	    Catalog::GetEntry<TableCatalogEntry>(context, INVALID_CATALOG, info->schema, info->table);
 
 	auto table_index = reader.ReadRequired<idx_t>();
 	auto result = make_unique<LogicalDelete>(table_catalog_entry, table_index);

package/src/duckdb/src/planner/operator/logical_insert.cpp

@@ -34,7 +34,7 @@ unique_ptr<LogicalOperator> LogicalInsert::Deserialize(LogicalDeserializationSta
 	auto return_chunk = reader.ReadRequired<bool>();
 	auto bound_defaults = reader.ReadRequiredSerializableList<Expression>(state.gstate);
 
-	auto &catalog = Catalog::GetCatalog(context);
+	auto &catalog = Catalog::GetCatalog(context, INVALID_CATALOG);
 
 	TableCatalogEntry *table_catalog_entry = catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->table);
 

package/src/duckdb/src/planner/operator/logical_update.cpp

@@ -17,7 +17,7 @@ void LogicalUpdate::Serialize(FieldWriter &writer) const {
 unique_ptr<LogicalOperator> LogicalUpdate::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
 	auto &context = state.gstate.context;
 	auto info = TableCatalogEntry::Deserialize(reader.GetSource(), context);
-	auto &catalog = Catalog::GetCatalog(context);
+	auto &catalog = Catalog::GetCatalog(context, INVALID_CATALOG);
 
 	TableCatalogEntry *table_catalog_entry = catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->table);
 

package/src/duckdb/src/planner/parsed_data/bound_create_table_info.cpp

@@ -39,7 +39,7 @@ unique_ptr<BoundCreateTableInfo> BoundCreateTableInfo::Deserialize(Deserializer
 	auto schema_name = create_info->schema;
 	auto result = make_unique<BoundCreateTableInfo>(move(create_info));
 	auto &context = state.context;
-	result->schema = Catalog::GetCatalog(context).GetSchema(context, schema_name);
+	result->schema = Catalog::GetSchema(context, INVALID_CATALOG, schema_name);
 	result->base = source.ReadOptional<CreateInfo>();
 
 	source.ReadList<Constraint>(result->constraints);

package/src/duckdb/src/planner/planner.cpp

@@ -8,8 +8,8 @@
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
 #include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/transaction/transaction.hpp"
 #include "duckdb/common/serializer/buffered_deserializer.hpp"
+#include "duckdb/transaction/meta_transaction.hpp"
 
 namespace duckdb {
 
@@ -103,7 +103,7 @@ shared_ptr<PreparedStatementData> Planner::PrepareSQLStatement(unique_ptr<SQLSta
 	prepared_data->types = types;
 	prepared_data->value_map = move(value_map);
 	prepared_data->properties = properties;
-	prepared_data->catalog_version = Transaction::GetTransaction(context).catalog_version;
+	prepared_data->catalog_version = MetaTransaction::Get(context).catalog_version;
 	return prepared_data;
 }
 
@@ -132,6 +132,7 @@ void Planner::CreatePlan(unique_ptr<SQLStatement> statement) {
 	case StatementType::PREPARE_STATEMENT:
 	case StatementType::EXECUTE_STATEMENT:
 	case StatementType::LOGICAL_PLAN_STATEMENT:
+	case StatementType::ATTACH_STATEMENT:
 		CreatePlan(*statement);
 		break;
 	default:

package/src/duckdb/src/planner/pragma_handler.cpp

@@ -62,7 +62,7 @@ void PragmaHandler::HandlePragmaStatements(ClientContextLock &lock, vector<uniqu
 string PragmaHandler::HandlePragma(SQLStatement *statement) { // PragmaInfo &info
 	auto info = *((PragmaStatement &)*statement).info;
 	auto entry =
-	    Catalog::GetCatalog(context).GetEntry<PragmaFunctionCatalogEntry>(context, DEFAULT_SCHEMA, info.name, false);
+	    Catalog::GetEntry<PragmaFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, info.name, false);
 	string error;
 
 	FunctionBinder function_binder(context);

package/src/duckdb/src/storage/buffer_manager.cpp

@@ -6,6 +6,7 @@
 #include "duckdb/parallel/concurrentqueue.hpp"
 #include "duckdb/storage/in_memory_block_manager.hpp"
 #include "duckdb/storage/storage_manager.hpp"
+#include "duckdb/main/attached_database.hpp"
 
 namespace duckdb {
 
@@ -1017,6 +1018,10 @@ Allocator &BufferAllocator::Get(DatabaseInstance &db) {
 	return BufferManager::GetBufferManager(db).GetBufferAllocator();
 }
 
+Allocator &BufferAllocator::Get(AttachedDatabase &db) {
+	return BufferAllocator::Get(db.GetDatabase());
+}
+
 Allocator &BufferManager::GetBufferAllocator() {
 	return buffer_allocator;
 }

package/src/duckdb/src/storage/checkpoint_manager.cpp

@@ -30,11 +30,16 @@
 #include "duckdb/storage/meta_block_reader.hpp"
 #include "duckdb/storage/table/column_checkpoint_state.hpp"
 #include "duckdb/transaction/transaction_manager.hpp"
+#include "duckdb/main/attached_database.hpp"
 
 namespace duckdb {
 
 void ReorderTableEntries(vector<TableCatalogEntry *> &tables);
 
+SingleFileCheckpointWriter::SingleFileCheckpointWriter(AttachedDatabase &db, BlockManager &block_manager)
+    : CheckpointWriter(db), partial_block_manager(block_manager) {
+}
+
 BlockManager &SingleFileCheckpointWriter::GetBlockManager() {
 	auto &storage_manager = (SingleFileStorageManager &)db.GetStorageManager();
 	return *storage_manager.block_manager;
@@ -49,7 +54,7 @@ unique_ptr<TableDataWriter> SingleFileCheckpointWriter::GetTableDataWriter(Table
 }
 
 void SingleFileCheckpointWriter::CreateCheckpoint() {
-	auto &config = DBConfig::GetConfig(db);
+	auto &config = DBConfig::Get(db);
 	auto &storage_manager = (SingleFileStorageManager &)db.GetStorageManager();
 	if (storage_manager.InMemory()) {
 		return;
@@ -68,7 +73,6 @@ void SingleFileCheckpointWriter::CreateCheckpoint() {
 
 	vector<SchemaCatalogEntry *> schemas;
 	// we scan the set of committed schemas
-	auto &catalog = Catalog::GetCatalog(db);
 	catalog.schemas->Scan([&](CatalogEntry *entry) { schemas.push_back((SchemaCatalogEntry *)entry); });
 	// write the actual data into the database
 	// write the amount of schemas
@@ -119,7 +123,7 @@ void SingleFileCheckpointReader::LoadFromStorage() {
 		return;
 	}
 
-	Connection con(storage.db);
+	Connection con(storage.GetDatabase());
 	con.BeginTransaction();
 	// create the MetaBlockReader to read from the storage
 	MetaBlockReader reader(block_manager, meta_block);
@@ -243,8 +247,6 @@ void CheckpointWriter::WriteSchema(SchemaCatalogEntry &schema) {
 }
 
 void CheckpointReader::ReadSchema(ClientContext &context, MetaBlockReader &reader) {
-	auto &catalog = Catalog::GetCatalog(context);
-
 	// read the schema and create it in the catalog
 	auto info = SchemaCatalogEntry::Deserialize(reader);
 	// we set create conflict to ignore to ignore the failure of recreating the main schema
@@ -302,8 +304,6 @@ void CheckpointWriter::WriteView(ViewCatalogEntry &view) {
 
 void CheckpointReader::ReadView(ClientContext &context, MetaBlockReader &reader) {
 	auto info = ViewCatalogEntry::Deserialize(reader, context);
-
-	auto &catalog = Catalog::GetCatalog(context);
 	catalog.CreateView(context, info.get());
 }
 
@@ -316,8 +316,6 @@ void CheckpointWriter::WriteSequence(SequenceCatalogEntry &seq) {
 
 void CheckpointReader::ReadSequence(ClientContext &context, MetaBlockReader &reader) {
 	auto info = SequenceCatalogEntry::Deserialize(reader);
-
-	auto &catalog = Catalog::GetCatalog(context);
 	catalog.CreateSequence(context, info.get());
 }
 
@@ -341,7 +339,6 @@ void CheckpointReader::ReadIndex(ClientContext &context, MetaBlockReader &reader
 	auto info = IndexCatalogEntry::Deserialize(reader, context);
 
 	// Create index in the catalog
-	auto &catalog = Catalog::GetCatalog(context);
 	auto schema_catalog = catalog.GetSchema(context, info->schema);
 	auto table_catalog =
 	    (TableCatalogEntry *)catalog.GetEntry(context, CatalogType::TABLE_ENTRY, info->schema, info->table->table_name);
@@ -384,7 +381,7 @@ void CheckpointReader::ReadIndex(ClientContext &context, MetaBlockReader &reader
 	case IndexType::ART: {
 		auto art =
 		    make_unique<ART>(info->column_ids, TableIOManager::Get(*table_catalog->storage), move(unbound_expressions),
-		                     info->constraint_type, *context.db, root_block_id, root_offset);
+		                     info->constraint_type, table_catalog->storage->db, root_block_id, root_offset);
 		index_catalog->index = art.get();
 		table_catalog->storage->info->indexes.AddIndex(move(art));
 		break;
@@ -403,8 +400,6 @@ void CheckpointWriter::WriteType(TypeCatalogEntry &table) {
 
 void CheckpointReader::ReadType(ClientContext &context, MetaBlockReader &reader) {
 	auto info = TypeCatalogEntry::Deserialize(reader);
-
-	auto &catalog = Catalog::GetCatalog(context);
 	catalog.CreateType(context, info.get());
 }
 
@@ -417,7 +412,6 @@ void CheckpointWriter::WriteMacro(ScalarMacroCatalogEntry &macro) {
 
 void CheckpointReader::ReadMacro(ClientContext &context, MetaBlockReader &reader) {
 	auto info = ScalarMacroCatalogEntry::Deserialize(reader, context);
-	auto &catalog = Catalog::GetCatalog(context);
 	catalog.CreateFunction(context, info.get());
 }
 
@@ -427,7 +421,6 @@ void CheckpointWriter::WriteTableMacro(TableMacroCatalogEntry &macro) {
 
 void CheckpointReader::ReadTableMacro(ClientContext &context, MetaBlockReader &reader) {
 	auto info = TableMacroCatalogEntry::Deserialize(reader, context);
-	auto &catalog = Catalog::GetCatalog(context);
 	catalog.CreateFunction(context, info.get());
 }
 
@@ -448,13 +441,13 @@ void CheckpointReader::ReadTable(ClientContext &context, MetaBlockReader &reader
 	auto info = TableCatalogEntry::Deserialize(reader, context);
 	// bind the info
 	auto binder = Binder::CreateBinder(context);
-	auto bound_info = binder->BindCreateTableInfo(move(info));
+	auto schema = catalog.GetSchema(context, info->schema);
+	auto bound_info = binder->BindCreateTableInfo(move(info), schema);
 
 	// now read the actual table data and place it into the create table info
 	ReadTableData(context, reader, *bound_info);
 
 	// finally create the table in the catalog
-	auto &catalog = Catalog::GetCatalog(context);
 	catalog.CreateTable(context, bound_info.get());
 }