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

package/src/duckdb/src/include/duckdb/transaction/transaction_context.hpp

@@ -10,10 +10,12 @@
 
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/assert.hpp"
+#include "duckdb/common/exception.hpp"
 
 namespace duckdb {
 
 class ClientContext;
+class MetaTransaction;
 class Transaction;
 class TransactionManager;
 
@@ -21,13 +23,13 @@ class TransactionManager;
 //! current transaction
 class TransactionContext {
 public:
-	TransactionContext(TransactionManager &transaction_manager, ClientContext &context)
-	    : transaction_manager(transaction_manager), context(context), auto_commit(true), current_transaction(nullptr) {
-	}
+	TransactionContext(ClientContext &context);
 	~TransactionContext();
 
-	Transaction &ActiveTransaction() {
-		D_ASSERT(current_transaction);
+	MetaTransaction &ActiveTransaction() {
+		if (!current_transaction) {
+			throw InternalException("TransactionContext::ActiveTransaction called without active transaction");
+		}
 		return *current_transaction;
 	}
 
@@ -35,7 +37,6 @@ public:
 		return !!current_transaction;
 	}
 
-	void RecordQuery(string query);
 	void BeginTransaction();
 	void Commit();
 	void Rollback();
@@ -46,12 +47,15 @@ public:
 		return auto_commit;
 	}
 
+	idx_t GetActiveQuery();
+	void ResetActiveQuery();
+	void SetActiveQuery(transaction_t query_number);
+
 private:
-	TransactionManager &transaction_manager;
 	ClientContext &context;
 	bool auto_commit;
 
-	Transaction *current_transaction;
+	unique_ptr<MetaTransaction> current_transaction;
 
 	TransactionContext(const TransactionContext &) = delete;
 };

package/src/duckdb/src/include/duckdb/transaction/transaction_manager.hpp

