duckdb 1.3.3-dev0.0 → 1.3.3-dev4.0

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

@@ -30,6 +30,8 @@
 #include "duckdb/storage/compression/empty_validity.hpp"
 #include "duckdb/logging/logger.hpp"
 #include "duckdb/common/http_util.hpp"
+#include "mbedtls_wrapper.hpp"
+#include "duckdb/main/database_file_path_manager.hpp"
 
 #ifndef DUCKDB_NO_THREADS
 #include "duckdb/common/thread.hpp"
@@ -65,7 +67,7 @@ DBConfig::DBConfig(const case_insensitive_map_t<Value> &config_dict, bool read_o
 DBConfig::~DBConfig() {
 }
 
-DatabaseInstance::DatabaseInstance() {
+DatabaseInstance::DatabaseInstance() : db_validity(*this) {
 	config.is_user_config = false;
 	create_api_v1 = nullptr;
 }
@@ -97,18 +99,6 @@ DatabaseInstance::~DatabaseInstance() {
 	config.db_cache_entry.reset();
 }
 
-BufferManager &BufferManager::GetBufferManager(DatabaseInstance &db) {
-	return db.GetBufferManager();
-}
-
-const BufferManager &BufferManager::GetBufferManager(const DatabaseInstance &db) {
-	return db.GetBufferManager();
-}
-
-BufferManager &BufferManager::GetBufferManager(AttachedDatabase &db) {
-	return BufferManager::GetBufferManager(db.GetDatabase());
-}
-
 DatabaseInstance &DatabaseInstance::GetDatabase(ClientContext &context) {
 	return *context.db;
 }
@@ -172,9 +162,9 @@ ConnectionManager &ConnectionManager::Get(ClientContext &context) {
 	return ConnectionManager::Get(DatabaseInstance::GetDatabase(context));
 }
 
-unique_ptr<AttachedDatabase> DatabaseInstance::CreateAttachedDatabase(ClientContext &context, AttachInfo &info,
+shared_ptr<AttachedDatabase> DatabaseInstance::CreateAttachedDatabase(ClientContext &context, AttachInfo &info,
                                                                       AttachOptions &options) {
-	unique_ptr<AttachedDatabase> attached_database;
+	shared_ptr<AttachedDatabase> attached_database;
 	auto &catalog = Catalog::GetSystemCatalog(*this);
 
 	if (!options.db_type.empty()) {
@@ -188,16 +178,16 @@ unique_ptr<AttachedDatabase> DatabaseInstance::CreateAttachedDatabase(ClientCont
 		if (entry->second->attach != nullptr && entry->second->create_transaction_manager != nullptr) {
 			// Use the storage extension to create the initial database.
 			attached_database =
-			    make_uniq<AttachedDatabase>(*this, catalog, *entry->second, context, info.name, info, options);
+			    make_shared_ptr<AttachedDatabase>(*this, catalog, *entry->second, context, info.name, info, options);
 			return attached_database;
 		}
 
-		attached_database = make_uniq<AttachedDatabase>(*this, catalog, info.name, info.path, options);
+		attached_database = make_shared_ptr<AttachedDatabase>(*this, catalog, info.name, info.path, options);
 		return attached_database;
 	}
 
 	// An empty db_type defaults to a duckdb database file.
-	attached_database = make_uniq<AttachedDatabase>(*this, catalog, info.name, info.path, options);
+	attached_database = make_shared_ptr<AttachedDatabase>(*this, catalog, info.name, info.path, options);
 	return attached_database;
 }
 
@@ -206,14 +196,13 @@ void DatabaseInstance::CreateMainDatabase() {
 	info.name = AttachedDatabase::ExtractDatabaseName(config.options.database_path, GetFileSystem());
 	info.path = config.options.database_path;
 
-	optional_ptr<AttachedDatabase> initial_database;
 	Connection con(*this);
 	con.BeginTransaction();
 	AttachOptions options(config.options);
-	initial_database = db_manager->AttachDatabase(*con.context, info, options);
-
+	auto initial_database = db_manager->AttachDatabase(*con.context, info, options);
 	initial_database->SetInitialDatabase();
 	initial_database->Initialize(*con.context);
+	db_manager->FinalizeAttach(*con.context, info, std::move(initial_database));
 	con.Commit();
 }
 
@@ -304,21 +293,19 @@ void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_conf
 	scheduler = make_uniq<TaskScheduler>(*this);
 	object_cache = make_uniq<ObjectCache>();
 	connection_manager = make_uniq<ConnectionManager>();
+	extension_manager = make_uniq<ExtensionManager>(*this);
 
 	// initialize the secret manager
 	config.secret_manager->Initialize(*this);
 
-	// resolve the type of teh database we are opening
+	// resolve the type of the database we are opening
 	auto &fs = FileSystem::GetFileSystem(*this);
 	DBPathAndType::ResolveDatabaseType(fs, config.options.database_path, config.options.database_type);
 
 	// initialize the system catalog
 	db_manager->InitializeSystemCatalog();
 
-	if (config.options.database_type == "duckdb") {
-		config.options.database_type = string();
-	}
-	if (!config.options.database_type.empty()) {
+	if (!config.options.database_type.empty() && !StringUtil::CIEquals(config.options.database_type, "duckdb")) {
 		// if we are opening an extension database - load the extension
 		if (!config.file_system) {
 			throw InternalException("No file system!?");
@@ -401,6 +388,10 @@ ConnectionManager &DatabaseInstance::GetConnectionManager() {
 	return *connection_manager;
 }
 
+ExtensionManager &DatabaseInstance::GetExtensionManager() {
+	return *extension_manager;
+}
+
 FileSystem &DuckDB::GetFileSystem() {
 	return instance->GetFileSystem();
 }
@@ -453,6 +444,9 @@ void DatabaseInstance::Configure(DBConfig &new_config, const char *database_path
 	if (new_config.secret_manager) {
 		config.secret_manager = std::move(new_config.secret_manager);
 	}
+	if (!new_config.storage_extensions.empty()) {
+		config.storage_extensions = std::move(new_config.storage_extensions);
+	}
 	if (config.options.maximum_memory == DConstants::INVALID_INDEX) {
 		config.SetDefaultMaxMemory();
 	}
@@ -480,6 +474,7 @@ void DatabaseInstance::Configure(DBConfig &new_config, const char *database_path
 		                                                 config.options.allocator_bulk_deallocation_flush_threshold);
 	}
 	config.db_cache_entry = std::move(new_config.db_cache_entry);
+	config.path_manager = std::move(new_config.path_manager);
 }
 
 DBConfig &DBConfig::GetConfig(ClientContext &context) {
@@ -494,52 +489,30 @@ idx_t DatabaseInstance::NumberOfThreads() {
 	return NumericCast<idx_t>(scheduler->NumberOfThreads());
 }
 
-const unordered_map<string, ExtensionInfo> &DatabaseInstance::GetExtensions() {
-	return loaded_extensions_info;
-}
-
-void DatabaseInstance::AddExtensionInfo(const string &name, const ExtensionLoadedInfo &info) {
-	loaded_extensions_info[name].load_info = make_uniq<ExtensionLoadedInfo>(info);
-}
-
 idx_t DuckDB::NumberOfThreads() {
 	return instance->NumberOfThreads();
 }
 
-bool DatabaseInstance::ExtensionIsLoaded(const std::string &name) {
-	auto extension_name = ExtensionHelper::GetExtensionName(name);
-	auto it = loaded_extensions_info.find(extension_name);
-	return it != loaded_extensions_info.end() && it->second.is_loaded;
+bool DatabaseInstance::ExtensionIsLoaded(const string &name) {
+	return extension_manager->ExtensionIsLoaded(name);
 }
 
 bool DuckDB::ExtensionIsLoaded(const std::string &name) {
 	return instance->ExtensionIsLoaded(name);
 }
 
-void DatabaseInstance::SetExtensionLoaded(const string &name, ExtensionInstallInfo &install_info) {
-	auto extension_name = ExtensionHelper::GetExtensionName(name);
-	loaded_extensions_info[extension_name].is_loaded = true;
-	loaded_extensions_info[extension_name].install_info = make_uniq<ExtensionInstallInfo>(install_info);
-
-	auto &callbacks = DBConfig::GetConfig(*this).extension_callbacks;
-	for (auto &callback : callbacks) {
-		callback->OnExtensionLoaded(*this, name);
-	}
-	DUCKDB_LOG_INFO(*this, name);
-}
-
-SettingLookupResult DatabaseInstance::TryGetCurrentSetting(const std::string &key, Value &result) const {
+SettingLookupResult DatabaseInstance::TryGetCurrentSetting(const string &key, Value &result) const {
 	// check the session values
 	auto &db_config = DBConfig::GetConfig(*this);
-	const auto &global_config_map = db_config.options.set_variables;
+	return db_config.TryGetCurrentSetting(key, result);
+}
 
-	auto global_value = global_config_map.find(key);
-	bool found_global_value = global_value != global_config_map.end();
-	if (!found_global_value) {
-		return SettingLookupResult();
+shared_ptr<EncryptionUtil> DatabaseInstance::GetEncryptionUtil() const {
+	if (config.encryption_util) {
+		return config.encryption_util;
 	}
-	result = global_value->second;
-	return SettingLookupResult(SettingScope::GLOBAL);
+
+	return make_shared_ptr<duckdb_mbedtls::MbedTlsWrapper::AESStateMBEDTLSFactory>();
 }
 
 ValidChecker &DatabaseInstance::GetValidChecker() {

package/src/duckdb/src/main/database_file_path_manager.cpp

@@ -0,0 +1,42 @@
+#include "duckdb/main/database_file_path_manager.hpp"
+#include "duckdb/common/exception/binder_exception.hpp"
+#include "duckdb/parser/parsed_data/attach_info.hpp"
+#include "duckdb/main/attached_database.hpp"
+
+namespace duckdb {
+
+idx_t DatabaseFilePathManager::ApproxDatabaseCount() const {
+	lock_guard<mutex> path_lock(db_paths_lock);
+	return db_paths_to_name.size();
+}
+
+InsertDatabasePathResult DatabaseFilePathManager::InsertDatabasePath(const string &path, const string &name,
+                                                                     OnCreateConflict on_conflict,
+                                                                     AttachOptions &options) {
+	if (path.empty() || path == IN_MEMORY_PATH) {
+		return InsertDatabasePathResult::SUCCESS;
+	}
+
+	lock_guard<mutex> path_lock(db_paths_lock);
+	auto entry = db_paths_to_name.emplace(path, name);
+	if (!entry.second) {
+		if (on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT && entry.first->second == name) {
+			return InsertDatabasePathResult::ALREADY_EXISTS;
+		}
+		throw BinderException("Unique file handle conflict: Cannot attach \"%s\" - the database file \"%s\" is already "
+		                      "attached by database \"%s\"",
+		                      name, path, entry.first->second);
+	}
+	options.stored_database_path = make_uniq<StoredDatabasePath>(*this, path, name);
+	return InsertDatabasePathResult::SUCCESS;
+}
+
+void DatabaseFilePathManager::EraseDatabasePath(const string &path) {
+	if (path.empty() || path == IN_MEMORY_PATH) {
+		return;
+	}
+	lock_guard<mutex> path_lock(db_paths_lock);
+	db_paths_to_name.erase(path);
+}
+
+} // namespace duckdb

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

@@ -8,13 +8,20 @@
 #include "duckdb/main/database_path_and_type.hpp"
 #include "duckdb/main/extension_helper.hpp"
 #include "duckdb/storage/storage_manager.hpp"
+#include "duckdb/transaction/duck_transaction.hpp"
+#include "duckdb/transaction/duck_transaction_manager.hpp"
 
 namespace duckdb {
 
 DatabaseManager::DatabaseManager(DatabaseInstance &db)
     : next_oid(0), current_query_number(1), current_transaction_id(0) {
-	system = make_uniq<AttachedDatabase>(db);
-	databases = make_uniq<CatalogSet>(system->GetCatalog());
+	system = make_shared_ptr<AttachedDatabase>(db);
+	auto &config = DBConfig::GetConfig(db);
+	path_manager = config.path_manager;
+	if (!path_manager) {
+		// no shared path manager
+		path_manager = make_shared_ptr<DatabaseFilePathManager>();
+	}
 }
 
 DatabaseManager::~DatabaseManager() {
@@ -30,24 +37,59 @@ void DatabaseManager::InitializeSystemCatalog() {
 }
 
 void DatabaseManager::FinalizeStartup() {
-	auto databases = GetDatabases();
-	for (auto &db : databases) {
-		db.get().FinalizeLoad(nullptr);
+	auto dbs = GetDatabases();
+	for (auto &db : dbs) {
+		db->FinalizeLoad(nullptr);
 	}
 }
 
 optional_ptr<AttachedDatabase> DatabaseManager::GetDatabase(ClientContext &context, const string &name) {
+	auto &meta_transaction = MetaTransaction::Get(context);
+	// first check if we have a local reference to this database already
+	auto database = meta_transaction.GetReferencedDatabase(name);
+	if (database) {
+		// we do! return it
+		return database;
+	}
+	lock_guard<mutex> guard(databases_lock);
 	if (StringUtil::Lower(name) == TEMP_CATALOG) {
-		return context.client_data->temporary_objects.get();
+		return meta_transaction.UseDatabase(context.client_data->temporary_objects);
 	}
 	if (StringUtil::Lower(name) == SYSTEM_CATALOG) {
-		return system;
+		return meta_transaction.UseDatabase(system);
 	}
-	return reinterpret_cast<AttachedDatabase *>(databases->GetEntry(context, name).get());
+	auto entry = databases.find(name);
+	if (entry == databases.end()) {
+		// not found
+		return nullptr;
+	}
+	return meta_transaction.UseDatabase(entry->second);
 }
 
-optional_ptr<AttachedDatabase> DatabaseManager::AttachDatabase(ClientContext &context, AttachInfo &info,
-                                                               AttachOptions &options) {
+shared_ptr<AttachedDatabase> DatabaseManager::AttachDatabase(ClientContext &context, AttachInfo &info,
+                                                             AttachOptions &options) {
+	auto &config = DBConfig::GetConfig(context);
+	if (options.db_type.empty() || StringUtil::CIEquals(options.db_type, "duckdb")) {
+		while (InsertDatabasePath(info, options) == InsertDatabasePathResult::ALREADY_EXISTS) {
+			// database with this name and path already exists
+			// ... but it might not be done attaching yet!
+			// verify the database has actually finished attaching prior to returning
+			lock_guard<mutex> guard(databases_lock);
+			if (databases.find(info.name) != databases.end()) {
+				// database ACTUALLY exists - return
+				return nullptr;
+			}
+			if (context.interrupted) {
+				throw InterruptException();
+			}
+		}
+	}
+	GetDatabaseType(context, info, config, options);
+	if (!options.db_type.empty()) {
+		// we only need to prevent duplicate opening of DuckDB files
+		// if this is not a DuckDB file but e.g. a CSV or Parquet file, we don't need to do this duplicate protection
+		options.stored_database_path.reset();
+	}
 	if (AttachedDatabase::NameIsReserved(info.name)) {
 		throw BinderException("Attached database name \"%s\" cannot be used because it is a reserved name", info.name);
 	}
@@ -68,27 +110,41 @@ optional_ptr<AttachedDatabase> DatabaseManager::AttachDatabase(ClientContext &co
 	// now create the attached database
 	auto &db = DatabaseInstance::GetDatabase(context);
 	auto attached_db = db.CreateAttachedDatabase(context, info, options);
+	return attached_db;
+}
 
-	if (options.db_type.empty()) {
-		InsertDatabasePath(context, info.path, attached_db->name);
-	}
-
+optional_ptr<AttachedDatabase> DatabaseManager::FinalizeAttach(ClientContext &context, AttachInfo &info,
+                                                               shared_ptr<AttachedDatabase> attached_db) {
 	const auto name = attached_db->GetName();
 	attached_db->oid = NextOid();
-	LogicalDependencyList dependencies;
 	if (default_database.empty()) {
 		default_database = name;
 	}
-
-	// and add it to the databases catalog set
-	if (info.on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT) {
-		DetachDatabase(context, name, OnEntryNotFound::RETURN_NULL);
+	shared_ptr<AttachedDatabase> detached_db;
+	{
+		lock_guard<mutex> guard(databases_lock);
+		auto entry = databases.emplace(name, attached_db);
+		if (!entry.second) {
+			if (info.on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT) {
+				// override existing entry
+				detached_db = std::move(entry.first->second);
+				databases[name] = attached_db;
+			} else {
+				throw BinderException("Failed to attach database: database with name \"%s\" already exists", name);
+			}
+		}
 	}
-	if (!databases->CreateEntry(context, name, std::move(attached_db), dependencies)) {
-		throw BinderException("Failed to attach database: database with name \"%s\" already exists", name);
+	auto &meta_transaction = MetaTransaction::Get(context);
+	if (detached_db) {
+		meta_transaction.DetachDatabase(*detached_db);
+		detached_db->OnDetach(context);
+		detached_db.reset();
 	}
-
-	return GetDatabase(context, name);
+	auto &db_ref = meta_transaction.UseDatabase(attached_db);
+	auto &transaction = DuckTransaction::Get(context, *system);
+	auto &transaction_manager = DuckTransactionManager::Get(*system);
+	transaction_manager.PushAttach(transaction, db_ref);
+	return db_ref;
 }
 
 void DatabaseManager::DetachDatabase(ClientContext &context, const string &name, OnEntryNotFound if_not_found) {
@@ -98,102 +154,70 @@ void DatabaseManager::DetachDatabase(ClientContext &context, const string &name,
 		                      name);
 	}
 
-	auto entry = databases->GetEntry(context, name);
-	if (!entry) {
+	auto attached_db = DetachInternal(name);
+	if (!attached_db) {
 		if (if_not_found == OnEntryNotFound::THROW_EXCEPTION) {
 			throw BinderException("Failed to detach database with name \"%s\": database not found", name);
 		}
 		return;
 	}
-	auto &db = entry->Cast<AttachedDatabase>();
-	db.OnDetach(context);
 
-	if (!databases->DropEntry(context, name, false, true)) {
-		throw InternalException("Failed to drop attached database");
-	}
+	attached_db->OnDetach(context);
 }
 
-optional_ptr<AttachedDatabase> DatabaseManager::GetDatabaseFromPath(ClientContext &context, const string &path) {
-	auto database_list = GetDatabases(context);
-	for (auto &db_ref : database_list) {
-		auto &db = db_ref.get();
-		if (db.IsSystem()) {
-			continue;
-		}
-		auto &catalog = Catalog::GetCatalog(db);
-		if (catalog.InMemory()) {
-			continue;
-		}
-		auto db_path = catalog.GetDBPath();
-		if (StringUtil::CIEquals(path, db_path)) {
-			return &db;
-		}
-	}
-	return nullptr;
-}
-
-void DatabaseManager::CheckPathConflict(ClientContext &context, const string &path) {
-	// ensure that we did not already attach a database with the same path
-	bool path_exists;
+shared_ptr<AttachedDatabase> DatabaseManager::DetachInternal(const string &name) {
+	shared_ptr<AttachedDatabase> attached_db;
 	{
-		lock_guard<mutex> path_lock(db_paths_lock);
-		path_exists = db_paths.find(path) != db_paths.end();
-	}
-	if (path_exists) {
-		// check that the database is actually still attached
-		auto entry = GetDatabaseFromPath(context, path);
-		if (entry) {
-			throw BinderException("Unique file handle conflict: Database \"%s\" is already attached with path \"%s\", ",
-			                      entry->name, path);
+		lock_guard<mutex> guard(databases_lock);
+		auto entry = databases.find(name);
+		if (entry == databases.end()) {
+			return nullptr;
 		}
+		attached_db = std::move(entry->second);
+		databases.erase(entry);
 	}
+	return attached_db;
 }
 
-void DatabaseManager::InsertDatabasePath(ClientContext &context, const string &path, const string &name) {
-	if (path.empty() || path == IN_MEMORY_PATH) {
-		return;
-	}
-
-	CheckPathConflict(context, path);
-	lock_guard<mutex> path_lock(db_paths_lock);
-	db_paths.insert(path);
+idx_t DatabaseManager::ApproxDatabaseCount() {
+	return path_manager->ApproxDatabaseCount();
 }
 
-void DatabaseManager::EraseDatabasePath(const string &path) {
-	if (path.empty() || path == IN_MEMORY_PATH) {
-		return;
-	}
-	lock_guard<mutex> path_lock(db_paths_lock);
-	auto path_it = db_paths.find(path);
-	if (path_it != db_paths.end()) {
-		db_paths.erase(path_it);
-	}
+InsertDatabasePathResult DatabaseManager::InsertDatabasePath(const AttachInfo &info, AttachOptions &options) {
+	return path_manager->InsertDatabasePath(info.path, info.name, info.on_conflict, options);
 }
 
 vector<string> DatabaseManager::GetAttachedDatabasePaths() {
-	lock_guard<mutex> path_lock(db_paths_lock);
-	vector<string> paths;
-	for (auto &path : db_paths) {
-		paths.push_back(path);
+	vector<string> result;
+	lock_guard<mutex> guard(databases_lock);
+	for (auto &entry : databases) {
+		auto &db_ref = *entry.second;
+		auto &catalog = db_ref.GetCatalog();
+		if (catalog.InMemory() || catalog.IsSystemCatalog()) {
+			continue;
+		}
+		auto path = catalog.GetDBPath();
+		if (path.empty()) {
+			continue;
+		}
+		result.push_back(std::move(path));
 	}
-	return paths;
+	return result;
 }
 
 void DatabaseManager::GetDatabaseType(ClientContext &context, AttachInfo &info, const DBConfig &config,
                                       AttachOptions &options) {
 
 	// Test if the database is a DuckDB database file.
-	if (StringUtil::CIEquals(options.db_type, "DUCKDB")) {
+	if (StringUtil::CIEquals(options.db_type, "duckdb")) {
 		options.db_type = "";
 		return;
 	}
 
 	// Try to extract the database type from the path.
 	if (options.db_type.empty()) {
-		CheckPathConflict(context, info.path);
-
 		auto &fs = FileSystem::GetFileSystem(context);
-		DBPathAndType::CheckMagicBytes(fs, info.path, options.db_type);
+		DBPathAndType::CheckMagicBytes(QueryContext(context), fs, info.path, options.db_type);
 	}
 
 	if (options.db_type.empty()) {
@@ -243,44 +267,46 @@ void DatabaseManager::SetDefaultDatabase(ClientContext &context, const string &n
 }
 // LCOV_EXCL_STOP
 
-vector<reference<AttachedDatabase>> DatabaseManager::GetDatabases(ClientContext &context,
-                                                                  const optional_idx max_db_count) {
-	vector<reference<AttachedDatabase>> result;
+vector<shared_ptr<AttachedDatabase>> DatabaseManager::GetDatabases(ClientContext &context,
+                                                                   const optional_idx max_db_count) {
+	vector<shared_ptr<AttachedDatabase>> result;
+
+	lock_guard<mutex> guard(databases_lock);
 	idx_t count = 2;
-	databases->ScanWithReturn(context, [&](CatalogEntry &entry) {
+	for (auto &entry : databases) {
 		if (max_db_count.IsValid() && count >= max_db_count.GetIndex()) {
-			return false;
+			break;
 		}
-		result.push_back(entry.Cast<AttachedDatabase>());
+		result.push_back(entry.second);
 		count++;
-		return true;
-	});
-
+	}
 	if (!max_db_count.IsValid() || max_db_count.GetIndex() >= 1) {
-		result.push_back(*system);
+		result.push_back(system);
 	}
 	if (!max_db_count.IsValid() || max_db_count.GetIndex() >= 2) {
-		result.push_back(*context.client_data->temporary_objects);
+		result.push_back(context.client_data->temporary_objects);
 	}
 
 	return result;
 }
 
-vector<reference<AttachedDatabase>> DatabaseManager::GetDatabases() {
-	vector<reference<AttachedDatabase>> result;
-	databases->Scan([&](CatalogEntry &entry) { result.push_back(entry.Cast<AttachedDatabase>()); });
-	result.push_back(*system);
+vector<shared_ptr<AttachedDatabase>> DatabaseManager::GetDatabases() {
+	vector<shared_ptr<AttachedDatabase>> result;
+
+	lock_guard<mutex> guard(databases_lock);
+	for (auto &entry : databases) {
+		result.push_back(entry.second);
+	}
+	result.push_back(system);
 	return result;
 }
 
 void DatabaseManager::ResetDatabases(unique_ptr<TaskScheduler> &scheduler) {
-	vector<reference<AttachedDatabase>> result;
-	databases->Scan([&](CatalogEntry &entry) { result.push_back(entry.Cast<AttachedDatabase>()); });
-	for (auto &database : result) {
-		database.get().Close();
+	auto databases = GetDatabases();
+	for (auto &entry : databases) {
+		entry->Close();
+		entry.reset();
 	}
-	scheduler.reset();
-	databases.reset();
 }
 
 Catalog &DatabaseManager::GetSystemCatalog() {

package/src/duckdb/src/main/database_path_and_type.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/main/extension_helper.hpp"
 #include "duckdb/storage/magic_bytes.hpp"
 #include "duckdb/function/replacement_scan.hpp"
+#include "duckdb/main/client_context.hpp"
 
 namespace duckdb {
 
@@ -15,9 +16,9 @@ void DBPathAndType::ExtractExtensionPrefix(string &path, string &db_type) {
 	}
 }
 
-void DBPathAndType::CheckMagicBytes(FileSystem &fs, string &path, string &db_type) {
+void DBPathAndType::CheckMagicBytes(QueryContext context, FileSystem &fs, string &path, string &db_type) {
 	// if there isn't - check the magic bytes of the file (if any)
-	auto file_type = MagicBytes::CheckMagicBytes(fs, path);
+	auto file_type = MagicBytes::CheckMagicBytes(context, fs, path);
 	db_type = string();
 	switch (file_type) {
 	case DataFileType::SQLITE_FILE:
@@ -50,7 +51,7 @@ void DBPathAndType::ResolveDatabaseType(FileSystem &fs, string &path, string &db
 		return;
 	}
 	// check database type by reading the magic bytes of a file
-	DBPathAndType::CheckMagicBytes(fs, path, db_type);
+	DBPathAndType::CheckMagicBytes(QueryContext(), fs, path, db_type);
 }
 
 } // namespace duckdb