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

package/src/duckdb/src/storage/data_table.cpp

@@ -19,10 +19,20 @@
 #include "duckdb/storage/table/standard_column_data.hpp"
 #include "duckdb/transaction/transaction.hpp"
 #include "duckdb/transaction/transaction_manager.hpp"
+#include "duckdb/main/attached_database.hpp"
 
 namespace duckdb {
 
-DataTable::DataTable(DatabaseInstance &db, shared_ptr<TableIOManager> table_io_manager_p, const string &schema,
+DataTableInfo::DataTableInfo(AttachedDatabase &db, shared_ptr<TableIOManager> table_io_manager_p, string schema,
+                             string table)
+    : db(db), table_io_manager(move(table_io_manager_p)), cardinality(0), schema(move(schema)), table(move(table)) {
+}
+
+bool DataTableInfo::IsTemporary() const {
+	return db.IsTemporary();
+}
+
+DataTable::DataTable(AttachedDatabase &db, shared_ptr<TableIOManager> table_io_manager_p, const string &schema,
                      const string &table, vector<ColumnDefinition> column_definitions_p,
                      unique_ptr<PersistentTableData> data)
     : info(make_shared<DataTableInfo>(db, move(table_io_manager_p), schema, table)),
@@ -53,7 +63,7 @@ DataTable::DataTable(ClientContext &context, DataTable &parent, ColumnDefinition
 	this->row_groups = parent.row_groups->AddColumn(context, new_column, default_value);
 
 	// also add this column to client local storage
-	auto &local_storage = LocalStorage::Get(context);
+	auto &local_storage = LocalStorage::Get(context, db);
 	local_storage.AddColumn(&parent, this, new_column, default_value);
 
 	// this table replaces the previous table, hence the parent is no longer the root DataTable
@@ -98,7 +108,7 @@ DataTable::DataTable(ClientContext &context, DataTable &parent, idx_t removed_co
 	this->row_groups = parent.row_groups->RemoveColumn(removed_column);
 
 	// scan the original table, and fill the new column with the transformed value
-	auto &local_storage = LocalStorage::Get(context);
+	auto &local_storage = LocalStorage::Get(context, db);
 	local_storage.DropColumn(&parent, this, removed_column);
 
 	// this table replaces the previous table, hence the parent is no longer the root DataTable
@@ -118,7 +128,7 @@ DataTable::DataTable(ClientContext &context, DataTable &parent, unique_ptr<Bound
 	VerifyNewConstraint(context, parent, constraint.get());
 
 	// Get the local data ownership from old dt
-	auto &local_storage = LocalStorage::Get(context);
+	auto &local_storage = LocalStorage::Get(context, db);
 	local_storage.MoveStorage(&parent, this);
 	// this table replaces the previous table, hence the parent is no longer the root DataTable
 	parent.is_root = false;
@@ -150,7 +160,7 @@ DataTable::DataTable(ClientContext &context, DataTable &parent, idx_t changed_id
 	this->row_groups = parent.row_groups->AlterType(context, changed_idx, target_type, bound_columns, cast_expr);
 
 	// scan the original table, and fill the new column with the transformed value
-	auto &local_storage = LocalStorage::Get(context);
+	auto &local_storage = LocalStorage::Get(context, db);
 	local_storage.ChangeType(&parent, this, changed_idx, target_type, bound_columns, cast_expr);
 
 	// this table replaces the previous table, hence the parent is no longer the root DataTable
@@ -203,7 +213,7 @@ idx_t DataTable::MaxThreads(ClientContext &context) {
 void DataTable::InitializeParallelScan(ClientContext &context, ParallelTableScanState &state) {
 	row_groups->InitializeParallelScan(state.scan_state);
 
-	auto &local_storage = LocalStorage::Get(context);
+	auto &local_storage = LocalStorage::Get(context, db);
 	local_storage.InitializeParallelScan(this, state.local_state);
 }
 
@@ -212,7 +222,7 @@ bool DataTable::NextParallelScan(ClientContext &context, ParallelTableScanState
 		return true;
 	}
 	scan_state.table_state.batch_index = state.scan_state.batch_index;
-	auto &local_storage = LocalStorage::Get(context);
+	auto &local_storage = LocalStorage::Get(context, db);
 	if (local_storage.NextParallelScan(context, this, state.local_state, scan_state.local_state)) {
 		return true;
 	} else {
@@ -315,8 +325,8 @@ bool DataTable::IsForeignKeyIndex(const vector<PhysicalIndex> &fk_keys, Index &i
 	return true;
 }
 
-static void VerifyForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, ClientContext &context, DataChunk &chunk,
-                                       bool is_append) {
+void DataTable::VerifyForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, ClientContext &context,
+                                           DataChunk &chunk, bool is_append) {
 	const vector<PhysicalIndex> *src_keys_ptr = &bfk.info.fk_keys;
 	const vector<PhysicalIndex> *dst_keys_ptr = &bfk.info.pk_keys;
 	if (!is_append) {
@@ -325,7 +335,7 @@ static void VerifyForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, Cli
 	}
 
 	auto table_entry_ptr =
-	    Catalog::GetCatalog(context).GetEntry<TableCatalogEntry>(context, bfk.info.schema, bfk.info.table);
+	    Catalog::GetEntry<TableCatalogEntry>(context, INVALID_CATALOG, bfk.info.schema, bfk.info.table);
 	if (table_entry_ptr == nullptr) {
 		throw InternalException("Can't find table \"%s\" in foreign key constraint", bfk.info.table);
 	}
@@ -355,7 +365,7 @@ static void VerifyForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, Cli
 
 	data_table->info->indexes.VerifyForeignKey(*dst_keys_ptr, is_append, dst_chunk, err_msgs);
 	// check whether or not the chunk can be inserted or deleted into the referenced table' transaction local storage
-	auto &local_storage = LocalStorage::Get(context);
+	auto &local_storage = LocalStorage::Get(context, db);
 	bool transaction_check = local_storage.Find(data_table);
 	if (transaction_check) {
 		auto &transact_index = local_storage.GetIndexes(data_table);
@@ -394,13 +404,13 @@ static void VerifyForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, Cli
 	}
 }
 
-static void VerifyAppendForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, ClientContext &context,
-                                             DataChunk &chunk) {
+void DataTable::VerifyAppendForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, ClientContext &context,
+                                                 DataChunk &chunk) {
 	VerifyForeignKeyConstraint(bfk, context, chunk, true);
 }
 
-static void VerifyDeleteForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, ClientContext &context,
-                                             DataChunk &chunk) {
+void DataTable::VerifyDeleteForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, ClientContext &context,
+                                                 DataChunk &chunk) {
 	VerifyForeignKeyConstraint(bfk, context, chunk, false);
 }
 
@@ -410,7 +420,7 @@ void DataTable::VerifyNewConstraint(ClientContext &context, DataTable &parent, c
 	}
 
 	parent.row_groups->VerifyNewConstraint(parent, *constraint);
-	auto &local_storage = LocalStorage::Get(context);
+	auto &local_storage = LocalStorage::Get(context, db);
 	local_storage.VerifyNewConstraint(parent, *constraint);
 }
 
@@ -472,7 +482,7 @@ void DataTable::InitializeLocalAppend(LocalAppendState &state, ClientContext &co
 	if (!is_root) {
 		throw TransactionException("Transaction conflict: adding entries to a table that has been altered!");
 	}
-	auto &local_storage = LocalStorage::Get(context);
+	auto &local_storage = LocalStorage::Get(context, db);
 	local_storage.InitializeAppend(state, this);
 }
 
@@ -500,12 +510,12 @@ void DataTable::FinalizeLocalAppend(LocalAppendState &state) {
 }
 
 OptimisticDataWriter *DataTable::CreateOptimisticWriter(ClientContext &context) {
-	auto &local_storage = LocalStorage::Get(context);
+	auto &local_storage = LocalStorage::Get(context, db);
 	return local_storage.CreateOptimisticWriter(this);
 }
 
 void DataTable::LocalMerge(ClientContext &context, RowGroupCollection &collection) {
-	auto &local_storage = LocalStorage::Get(context);
+	auto &local_storage = LocalStorage::Get(context, db);
 	local_storage.LocalMerge(this, collection);
 }
 
@@ -751,8 +761,8 @@ idx_t DataTable::Delete(TableCatalogEntry &table, ClientContext &context, Vector
 		return 0;
 	}
 
-	auto &transaction = Transaction::GetTransaction(context);
-	auto &local_storage = LocalStorage::Get(context);
+	auto &transaction = Transaction::Get(context, db);
+	auto &local_storage = LocalStorage::Get(transaction);
 
 	row_identifiers.Flatten(count);
 	auto ids = FlatVector::GetData<row_t>(row_identifiers);
@@ -887,7 +897,7 @@ void DataTable::Update(TableCatalogEntry &table, ClientContext &context, Vector
 	VerifyUpdateConstraints(context, table, updates, column_ids);
 
 	// now perform the actual update
-	auto &transaction = Transaction::GetTransaction(context);
+	auto &transaction = Transaction::Get(context, db);
 
 	updates.Flatten();
 	row_ids.Flatten(count);
@@ -895,7 +905,7 @@ void DataTable::Update(TableCatalogEntry &table, ClientContext &context, Vector
 	auto first_id = FlatVector::GetValue<row_t>(row_ids, 0);
 	if (first_id >= MAX_ROW_ID) {
 		// update is in transaction-local storage: push update into local storage
-		auto &local_storage = LocalStorage::Get(context);
+		auto &local_storage = LocalStorage::Get(context, db);
 		local_storage.Update(this, row_ids, column_ids, updates);
 		return;
 	}
@@ -921,7 +931,7 @@ void DataTable::UpdateColumn(TableCatalogEntry &table, ClientContext &context, V
 	}
 
 	// now perform the actual update
-	auto &transaction = Transaction::GetTransaction(context);
+	auto &transaction = Transaction::Get(context, db);
 
 	updates.Flatten();
 	row_ids.Flatten(updates.size());

package/src/duckdb/src/storage/local_storage.cpp

@@ -32,7 +32,7 @@ OptimisticDataWriter::~OptimisticDataWriter() {
 
 bool OptimisticDataWriter::PrepareWrite() {
 	// check if we should pre-emptively write the table to disk
-	if (table->info->IsTemporary() || StorageManager::GetStorageManager(table->db).InMemory()) {
+	if (table->info->IsTemporary() || StorageManager::Get(table->info->db).InMemory()) {
 		return false;
 	}
 	// we should! write the second-to-last row group to disk
@@ -362,8 +362,12 @@ LocalStorage &LocalStorage::Get(Transaction &transaction) {
 	return transaction.GetLocalStorage();
 }
 
-LocalStorage &LocalStorage::Get(ClientContext &context) {
-	return Transaction::GetTransaction(context).GetLocalStorage();
+LocalStorage &LocalStorage::Get(ClientContext &context, AttachedDatabase &db) {
+	return Transaction::Get(context, db).GetLocalStorage();
+}
+
+LocalStorage &LocalStorage::Get(ClientContext &context, Catalog &catalog) {
+	return LocalStorage::Get(context, catalog.GetAttached());
 }
 
 void LocalStorage::InitializeScan(DataTable *table, CollectionScanState &state, TableFilterSet *table_filters) {

package/src/duckdb/src/storage/single_file_block_manager.cpp

@@ -106,7 +106,7 @@ T DeserializeHeaderStructure(data_ptr_t ptr) {
 	return T::Deserialize(source);
 }
 
-SingleFileBlockManager::SingleFileBlockManager(DatabaseInstance &db, string path_p, bool read_only, bool create_new,
+SingleFileBlockManager::SingleFileBlockManager(AttachedDatabase &db, string path_p, bool read_only, bool create_new,
                                                bool use_direct_io)
     : BlockManager(BufferManager::GetBufferManager(db)), db(db), path(move(path_p)),
       header_buffer(Allocator::Get(db), FileBufferType::MANAGED_BUFFER,
@@ -129,7 +129,7 @@ SingleFileBlockManager::SingleFileBlockManager(DatabaseInstance &db, string path
 		flags |= FileFlags::FILE_FLAGS_DIRECT_IO;
 	}
 	// open the RDBMS handle
-	auto &fs = FileSystem::GetFileSystem(db);
+	auto &fs = FileSystem::Get(db);
 	handle = fs.OpenFile(path, flags, lock);
 	if (create_new) {
 		// if we create a new file, we fill the metadata of the file
@@ -416,7 +416,7 @@ void SingleFileBlockManager::WriteHeader(DatabaseHeader header) {
 	}
 	header.block_count = max_block;
 
-	auto &config = DBConfig::GetConfig(db);
+	auto &config = DBConfig::Get(db);
 	if (config.options.checkpoint_abort == CheckpointAbort::DEBUG_ABORT_AFTER_FREE_LIST_WRITE) {
 		throw FatalException("Checkpoint aborted after free list write because of PRAGMA checkpoint_abort flag");
 	}

package/src/duckdb/src/storage/storage_manager.cpp

@@ -7,24 +7,33 @@
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/common/file_system.hpp"
 #include "duckdb/main/database.hpp"
-#include "duckdb/main/connection.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/function/function.hpp"
-#include "duckdb/parser/parsed_data/create_schema_info.hpp"
 #include "duckdb/transaction/transaction_manager.hpp"
 #include "duckdb/common/serializer/buffered_file_reader.hpp"
+#include "duckdb/main/attached_database.hpp"
 
 namespace duckdb {
 
-StorageManager::StorageManager(DatabaseInstance &db, string path, bool read_only)
-    : db(db), path(move(path)), read_only(read_only) {
+StorageManager::StorageManager(AttachedDatabase &db, string path_p, bool read_only)
+    : db(db), path(move(path_p)), read_only(read_only) {
+	if (path.empty()) {
+		path = ":memory:";
+	}
 }
 
 StorageManager::~StorageManager() {
 }
 
-StorageManager &StorageManager::GetStorageManager(ClientContext &context) {
-	return StorageManager::GetStorageManager(*context.db);
+StorageManager &StorageManager::Get(AttachedDatabase &db) {
+	return db.GetStorageManager();
+}
+StorageManager &StorageManager::Get(Catalog &catalog) {
+	return StorageManager::Get(catalog.GetAttached());
+}
+
+DatabaseInstance &StorageManager::GetDatabase() {
+	return db.GetDatabase();
 }
 
 BufferManager &BufferManager::GetBufferManager(ClientContext &context) {
@@ -40,12 +49,8 @@ bool ObjectCache::ObjectCacheEnabled(ClientContext &context) {
 }
 
 bool StorageManager::InMemory() {
-	return path.empty() || path == ":memory:";
-}
-
-void StorageManager::CreateBufferManager() {
-	auto &config = DBConfig::GetConfig(db);
-	buffer_manager = make_unique<BufferManager>(db, config.options.temporary_directory, config.options.maximum_memory);
+	D_ASSERT(!path.empty());
+	return path == ":memory:";
 }
 
 void StorageManager::Initialize() {
@@ -53,30 +58,6 @@ void StorageManager::Initialize() {
 	if (in_memory && read_only) {
 		throw CatalogException("Cannot launch in-memory database in read-only mode!");
 	}
-	CreateBufferManager();
-
-	auto &config = DBConfig::GetConfig(db);
-	auto &catalog = Catalog::GetCatalog(db);
-
-	// first initialize the base system catalogs
-	// these are never written to the WAL
-	Connection con(db);
-	con.BeginTransaction();
-
-	// create the default schema
-	CreateSchemaInfo info;
-	info.schema = DEFAULT_SCHEMA;
-	info.internal = true;
-	catalog.CreateSchema(*con.context, &info);
-
-	if (config.options.initialize_default_database) {
-		// initialize default functions
-		BuiltinFunctions builtin(*con.context, catalog);
-		builtin.Initialize();
-	}
-
-	// commit transactions
-	con.Commit();
 
 	// create or load the database from disk, if not in-memory mode
 	LoadDatabase();
@@ -99,20 +80,20 @@ public:
 	}
 };
 
-SingleFileStorageManager::SingleFileStorageManager(DatabaseInstance &db, string path, bool read_only)
+SingleFileStorageManager::SingleFileStorageManager(AttachedDatabase &db, string path, bool read_only)
     : StorageManager(db, move(path), read_only) {
 }
 
 void SingleFileStorageManager::LoadDatabase() {
 	if (InMemory()) {
-		block_manager = make_unique<InMemoryBlockManager>(*buffer_manager);
+		block_manager = make_unique<InMemoryBlockManager>(BufferManager::GetBufferManager(db));
 		table_io_manager = make_unique<SingleFileTableIOManager>(*block_manager);
 		return;
 	}
 
 	string wal_path = path + ".wal";
-	auto &fs = db.GetFileSystem();
-	auto &config = db.config;
+	auto &fs = FileSystem::Get(db);
+	auto &config = DBConfig::Get(db);
 	bool truncate_wal = false;
 	// first check if the database exists
 	if (!fs.FileExists(path)) {
@@ -228,7 +209,8 @@ void SingleFileStorageManager::CreateCheckpoint(bool delete_wal, bool force_chec
 	if (InMemory() || read_only || !wal) {
 		return;
 	}
-	if (wal->GetWALSize() > 0 || db.config.options.force_checkpoint || force_checkpoint) {
+	auto &config = DBConfig::Get(db);
+	if (wal->GetWALSize() > 0 || config.options.force_checkpoint || force_checkpoint) {
 		// we only need to checkpoint if there is anything in the WAL
 		SingleFileCheckpointWriter checkpointer(db, *block_manager);
 		checkpointer.CreateCheckpoint();
@@ -261,9 +243,10 @@ bool SingleFileStorageManager::AutomaticCheckpoint(idx_t estimated_wal_bytes) {
 		return false;
 	}
 
+	auto &config = DBConfig::Get(db);
 	auto initial_size = log->GetWALSize();
 	idx_t expected_wal_size = initial_size + estimated_wal_bytes;
-	return expected_wal_size > db.config.options.checkpoint_wal_size;
+	return expected_wal_size > config.options.checkpoint_wal_size;
 }
 
 shared_ptr<TableIOManager> SingleFileStorageManager::GetTableIOManager(BoundCreateTableInfo *info /*info*/) {

package/src/duckdb/src/storage/table/column_data.cpp

@@ -14,6 +14,7 @@
 
 #include "duckdb/storage/table/struct_column_data.hpp"
 #include "duckdb/storage/table/update_segment.hpp"
+#include "duckdb/main/attached_database.hpp"
 
 namespace duckdb {
 
@@ -38,7 +39,7 @@ ColumnData::~ColumnData() {
 }
 
 DatabaseInstance &ColumnData::GetDatabase() const {
-	return info.db;
+	return info.db.GetDatabase();
 }
 
 DataTableInfo &ColumnData::GetTableInfo() const {

package/src/duckdb/src/storage/table/row_group.cpp

@@ -13,20 +13,21 @@
 #include "duckdb/storage/meta_block_reader.hpp"
 #include "duckdb/transaction/transaction_manager.hpp"
 #include "duckdb/main/database.hpp"
+#include "duckdb/main/attached_database.hpp"
 
 namespace duckdb {
 
 constexpr const idx_t RowGroup::ROW_GROUP_VECTOR_COUNT;
 constexpr const idx_t RowGroup::ROW_GROUP_SIZE;
 
-RowGroup::RowGroup(DatabaseInstance &db, BlockManager &block_manager, DataTableInfo &table_info, idx_t start,
+RowGroup::RowGroup(AttachedDatabase &db, BlockManager &block_manager, DataTableInfo &table_info, idx_t start,
                    idx_t count)
     : SegmentBase(start, count), db(db), block_manager(block_manager), table_info(table_info) {
 
 	Verify();
 }
 
-RowGroup::RowGroup(DatabaseInstance &db, BlockManager &block_manager, DataTableInfo &table_info,
+RowGroup::RowGroup(AttachedDatabase &db, BlockManager &block_manager, DataTableInfo &table_info,
                    const vector<LogicalType> &types, RowGroupPointer &&pointer)
     : SegmentBase(pointer.row_start, pointer.tuple_count), db(db), block_manager(block_manager),
       table_info(table_info) {
@@ -77,6 +78,10 @@ void VersionNode::SetStart(idx_t start) {
 RowGroup::~RowGroup() {
 }
 
+DatabaseInstance &RowGroup::GetDatabase() {
+	return db.GetDatabase();
+}
+
 void RowGroup::InitializeEmpty(const vector<LogicalType> &types) {
 	// set up the segment trees for the column segments
 	for (idx_t i = 0; i < types.size(); i++) {

package/src/duckdb/src/storage/wal_replay.cpp

@@ -17,16 +17,17 @@
 #include "duckdb/storage/data_table.hpp"
 #include "duckdb/storage/write_ahead_log.hpp"
 #include "duckdb/storage/storage_manager.hpp"
+#include "duckdb/main/attached_database.hpp"
 
 namespace duckdb {
 
-bool WriteAheadLog::Replay(DatabaseInstance &database, string &path) {
-	auto initial_reader = make_unique<BufferedFileReader>(database.GetFileSystem(), path.c_str());
+bool WriteAheadLog::Replay(AttachedDatabase &database, string &path) {
+	auto initial_reader = make_unique<BufferedFileReader>(FileSystem::Get(database), path.c_str());
 	if (initial_reader->Finished()) {
 		// WAL is empty
 		return false;
 	}
-	Connection con(database);
+	Connection con(database.GetDatabase());
 	con.BeginTransaction();
 
 	// first deserialize the WAL to look for a checkpoint flag
@@ -58,7 +59,7 @@ bool WriteAheadLog::Replay(DatabaseInstance &database, string &path) {
 	initial_reader.reset();
 	if (checkpoint_state.checkpoint_id != INVALID_BLOCK) {
 		// there is a checkpoint flag: check if we need to deserialize the WAL
-		auto &manager = StorageManager::GetStorageManager(database);
+		auto &manager = database.GetStorageManager();
 		if (manager.IsCheckpointClean(checkpoint_state.checkpoint_id)) {
 			// the contents of the WAL have already been checkpointed
 			// we can safely truncate the WAL and ignore its contents
@@ -67,7 +68,7 @@ bool WriteAheadLog::Replay(DatabaseInstance &database, string &path) {
 	}
 
 	// we need to recover from the WAL: actually set up the replay state
-	BufferedFileReader reader(database.GetFileSystem(), path.c_str());
+	BufferedFileReader reader(FileSystem::Get(database), path.c_str());
 	ReplayState state(database, *con.context, reader);
 
 	// replay the WAL
@@ -192,7 +193,6 @@ void ReplayState::ReplayCreateTable() {
 	auto binder = Binder::CreateBinder(context);
 	auto bound_info = binder->BindCreateTableInfo(move(info));
 
-	auto &catalog = Catalog::GetCatalog(context);
 	catalog.CreateTable(context, bound_info.get());
 }
 
@@ -206,7 +206,6 @@ void ReplayState::ReplayDropTable() {
 		return;
 	}
 
-	auto &catalog = Catalog::GetCatalog(context);
 	catalog.DropEntry(context, &info);
 }
 
@@ -215,7 +214,6 @@ void ReplayState::ReplayAlter() {
 	if (deserialize_only) {
 		return;
 	}
-	auto &catalog = Catalog::GetCatalog(context);
 	catalog.Alter(context, info.get());
 }
 
@@ -228,7 +226,6 @@ void ReplayState::ReplayCreateView() {
 		return;
 	}
 
-	auto &catalog = Catalog::GetCatalog(context);
 	catalog.CreateView(context, entry.get());
 }
 
@@ -240,7 +237,6 @@ void ReplayState::ReplayDropView() {
 	if (deserialize_only) {
 		return;
 	}
-	auto &catalog = Catalog::GetCatalog(context);
 	catalog.DropEntry(context, &info);
 }
 
@@ -254,7 +250,6 @@ void ReplayState::ReplayCreateSchema() {
 		return;
 	}
 
-	auto &catalog = Catalog::GetCatalog(context);
 	catalog.CreateSchema(context, &info);
 }
 
@@ -267,7 +262,6 @@ void ReplayState::ReplayDropSchema() {
 		return;
 	}
 
-	auto &catalog = Catalog::GetCatalog(context);
 	catalog.DropEntry(context, &info);
 }
 
@@ -280,7 +274,6 @@ void ReplayState::ReplayCreateType() {
 		return;
 	}
 
-	auto &catalog = Catalog::GetCatalog(context);
 	catalog.CreateType(context, info.get());
 }
 
@@ -294,7 +287,6 @@ void ReplayState::ReplayDropType() {
 		return;
 	}
 
-	auto &catalog = Catalog::GetCatalog(context);
 	catalog.DropEntry(context, &info);
 }
 
@@ -307,7 +299,6 @@ void ReplayState::ReplayCreateSequence() {
 		return;
 	}
 
-	auto &catalog = Catalog::GetCatalog(context);
 	catalog.CreateSequence(context, entry.get());
 }
 
@@ -320,7 +311,6 @@ void ReplayState::ReplayDropSequence() {
 		return;
 	}
 
-	auto &catalog = Catalog::GetCatalog(context);
 	catalog.DropEntry(context, &info);
 }
 
@@ -334,7 +324,6 @@ void ReplayState::ReplaySequenceValue() {
 	}
 
 	// fetch the sequence from the catalog
-	auto &catalog = Catalog::GetCatalog(context);
 	auto seq = catalog.GetEntry<SequenceCatalogEntry>(context, schema, name);
 	if (usage_count > seq->usage_count) {
 		seq->usage_count = usage_count;
@@ -351,7 +340,6 @@ void ReplayState::ReplayCreateMacro() {
 		return;
 	}
 
-	auto &catalog = Catalog::GetCatalog(context);
 	catalog.CreateFunction(context, entry.get());
 }
 
@@ -364,7 +352,6 @@ void ReplayState::ReplayDropMacro() {
 		return;
 	}
 
-	auto &catalog = Catalog::GetCatalog(context);
 	catalog.DropEntry(context, &info);
 }
 
@@ -377,7 +364,6 @@ void ReplayState::ReplayCreateTableMacro() {
 		return;
 	}
 
-	auto &catalog = Catalog::GetCatalog(context);
 	catalog.CreateFunction(context, entry.get());
 }
 
@@ -390,7 +376,6 @@ void ReplayState::ReplayDropTableMacro() {
 		return;
 	}
 
-	auto &catalog = Catalog::GetCatalog(context);
 	catalog.DropEntry(context, &info);
 }
 
@@ -403,7 +388,6 @@ void ReplayState::ReplayUseTable() {
 	if (deserialize_only) {
 		return;
 	}
-	auto &catalog = Catalog::GetCatalog(context);
 	current_table = catalog.GetEntry<TableCatalogEntry>(context, schema_name, table_name);
 }
 

package/src/duckdb/src/storage/write_ahead_log.cpp

@@ -11,9 +11,9 @@
 
 namespace duckdb {
 
-WriteAheadLog::WriteAheadLog(DatabaseInstance &database, const string &path) : skip_writing(false), database(database) {
+WriteAheadLog::WriteAheadLog(AttachedDatabase &database, const string &path) : skip_writing(false), database(database) {
 	wal_path = path;
-	writer = make_unique<BufferedFileWriter>(database.GetFileSystem(), path.c_str(),
+	writer = make_unique<BufferedFileWriter>(FileSystem::Get(database), path.c_str(),
 	                                         FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE |
 	                                             FileFlags::FILE_FLAGS_APPEND);
 }
@@ -41,7 +41,7 @@ void WriteAheadLog::Delete() {
 	}
 	writer.reset();
 
-	auto &fs = FileSystem::GetFileSystem(database);
+	auto &fs = FileSystem::Get(database);
 	fs.RemoveFile(wal_path);
 }