@@ -17,6 +17,7 @@
 
 namespace duckdb {
 
+class AttachedDatabase;
 class ClientContext;
 class Catalog;
 struct ClientLockWrapper;
@@ -29,7 +30,7 @@ class TransactionManager {
 	friend struct CheckpointLock;
 
 public:
-	explicit TransactionManager(DatabaseInstance &db);
+	explicit TransactionManager(AttachedDatabase &db);
 	~TransactionManager();
 
 	//! Start a new transaction
@@ -39,9 +40,6 @@ public:
 	//! Rollback the given transaction
 	void RollbackTransaction(Transaction *transaction);
 
-	transaction_t GetQueryNumber() {
-		return current_query_number++;
-	}
 	transaction_t LowestActiveId() {
 		return lowest_active_id;
 	}
@@ -51,8 +49,7 @@ public:
 
 	void Checkpoint(ClientContext &context, bool force = false);
 
-	static TransactionManager &Get(ClientContext &context);
-	static TransactionManager &Get(DatabaseInstance &db);
+	static TransactionManager &Get(AttachedDatabase &db);
 
 	void SetBaseCommitId(transaction_t base) {
 		D_ASSERT(base >= TRANSACTION_ID_START);
@@ -65,10 +62,8 @@ private:
 	void RemoveTransaction(Transaction *transaction) noexcept;
 	void LockClients(vector<ClientLockWrapper> &client_locks, ClientContext &context);
 
-	//! The database instance
-	DatabaseInstance &db;
-	//! The current query number
-	atomic<transaction_t> current_query_number;
+	//! The attached database
+	AttachedDatabase &db;
 	//! The current start timestamp used by transactions
 	transaction_t current_start_timestamp;
 	//! The current transaction ID used by transactions

package/src/duckdb/src/include/duckdb/transaction/undo_buffer.hpp

@@ -28,7 +28,7 @@ public:
 	};
 
 public:
-	UndoBuffer(const shared_ptr<ClientContext> &context);
+	UndoBuffer(ClientContext &context);
 
 	//! Reserve space for an entry of the specified type and length in the undo
 	//! buffer

package/src/duckdb/src/main/attached_database.cpp

@@ -0,0 +1,97 @@
+#include "duckdb/main/attached_database.hpp"
+#include "duckdb/storage/storage_manager.hpp"
+#include "duckdb/transaction/transaction_manager.hpp"
+#include "duckdb/common/file_system.hpp"
+
+namespace duckdb {
+
+AttachedDatabase::AttachedDatabase(DatabaseInstance &db, AttachedDatabaseType type)
+    : CatalogEntry(CatalogType::DATABASE_ENTRY, nullptr,
+                   type == AttachedDatabaseType::SYSTEM_DATABASE ? SYSTEM_CATALOG : TEMP_CATALOG),
+      db(db), type(type) {
+	D_ASSERT(type == AttachedDatabaseType::TEMP_DATABASE || type == AttachedDatabaseType::SYSTEM_DATABASE);
+	if (type == AttachedDatabaseType::TEMP_DATABASE) {
+		storage = make_unique<SingleFileStorageManager>(*this, ":memory:", false);
+	}
+	catalog = make_unique<Catalog>(*this);
+	transaction_manager = make_unique<TransactionManager>(*this);
+	internal = true;
+}
+
+AttachedDatabase::AttachedDatabase(DatabaseInstance &db, Catalog &catalog_p, string name_p, string file_path_p,
+                                   AccessMode access_mode)
+    : CatalogEntry(CatalogType::DATABASE_ENTRY, &catalog_p, move(name_p)), db(db),
+      type(access_mode == AccessMode::READ_ONLY ? AttachedDatabaseType::READ_ONLY_DATABASE
+                                                : AttachedDatabaseType::READ_WRITE_DATABASE) {
+	storage = make_unique<SingleFileStorageManager>(*this, move(file_path_p), access_mode == AccessMode::READ_ONLY);
+	catalog = make_unique<Catalog>(*this);
+	transaction_manager = make_unique<TransactionManager>(*this);
+	internal = true;
+}
+
+AttachedDatabase::~AttachedDatabase() {
+	if (Exception::UncaughtException()) {
+		return;
+	}
+	if (IsSystem()) {
+		return;
+	}
+
+	// shutting down: attempt to checkpoint the database
+	// but only if we are not cleaning up as part of an exception unwind
+	try {
+		if (!storage->InMemory()) {
+			auto &config = DBConfig::GetConfig(db);
+			if (!config.options.checkpoint_on_shutdown) {
+				return;
+			}
+			storage->CreateCheckpoint(true);
+		}
+	} catch (...) {
+	}
+}
+
+bool AttachedDatabase::IsSystem() const {
+	D_ASSERT(!storage || type != AttachedDatabaseType::SYSTEM_DATABASE);
+	return type == AttachedDatabaseType::SYSTEM_DATABASE;
+}
+
+bool AttachedDatabase::IsTemporary() const {
+	return type == AttachedDatabaseType::TEMP_DATABASE;
+}
+bool AttachedDatabase::IsReadOnly() const {
+	return type == AttachedDatabaseType::READ_ONLY_DATABASE;
+}
+
+string AttachedDatabase::ExtractDatabaseName(const string &dbpath) {
+	if (dbpath.empty() || dbpath == ":memory:") {
+		return "memory";
+	}
+	return FileSystem::ExtractBaseName(dbpath);
+}
+
+void AttachedDatabase::Initialize() {
+	if (IsSystem()) {
+		catalog->Initialize(true);
+	} else {
+		catalog->Initialize(false);
+		storage->Initialize();
+	}
+}
+
+StorageManager &AttachedDatabase::GetStorageManager() {
+	if (IsSystem()) {
+		throw InternalException("Internal system catalog does not have storage");
+	}
+	return *storage;
+}
+
+Catalog &AttachedDatabase::GetCatalog() {
+	return *catalog;
+}
+
+TransactionManager &AttachedDatabase::GetTransactionManager() {
+	return *transaction_manager;
+}
+
+} // namespace duckdb

package/src/duckdb/src/main/capi/table_function-c.cpp

@@ -274,7 +274,7 @@ duckdb_state duckdb_register_table_function(duckdb_connection connection, duckdb
 		return DuckDBError;
 	}
 	con->context->RunFunctionInTransaction([&]() {
-		auto &catalog = duckdb::Catalog::GetCatalog(*con->context);
+		auto &catalog = duckdb::Catalog::GetSystemCatalog(*con->context);
 		duckdb::CreateTableFunctionInfo tf_info(*tf);
 
 		// create the function in the catalog

package/src/duckdb/src/main/client_context.cpp

@@ -43,7 +43,10 @@
 #include "duckdb/common/preserved_error.hpp"
 #include "duckdb/common/progress_bar/progress_bar.hpp"
 #include "duckdb/main/error_manager.hpp"
+#include "duckdb/main/database_manager.hpp"
+#include "duckdb/transaction/meta_transaction.hpp"
 #include "duckdb/common/http_stats.hpp"
+#include "duckdb/main/attached_database.hpp"
 
 namespace duckdb {
 
@@ -61,8 +64,7 @@ struct ActiveQueryContext {
 };
 
 ClientContext::ClientContext(shared_ptr<DatabaseInstance> database)
-    : db(move(database)), transaction(db->GetTransactionManager(), *this), interrupted(false),
-      client_data(make_unique<ClientData>(*this)) {
+    : db(move(database)), interrupted(false), client_data(make_unique<ClientData>(*this)), transaction(*this) {
 }
 
 ClientContext::~ClientContext() {
@@ -81,7 +83,7 @@ unique_ptr<ClientContextLock> ClientContext::LockContext() {
 void ClientContext::Destroy() {
 	auto lock = LockContext();
 	if (transaction.HasActiveTransaction()) {
-		ActiveTransaction().active_query = MAXIMUM_QUERY_ID;
+		transaction.ResetActiveQuery();
 		if (!transaction.IsAutoCommit()) {
 			transaction.Rollback();
 		}
@@ -148,7 +150,7 @@ void ClientContext::BeginQueryInternal(ClientContextLock &lock, const string &qu
 	LogQueryInternal(lock, query);
 	active_query->query = query;
 	query_progress = -1;
-	ActiveTransaction().active_query = db->GetTransactionManager().GetQueryNumber();
+	transaction.SetActiveQuery(db->GetDatabaseManager().GetNewQueryNumber());
 }
 
 PreservedError ClientContext::EndQueryInternal(ClientContextLock &lock, bool success, bool invalidate_transaction) {
@@ -169,7 +171,7 @@ PreservedError ClientContext::EndQueryInternal(ClientContextLock &lock, bool suc
 		if (transaction.HasActiveTransaction()) {
 			// Move the query profiler into the history
 			auto &prev_profilers = client_data->query_profiler_history->GetPrevProfilers();
-			prev_profilers.emplace_back(transaction.ActiveTransaction().active_query, move(client_data->profiler));
+			prev_profilers.emplace_back(transaction.GetActiveQuery(), move(client_data->profiler));
 			// Reinitialize the query profiler
 			client_data->profiler = make_shared<QueryProfiler>(*this);
 			// Propagate settings of the saved query into the new profiler.
@@ -178,7 +180,7 @@ PreservedError ClientContext::EndQueryInternal(ClientContextLock &lock, bool suc
 				prev_profilers.pop_front();
 			}
 
-			ActiveTransaction().active_query = MAXIMUM_QUERY_ID;
+			transaction.ResetActiveQuery();
 			if (transaction.IsAutoCommit()) {
 				if (success) {
 					transaction.Commit();
@@ -234,10 +236,6 @@ FileOpener *FileOpener::Get(ClientContext &context) {
 	return ClientData::Get(context).file_opener.get();
 }
 
-SchemaCatalogEntry *SchemaCatalogEntry::GetTemporaryObjects(ClientContext &context) {
-	return context.client_data->temporary_objects.get();
-}
-
 const string &ClientContext::GetCurrentQuery() {
 	D_ASSERT(active_query);
 	return active_query->query;
@@ -333,7 +331,7 @@ shared_ptr<PreparedStatementData> ClientContext::CreatePreparedStatement(ClientC
 	result->names = planner.names;
 	result->types = planner.types;
 	result->value_map = move(planner.value_map);
-	result->catalog_version = Transaction::GetTransaction(*this).catalog_version;
+	result->catalog_version = MetaTransaction::Get(*this).catalog_version;
 
 	if (!planner.properties.bound_all_parameters) {
 		return result;
@@ -378,10 +376,19 @@ unique_ptr<PendingQueryResult> ClientContext::PendingPreparedStatement(ClientCon
 	if (ValidChecker::IsInvalidated(ActiveTransaction()) && statement.properties.requires_valid_transaction) {
 		throw Exception(ErrorManager::FormatException(*this, ErrorType::INVALIDATED_TRANSACTION));
 	}
-	auto &db_config = DBConfig::GetConfig(*this);
-	if (db_config.options.access_mode == AccessMode::READ_ONLY && !statement.properties.read_only) {
-		throw Exception(StringUtil::Format("Cannot execute statement of type \"%s\" in read-only mode!",
-		                                   StatementTypeToString(statement.statement_type)));
+	auto &transaction = MetaTransaction::Get(*this);
+	auto &manager = DatabaseManager::Get(*this);
+	for (auto &modified_database : statement.properties.modified_databases) {
+		auto entry = manager.GetDatabase(*this, modified_database);
+		if (!entry) {
+			throw InternalException("Database \"%s\" not found", modified_database);
+		}
+		if (entry->IsReadOnly()) {
+			throw Exception(StringUtil::Format(
+			    "Cannot execute statement of type \"%s\" on database \"%s\" which is attached in read-only mode!",
+			    StatementTypeToString(statement.statement_type), modified_database));
+		}
+		transaction.ModifyDatabase(entry);
 	}
 
 	// bind the bound values before execution
@@ -902,9 +909,8 @@ void ClientContext::DisableProfiling() {
 
 void ClientContext::RegisterFunction(CreateFunctionInfo *info) {
 	RunFunctionInTransaction([&]() {
-		auto &catalog = Catalog::GetCatalog(*this);
-		auto existing_function = (ScalarFunctionCatalogEntry *)catalog.GetEntry(
-		    *this, CatalogType::SCALAR_FUNCTION_ENTRY, info->schema, info->name, true);
+		auto existing_function =
+		    Catalog::GetEntry<ScalarFunctionCatalogEntry>(*this, INVALID_CATALOG, info->schema, info->name, true);
 		if (existing_function) {
 			auto new_info = (CreateScalarFunctionInfo *)info;
 			if (new_info->functions.MergeFunctionSet(existing_function->functions)) {
@@ -913,6 +919,7 @@ void ClientContext::RegisterFunction(CreateFunctionInfo *info) {
 			}
 		}
 		// create function
+		auto &catalog = Catalog::GetSystemCatalog(*this);
 		catalog.CreateFunction(*this, info);
 	});
 }
@@ -962,8 +969,7 @@ unique_ptr<TableDescription> ClientContext::TableInfo(const string &schema_name,
 	unique_ptr<TableDescription> result;
 	RunFunctionInTransaction([&]() {
 		// obtain the table info
-		auto &catalog = Catalog::GetCatalog(*this);
-		auto table = catalog.GetEntry<TableCatalogEntry>(*this, schema_name, table_name, true);
+		auto table = Catalog::GetEntry<TableCatalogEntry>(*this, INVALID_CATALOG, schema_name, table_name, true);
 		if (!table) {
 			return;
 		}
@@ -980,8 +986,8 @@ unique_ptr<TableDescription> ClientContext::TableInfo(const string &schema_name,
 
 void ClientContext::Append(TableDescription &description, ColumnDataCollection &collection) {
 	RunFunctionInTransaction([&]() {
-		auto &catalog = Catalog::GetCatalog(*this);
-		auto table_entry = catalog.GetEntry<TableCatalogEntry>(*this, description.schema, description.table);
+		auto table_entry =
+		    Catalog::GetEntry<TableCatalogEntry>(*this, INVALID_CATALOG, description.schema, description.table);
 		// verify that the table columns and types match up
 		if (description.columns.size() != table_entry->columns.PhysicalColumnCount()) {
 			throw Exception("Failed to append: table entry has different number of columns!");

package/src/duckdb/src/main/client_data.cpp

@@ -4,19 +4,22 @@
 #include "duckdb/main/query_profiler.hpp"
 #include "duckdb/common/http_stats.hpp"
 #include "duckdb/common/random_engine.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_search_path.hpp"
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/common/serializer/buffered_file_writer.hpp"
+#include "duckdb/main/attached_database.hpp"
+#include "duckdb/main/database.hpp"
 
 namespace duckdb {
 
 ClientData::ClientData(ClientContext &context) : catalog_search_path(make_unique<CatalogSearchPath>(context)) {
+	auto &db = DatabaseInstance::GetDatabase(context);
 	profiler = make_shared<QueryProfiler>(context);
 	query_profiler_history = make_unique<QueryProfilerHistory>();
-	temporary_objects = make_shared<SchemaCatalogEntry>(&Catalog::GetCatalog(context), TEMP_SCHEMA, true);
+	temporary_objects = make_shared<AttachedDatabase>(db, AttachedDatabaseType::TEMP_DATABASE);
 	random_engine = make_unique<RandomEngine>();
 	file_opener = make_unique<ClientContextFileOpener>(context);
+	temporary_objects->Initialize();
 }
 ClientData::~ClientData() {
 }

package/src/duckdb/src/main/config.cpp

@@ -71,6 +71,7 @@ static ConfigurationOption internal_options[] = {DUCKDB_GLOBAL(AccessModeSetting
                                                  DUCKDB_GLOBAL(ForceBitpackingModeSetting),
                                                  DUCKDB_LOCAL(HomeDirectorySetting),
                                                  DUCKDB_LOCAL(LogQueryPathSetting),
+                                                 DUCKDB_GLOBAL(ImmediateTransactionModeSetting),
                                                  DUCKDB_LOCAL(MaximumExpressionDepthSetting),
                                                  DUCKDB_GLOBAL(MaximumMemorySetting),
                                                  DUCKDB_GLOBAL_ALIAS("memory_limit", MaximumMemorySetting),

package/src/duckdb/src/main/database.cpp

@@ -1,6 +1,7 @@
 #include "duckdb/main/database.hpp"
 
 #include "duckdb/catalog/catalog.hpp"
+#include "duckdb/main/database_manager.hpp"
 #include "duckdb/common/virtual_file_system.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/parallel/task_scheduler.hpp"
@@ -13,6 +14,7 @@
 #include "duckdb/main/replacement_opens.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
 #include "duckdb/main/error_manager.hpp"
+#include "duckdb/main/attached_database.hpp"
 
 #ifndef DUCKDB_NO_THREADS
 #include "duckdb/common/thread.hpp"
@@ -50,38 +52,32 @@ DatabaseInstance::DatabaseInstance() {
 }
 
 DatabaseInstance::~DatabaseInstance() {
-	if (Exception::UncaughtException()) {
-		return;
-	}
-
-	// shutting down: attempt to checkpoint the database
-	// but only if we are not cleaning up as part of an exception unwind
-	try {
-		auto &storage = StorageManager::GetStorageManager(*this);
-		if (!storage.InMemory()) {
-			auto &config = storage.db.config;
-			if (!config.options.checkpoint_on_shutdown) {
-				return;
-			}
-			storage.CreateCheckpoint(true);
-		}
-	} catch (...) {
-	}
 }
 
 BufferManager &BufferManager::GetBufferManager(DatabaseInstance &db) {
-	return *db.GetStorageManager().buffer_manager;
+	return db.GetBufferManager();
+}
+
+BufferManager &BufferManager::GetBufferManager(AttachedDatabase &db) {
+	return BufferManager::GetBufferManager(db.GetDatabase());
 }
 
 DatabaseInstance &DatabaseInstance::GetDatabase(ClientContext &context) {
 	return *context.db;
 }
 
-StorageManager &StorageManager::GetStorageManager(DatabaseInstance &db) {
-	return db.GetStorageManager();
+DatabaseManager &DatabaseInstance::GetDatabaseManager() {
+	if (!db_manager) {
+		throw InternalException("Missing DB manager");
+	}
+	return *db_manager;
 }
 
-Catalog &Catalog::GetCatalog(DatabaseInstance &db) {
+Catalog &Catalog::GetSystemCatalog(DatabaseInstance &db) {
+	return db.GetDatabaseManager().GetSystemCatalog();
+}
+
+Catalog &Catalog::GetCatalog(AttachedDatabase &db) {
 	return db.GetCatalog();
 }
 
@@ -89,6 +85,10 @@ FileSystem &FileSystem::GetFileSystem(DatabaseInstance &db) {
 	return db.GetFileSystem();
 }
 
+FileSystem &FileSystem::Get(AttachedDatabase &db) {
+	return FileSystem::GetFileSystem(db.GetDatabase());
+}
+
 DBConfig &DBConfig::GetConfig(DatabaseInstance &db) {
 	return db.config;
 }
@@ -97,6 +97,10 @@ ClientConfig &ClientConfig::GetConfig(ClientContext &context) {
 	return context.config;
 }
 
+DBConfig &DBConfig::Get(AttachedDatabase &db) {
+	return DBConfig::GetConfig(db.GetDatabase());
+}
+
 const DBConfig &DBConfig::GetConfig(const DatabaseInstance &db) {
 	return db.config;
 }
@@ -105,11 +109,7 @@ const ClientConfig &ClientConfig::GetConfig(const ClientContext &context) {
 	return context.config;
 }
 
-TransactionManager &TransactionManager::Get(ClientContext &context) {
-	return TransactionManager::Get(DatabaseInstance::GetDatabase(context));
-}
-
-TransactionManager &TransactionManager::Get(DatabaseInstance &db) {
+TransactionManager &TransactionManager::Get(AttachedDatabase &db) {
 	return db.GetTransactionManager();
 }
 
@@ -159,19 +159,29 @@ void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_conf
 		config.options.temporary_directory = string();
 	}
 
-	// TODO: Support an extension here, to generate different storage managers
-	// depending on the DB path structure/prefix.
-	const string dbPath = config.options.database_path;
-	storage = make_unique<SingleFileStorageManager>(*this, dbPath, config.options.access_mode == AccessMode::READ_ONLY);
-
-	catalog = make_unique<Catalog>(*this);
-	transaction_manager = make_unique<TransactionManager>(*this);
+	auto &config = DBConfig::GetConfig(*this);
+	db_manager = make_unique<DatabaseManager>(*this);
+	buffer_manager =
+	    make_unique<BufferManager>(*this, config.options.temporary_directory, config.options.maximum_memory);
 	scheduler = make_unique<TaskScheduler>(*this);
 	object_cache = make_unique<ObjectCache>();
 	connection_manager = make_unique<ConnectionManager>();
 
+	auto database_name = AttachedDatabase::ExtractDatabaseName(config.options.database_path);
+	auto attached_database = make_unique<AttachedDatabase>(*this, Catalog::GetSystemCatalog(*this), database_name,
+	                                                       config.options.database_path, config.options.access_mode);
+	auto initial_database = attached_database.get();
+	{
+		Connection con(*this);
+		con.BeginTransaction();
+		db_manager->AddDatabase(*con.context, move(attached_database));
+		con.Commit();
+	}
+
+	// initialize the system catalog
+	db_manager->InitializeSystemCatalog();
 	// initialize the database
-	storage->Initialize();
+	initial_database->Initialize();
 
 	// only increase thread count after storage init because we get races on catalog otherwise
 	scheduler->SetThreads(config.options.maximum_threads);
@@ -200,16 +210,16 @@ DuckDB::DuckDB(DatabaseInstance &instance_p) : instance(instance_p.shared_from_t
 DuckDB::~DuckDB() {
 }
 
-StorageManager &DatabaseInstance::GetStorageManager() {
-	return *storage;
+BufferManager &DatabaseInstance::GetBufferManager() {
+	return *buffer_manager;
 }
 
-Catalog &DatabaseInstance::GetCatalog() {
-	return *catalog;
+DatabaseManager &DatabaseManager::Get(DatabaseInstance &db) {
+	return db.GetDatabaseManager();
 }
 
-TransactionManager &DatabaseInstance::GetTransactionManager() {
-	return *transaction_manager;
+DatabaseManager &DatabaseManager::Get(ClientContext &db) {
+	return DatabaseManager::Get(*db.db);
 }
 
 TaskScheduler &DatabaseInstance::GetScheduler() {
@@ -240,6 +250,10 @@ Allocator &Allocator::Get(DatabaseInstance &db) {
 	return *db.config.allocator;
 }
 
+Allocator &Allocator::Get(AttachedDatabase &db) {
+	return Allocator::Get(db.GetDatabase());
+}
+
 void DatabaseInstance::Configure(DBConfig &new_config) {
 	config.options = new_config.options;
 	if (config.options.access_mode == AccessMode::UNDEFINED) {

package/src/duckdb/src/main/database_manager.cpp

@@ -0,0 +1,95 @@
+#include "duckdb/main/database_manager.hpp"
+#include "duckdb/catalog/catalog.hpp"
+#include "duckdb/main/attached_database.hpp"
+#include "duckdb/storage/storage_manager.hpp"
+#include "duckdb/main/client_data.hpp"
+#include "duckdb/catalog/catalog_search_path.hpp"
+
+namespace duckdb {
+
+DatabaseManager::DatabaseManager(DatabaseInstance &db) : catalog_version(0), current_query_number(1) {
+	system = make_unique<AttachedDatabase>(db);
+	databases = make_unique<CatalogSet>(system->GetCatalog());
+}
+
+DatabaseManager::~DatabaseManager() {
+}
+
+DatabaseManager &DatabaseManager::Get(AttachedDatabase &db) {
+	return DatabaseManager::Get(db.GetDatabase());
+}
+
+void DatabaseManager::InitializeSystemCatalog() {
+	system->Initialize();
+}
+
+AttachedDatabase *DatabaseManager::GetDatabase(ClientContext &context, const string &name) {
+	if (StringUtil::Lower(name) == TEMP_CATALOG) {
+		return context.client_data->temporary_objects.get();
+	}
+	return (AttachedDatabase *)databases->GetEntry(context, name);
+}
+
+void DatabaseManager::AddDatabase(ClientContext &context, unique_ptr<AttachedDatabase> db_instance) {
+	auto name = db_instance->GetName();
+	DependencyList dependencies;
+	if (default_database.empty()) {
+		default_database = name;
+	}
+	if (!databases->CreateEntry(context, name, move(db_instance), dependencies)) {
+		throw BinderException("Failed to attach database: database with name \"%s\" already exists", name);
+	}
+}
+
+void DatabaseManager::DetachDatabase(ClientContext &context, const string &name, bool if_exists) {
+	if (!databases->DropEntry(context, name, false, true)) {
+		if (!if_exists) {
+			throw BinderException("Failed to detach database with name \"%s\": database not found", name);
+		}
+	}
+}
+
+AttachedDatabase *DatabaseManager::GetDatabaseFromPath(ClientContext &context, const string &path) {
+	auto databases = GetDatabases(context);
+	for (auto db : databases) {
+		if (db->IsSystem()) {
+			continue;
+		}
+		auto &storage = db->GetStorageManager();
+		if (storage.InMemory()) {
+			continue;
+		}
+		if (StringUtil::CIEquals(path, storage.GetDBPath())) {
+			return db;
+		}
+	}
+	return nullptr;
+}
+
+const string &DatabaseManager::GetDefaultDatabase(ClientContext &context) {
+	auto &config = ClientData::Get(context);
+	auto &default_entry = config.catalog_search_path->GetDefault();
+	if (IsInvalidCatalog(default_entry.catalog)) {
+		auto &result = DatabaseManager::Get(context).default_database;
+		if (result.empty()) {
+			throw InternalException("Calling DatabaseManager::GetDefaultDatabase with no default database set");
+		}
+		return result;
+	}
+	return default_entry.catalog;
+}
+
+vector<AttachedDatabase *> DatabaseManager::GetDatabases(ClientContext &context) {
+	vector<AttachedDatabase *> result;
+	databases->Scan(context, [&](CatalogEntry *entry) { result.push_back((AttachedDatabase *)entry); });
+	result.push_back(system.get());
+	result.push_back(context.client_data->temporary_objects.get());
+	return result;
+}
+
+Catalog &DatabaseManager::GetSystemCatalog() {
+	D_ASSERT(system);
+	return system->GetCatalog();
+}
+
+} // namespace duckdb

package/src/duckdb/src/main/materialized_query_result.cpp

@@ -7,7 +7,7 @@ namespace duckdb {
 MaterializedQueryResult::MaterializedQueryResult(StatementType statement_type, StatementProperties properties,
                                                  vector<string> names_p, unique_ptr<ColumnDataCollection> collection_p,
                                                  ClientProperties client_properties)
-    : QueryResult(QueryResultType::MATERIALIZED_RESULT, statement_type, properties, collection_p->Types(),
+    : QueryResult(QueryResultType::MATERIALIZED_RESULT, statement_type, move(properties), collection_p->Types(),
                   move(names_p), move(client_properties)),
       collection(move(collection_p)), scan_initialized(false) {
 }