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

package/src/duckdb/src/main/db_instance_cache.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/main/db_instance_cache.hpp"
 #include "duckdb/main/extension_helper.hpp"
+#include "duckdb/main/database_file_path_manager.hpp"
 
 namespace duckdb {
 
@@ -31,7 +32,16 @@ string GetDBAbsolutePath(const string &database_p, FileSystem &fs) {
 	return fs.NormalizeAbsolutePath(fs.JoinPath(FileSystem::GetWorkingDirectory(), database));
 }
 
-shared_ptr<DuckDB> DBInstanceCache::GetInstanceInternal(const string &database, const DBConfig &config) {
+DBInstanceCache::DBInstanceCache() {
+	path_manager = make_shared_ptr<DatabaseFilePathManager>();
+}
+
+DBInstanceCache::~DBInstanceCache() {
+}
+
+shared_ptr<DuckDB> DBInstanceCache::GetInstanceInternal(const string &database, const DBConfig &config,
+                                                        std::unique_lock<std::mutex> &db_instances_lock) {
+	D_ASSERT(db_instances_lock.owns_lock());
 	auto local_fs = FileSystem::CreateLocal();
 	auto abs_database_path = GetDBAbsolutePath(database, *local_fs);
 	auto entry = db_instances.find(abs_database_path);
@@ -39,45 +49,52 @@ shared_ptr<DuckDB> DBInstanceCache::GetInstanceInternal(const string &database,
 		// path does not exist in the list yet - no cache entry
 		return nullptr;
 	}
-	auto cache_entry = entry->second.lock();
+	auto weak_cache_entry = entry->second;
+	auto cache_entry = weak_cache_entry.lock();
 	if (!cache_entry) {
 		// cache entry does not exist anymore - clean it up
 		db_instances.erase(entry);
 		return nullptr;
 	}
+	shared_ptr<DuckDB> db_instance;
+	{
+		db_instances_lock.unlock();
+		std::lock_guard<mutex> create_db_lock(cache_entry->update_database_mutex);
+		db_instance = cache_entry->database.lock();
+	}
 	// cache entry exists - check if the actual database still exists
-	auto db_instance = cache_entry->database.lock();
 	if (!db_instance) {
 		// if the database does not exist, but the cache entry still exists, the database is being shut down
 		// we need to wait until the database is fully shut down to safely proceed
 		// we do this here using a busy spin
-		while (cache_entry) {
-			// clear our cache entry
-			cache_entry.reset();
-			// try to lock it again
-			cache_entry = entry->second.lock();
+		cache_entry.reset();
+		while (!weak_cache_entry.expired()) {
 		}
+		D_ASSERT(!cache_entry);
 		// the cache entry has now been deleted - clear it from the set of database instances and return
-		db_instances.erase(entry);
+		db_instances_lock.lock();
+		db_instances.erase(abs_database_path);
+		db_instances_lock.unlock();
 		return nullptr;
 	}
 	// the database instance exists - check that the config matches
 	if (db_instance->instance->config != config) {
-		throw duckdb::ConnectionException(
-		    "Can't open a connection to same database file with a different configuration "
-		    "than existing connections");
+		throw ConnectionException("Can't open a connection to same database file with a different configuration "
+		                          "than existing connections");
 	}
 	return db_instance;
 }
 
 shared_ptr<DuckDB> DBInstanceCache::GetInstance(const string &database, const DBConfig &config) {
-	lock_guard<mutex> l(cache_lock);
-	return GetInstanceInternal(database, config);
+	unique_lock<mutex> lock {cache_lock};
+	return GetInstanceInternal(database, config, lock);
 }
 
 shared_ptr<DuckDB> DBInstanceCache::CreateInstanceInternal(const string &database, DBConfig &config,
-                                                           bool cache_instance,
+                                                           const bool cache_instance,
+                                                           std::unique_lock<std::mutex> db_instances_lock,
                                                            const std::function<void(DuckDB &)> &on_create) {
+	D_ASSERT(db_instances_lock.owns_lock());
 	string abs_database_path;
 	if (config.file_system) {
 		abs_database_path = GetDBAbsolutePath(database, *config.file_system);
@@ -85,27 +102,26 @@ shared_ptr<DuckDB> DBInstanceCache::CreateInstanceInternal(const string &databas
 		auto tmp_fs = FileSystem::CreateLocal();
 		abs_database_path = GetDBAbsolutePath(database, *tmp_fs);
 	}
-	if (db_instances.find(abs_database_path) != db_instances.end()) {
-		throw duckdb::Exception(ExceptionType::CONNECTION,
-		                        "Instance with path: " + abs_database_path + " already exists.");
-	}
 	// Creates new instance
 	string instance_path = abs_database_path;
 	if (abs_database_path.rfind(IN_MEMORY_PATH, 0) == 0) {
 		instance_path = IN_MEMORY_PATH;
 	}
-	shared_ptr<DatabaseCacheEntry> cache_entry;
+	shared_ptr<DuckDB> db_instance;
+	config.path_manager = path_manager;
 	if (cache_instance) {
-		cache_entry = make_shared_ptr<DatabaseCacheEntry>();
+		D_ASSERT(db_instances.find(abs_database_path) == db_instances.end());
+		shared_ptr<DatabaseCacheEntry> cache_entry = make_shared_ptr<DatabaseCacheEntry>();
 		config.db_cache_entry = cache_entry;
-	}
-	auto db_instance = make_shared_ptr<DuckDB>(instance_path, &config);
-	if (cache_entry) {
-		// attach cache entry to the database
-		cache_entry->database = db_instance;
-
-		// cache the entry in the db_instances map
+		// Create the new instance after unlocking to avoid new ddb creation requests to be blocked
+		lock_guard<mutex> create_db_lock(cache_entry->update_database_mutex);
 		db_instances[abs_database_path] = cache_entry;
+		db_instances_lock.unlock();
+		db_instance = make_shared_ptr<DuckDB>(instance_path, &config);
+		cache_entry->database = db_instance;
+	} else {
+		db_instances_lock.unlock();
+		db_instance = make_shared_ptr<DuckDB>(instance_path, &config);
 	}
 	if (on_create) {
 		on_create(*db_instance);
@@ -115,21 +131,34 @@ shared_ptr<DuckDB> DBInstanceCache::CreateInstanceInternal(const string &databas
 
 shared_ptr<DuckDB> DBInstanceCache::CreateInstance(const string &database, DBConfig &config, bool cache_instance,
                                                    const std::function<void(DuckDB &)> &on_create) {
-	lock_guard<mutex> l(cache_lock);
-	return CreateInstanceInternal(database, config, cache_instance, on_create);
+	return CreateInstanceInternal(database, config, cache_instance, unique_lock<mutex>(cache_lock), on_create);
 }
 
 shared_ptr<DuckDB> DBInstanceCache::GetOrCreateInstance(const string &database, DBConfig &config_dict,
                                                         bool cache_instance,
                                                         const std::function<void(DuckDB &)> &on_create) {
-	lock_guard<mutex> l(cache_lock);
+	unique_lock<mutex> lock(cache_lock, std::defer_lock);
 	if (cache_instance) {
-		auto instance = GetInstanceInternal(database, config_dict);
-		if (instance) {
-			return instance;
+
+		// While we do not own the lock, we cannot definitively say that the database instance does not exist.
+		while (!lock.owns_lock()) {
+			// The problem is, that we have to unlock the mutex in GetInstanceInternal, so we can non-blockingly wait
+			// for the database creation within the cache entry.
+			// Now even after unlocking and waiting for the DB creation we cannot guarantee that the database exists (it
+			// could have gone out of scope in the meantime). If that happened we have unlocked the global lock to wait,
+			// however we still return a nullptr. In this case we have to re-lock and try again until we either do not
+			// find a cache entry (can be done without unlocking) or we find a cache entry and the database is valid as
+			// well (in this case we can return that database)
+			lock.lock();
+			auto instance = GetInstanceInternal(database, config_dict, lock);
+			if (instance) {
+				return instance;
+			}
 		}
+	} else {
+		lock.lock();
 	}
-	return CreateInstanceInternal(database, config_dict, cache_instance, on_create);
+	return CreateInstanceInternal(database, config_dict, cache_instance, std::move(lock), on_create);
 }
 
 } // namespace duckdb

package/src/duckdb/src/main/error_manager.cpp

@@ -3,6 +3,7 @@
 #include "utf8proc_wrapper.hpp"
 #include "duckdb/common/exception/list.hpp"
 #include "duckdb/common/string_util.hpp"
+#include "duckdb/common/types/string.hpp"
 
 namespace duckdb {
 
@@ -49,7 +50,7 @@ string ErrorManager::FormatExceptionRecursive(ErrorType error_type, vector<Excep
 	return ExceptionFormatValue::Format(error, values);
 }
 
-InvalidInputException ErrorManager::InvalidUnicodeError(const string &input, const string &context) {
+InvalidInputException ErrorManager::InvalidUnicodeError(const String &input, const string &context) {
 	UnicodeInvalidReason reason;
 	size_t pos;
 	auto unicode = Utf8Proc::Analyze(const_char_ptr_cast(input.c_str()), input.size(), &reason, &pos);

package/src/duckdb/src/main/extension/extension_helper.cpp

@@ -10,6 +10,7 @@
 #include "duckdb/main/database.hpp"
 #include "duckdb/main/extension.hpp"
 #include "duckdb/main/extension_install_info.hpp"
+#include "duckdb/main/settings.hpp"
 
 // Note that c++ preprocessor doesn't have a nice way to clean this up so we need to set the defines we use to false
 // explicitly when they are undefined
@@ -212,9 +213,8 @@ bool ExtensionHelper::TryAutoLoadExtension(ClientContext &context, const string
 	auto &dbconfig = DBConfig::GetConfig(context);
 	try {
 		if (dbconfig.options.autoinstall_known_extensions) {
-			auto &config = DBConfig::GetConfig(context);
 			auto autoinstall_repo = ExtensionRepository::GetRepositoryByUrl(
-			    StringValue::Get(config.GetSetting<AutoinstallExtensionRepositorySetting>(context)));
+			    StringValue::Get(DBConfig::GetConfig(context).options.autoinstall_extension_repo));
 			ExtensionInstallOptions options;
 			options.repository = autoinstall_repo;
 			ExtensionHelper::InstallExtension(context, extension_name, options);
@@ -260,8 +260,6 @@ static ExtensionUpdateResult UpdateExtensionInternal(ClientContext &context, Dat
 	ExtensionUpdateResult result;
 	result.extension_name = extension_name;
 
-	auto &config = DBConfig::GetConfig(db);
-
 	if (!fs.FileExists(full_extension_path)) {
 		result.tag = ExtensionUpdateResultTag::NOT_INSTALLED;
 		return result;
@@ -277,7 +275,7 @@ static ExtensionUpdateResult UpdateExtensionInternal(ClientContext &context, Dat
 	// Parse the version of the extension before updating
 	auto ext_binary_handle = fs.OpenFile(full_extension_path, FileOpenFlags::FILE_FLAGS_READ);
 	auto parsed_metadata = ExtensionHelper::ParseExtensionMetaData(*ext_binary_handle);
-	if (!parsed_metadata.AppearsValid() && !config.options.allow_extensions_metadata_mismatch) {
+	if (!parsed_metadata.AppearsValid() && !DBConfig::GetSetting<AllowExtensionsMetadataMismatchSetting>(context)) {
 		throw IOException(
 		    "Failed to update extension: '%s', the metadata of the extension appears invalid! To resolve this, either "
 		    "reinstall the extension using 'FORCE INSTALL %s', manually remove the file '%s', or enable '"
@@ -433,23 +431,6 @@ ExtensionLoadResult ExtensionHelper::LoadExtension(DuckDB &db, const std::string
 
 ExtensionLoadResult ExtensionHelper::LoadExtensionInternal(DuckDB &db, const std::string &extension,
                                                            bool initial_load) {
-#ifdef DUCKDB_TEST_REMOTE_INSTALL
-	if (!initial_load && StringUtil::Contains(DUCKDB_TEST_REMOTE_INSTALL, extension)) {
-		Connection con(db);
-		auto result = con.Query("INSTALL " + extension);
-		if (result->HasError()) {
-			result->Print();
-			return ExtensionLoadResult::EXTENSION_UNKNOWN;
-		}
-		result = con.Query("LOAD " + extension);
-		if (result->HasError()) {
-			result->Print();
-			return ExtensionLoadResult::EXTENSION_UNKNOWN;
-		}
-		return ExtensionLoadResult::LOADED_EXTENSION;
-	}
-#endif
-
 #ifdef DUCKDB_EXTENSIONS_TEST_WITH_LOADABLE
 	// Note: weird comma's are on purpose to do easy string contains on a list of extension names
 	if (!initial_load && StringUtil::Contains(DUCKDB_EXTENSIONS_TEST_WITH_LOADABLE, "," + extension + ",")) {

package/src/duckdb/src/main/extension/extension_install.cpp

@@ -10,7 +10,7 @@
 #include "duckdb/main/extension_install_info.hpp"
 #include "duckdb/main/secret/secret.hpp"
 #include "duckdb/main/secret/secret_manager.hpp"
-
+#include "duckdb/main/settings.hpp"
 #include "duckdb/common/windows_undefs.hpp"
 
 #include <fstream>
@@ -52,7 +52,7 @@ string ExtensionHelper::ExtensionInstallDocumentationLink(const string &extensio
 	string link = "https://duckdb.org/docs/stable/extensions/troubleshooting";
 
 	if (components.size() >= 2) {
-		link += "/?version=" + components[0] + "&platform=" + components[1] + "&extension=" + extension_name;
+		link += "?version=" + components[0] + "&platform=" + components[1] + "&extension=" + extension_name;
 	}
 
 	return link;
@@ -165,11 +165,11 @@ unique_ptr<ExtensionInstallInfo> ExtensionHelper::InstallExtension(ClientContext
 	return InstallExtensionInternal(db, fs, local_path, extension, options, context);
 }
 
-unsafe_unique_array<data_t> ReadExtensionFileFromDisk(FileSystem &fs, const string &path, idx_t &file_size) {
+static unsafe_unique_array<data_t> ReadExtensionFileFromDisk(FileSystem &fs, const string &path, idx_t &file_size) {
 	auto source_file = fs.OpenFile(path, FileFlags::FILE_FLAGS_READ);
 	file_size = source_file->GetFileSize();
 	auto in_buffer = make_unsafe_uniq_array<data_t>(file_size);
-	source_file->Read(in_buffer.get(), file_size);
+	source_file->Read(QueryContext(), in_buffer.get(), file_size);
 	source_file->Close();
 	return in_buffer;
 }
@@ -224,7 +224,7 @@ static void CheckExtensionMetadataOnInstall(DatabaseInstance &db, void *in_buffe
 
 	auto metadata_mismatch_error = parsed_metadata.GetInvalidMetadataError();
 
-	if (!metadata_mismatch_error.empty() && !db.config.options.allow_extensions_metadata_mismatch) {
+	if (!metadata_mismatch_error.empty() && !DBConfig::GetSetting<AllowExtensionsMetadataMismatchSetting>(db)) {
 		throw IOException("Failed to install '%s'\n%s", extension_name, metadata_mismatch_error);
 	}
 
@@ -488,7 +488,7 @@ unique_ptr<ExtensionInstallInfo> ExtensionHelper::InstallExtensionInternal(Datab
 
 	if (fs.FileExists(local_extension_path) && !options.force_install) {
 		// File exists: throw error if origin mismatches
-		if (options.throw_on_origin_mismatch && !db.config.options.allow_extensions_metadata_mismatch &&
+		if (options.throw_on_origin_mismatch && !DBConfig::GetSetting<AllowExtensionsMetadataMismatchSetting>(db) &&
 		    fs.FileExists(local_extension_path + ".info")) {
 			ThrowErrorOnMismatchingExtensionOrigin(fs, local_extension_path, extension_name, extension,
 			                                       options.repository);

package/src/duckdb/src/main/extension/extension_load.cpp

@@ -7,6 +7,8 @@
 #include "duckdb/main/capi/extension_api.hpp"
 #include "duckdb/main/error_manager.hpp"
 #include "duckdb/main/extension_helper.hpp"
+#include "duckdb/main/extension_manager.hpp"
+#include "duckdb/main/settings.hpp"
 #include "mbedtls_wrapper.hpp"
 
 #ifndef DUCKDB_NO_THREADS
@@ -139,11 +141,9 @@ struct ExtensionAccess {
 //===--------------------------------------------------------------------===//
 #ifndef DUCKDB_DISABLE_EXTENSION_LOAD
 // The C++ init function
-typedef void (*ext_init_fun_t)(DatabaseInstance &);
+typedef void (*ext_init_fun_t)(ExtensionLoader &);
 // The C init function
 typedef bool (*ext_init_c_api_fun_t)(duckdb_extension_info info, duckdb_extension_access *access);
-typedef const char *(*ext_version_fun_t)(void);
-typedef bool (*ext_is_storage_t)(void);
 
 template <class T>
 static T LoadFunctionFromDLL(void *dll, const string &function_name, const string &filename) {
@@ -405,7 +405,7 @@ bool ExtensionHelper::TryInitialLoad(DatabaseInstance &db, FileSystem &fs, const
 		if (!signature_valid) {
 			throw IOException(db.config.error_manager->FormatException(ErrorType::UNSIGNED_EXTENSION, filename));
 		}
-	} else if (!db.config.options.allow_extensions_metadata_mismatch) {
+	} else if (!DBConfig::GetSetting<AllowExtensionsMetadataMismatchSetting>(db)) {
 		if (!metadata_mismatch_error.empty()) {
 			// Unsigned extensions AND configuration allowing n, loading allowed, mainly for
 			// debugging purposes
@@ -517,9 +517,22 @@ string ExtensionHelper::GetExtensionName(const string &original_name) {
 }
 
 void ExtensionHelper::LoadExternalExtension(DatabaseInstance &db, FileSystem &fs, const string &extension) {
-	if (db.ExtensionIsLoaded(extension)) {
+	auto &manager = ExtensionManager::Get(db);
+	auto info = manager.BeginLoad(extension);
+	if (!info) {
 		return;
 	}
+	try {
+		LoadExternalExtensionInternal(db, fs, extension, *info);
+	} catch (std::exception &ex) {
+		ErrorData error(ex);
+		info->LoadFail(error);
+		throw;
+	}
+}
+
+void ExtensionHelper::LoadExternalExtensionInternal(DatabaseInstance &db, FileSystem &fs, const string &extension,
+                                                    ExtensionActiveLoad &info) {
 #ifdef DUCKDB_DISABLE_EXTENSION_LOAD
 	throw PermissionException("Loading external extensions is disabled through a compile time flag");
 #else
@@ -527,7 +540,7 @@ void ExtensionHelper::LoadExternalExtension(DatabaseInstance &db, FileSystem &fs
 
 	// C++ ABI
 	if (extension_init_result.abi_type == ExtensionABIType::CPP) {
-		auto init_fun_name = extension_init_result.filebase + "_init";
+		auto init_fun_name = extension_init_result.filebase + "_duckdb_cpp_init";
 		ext_init_fun_t init_fun = TryLoadFunctionFromDLL<ext_init_fun_t>(extension_init_result.lib_hdl, init_fun_name,
 		                                                                 extension_init_result.filename);
 		if (!init_fun) {
@@ -536,7 +549,9 @@ void ExtensionHelper::LoadExternalExtension(DatabaseInstance &db, FileSystem &fs
 		}
 
 		try {
-			(*init_fun)(db);
+			ExtensionLoader loader(info);
+			(*init_fun)(loader);
+			loader.FinalizeLoad();
 		} catch (std::exception &e) {
 			ErrorData error(e);
 			throw InvalidInputException("Initialization function \"%s\" from file \"%s\" threw an exception: \"%s\"",
@@ -545,7 +560,7 @@ void ExtensionHelper::LoadExternalExtension(DatabaseInstance &db, FileSystem &fs
 
 		D_ASSERT(extension_init_result.install_info);
 
-		db.SetExtensionLoaded(extension, *extension_init_result.install_info);
+		info.FinishLoad(*extension_init_result.install_info);
 		return;
 	}
 
@@ -585,7 +600,7 @@ void ExtensionHelper::LoadExternalExtension(DatabaseInstance &db, FileSystem &fs
 
 		D_ASSERT(extension_init_result.install_info);
 
-		db.SetExtensionLoaded(extension, *extension_init_result.install_info);
+		info.FinishLoad(*extension_init_result.install_info);
 		return;
 	}
 

package/src/duckdb/src/main/extension/extension_loader.cpp

@@ -0,0 +1,234 @@
+#include "duckdb/main/extension/extension_loader.hpp"
+
+#include "duckdb/function/scalar_function.hpp"
+#include "duckdb/parser/parsed_data/create_aggregate_function_info.hpp"
+#include "duckdb/parser/parsed_data/create_type_info.hpp"
+#include "duckdb/parser/parsed_data/create_copy_function_info.hpp"
+#include "duckdb/parser/parsed_data/create_pragma_function_info.hpp"
+#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
+#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
+#include "duckdb/parser/parsed_data/create_macro_info.hpp"
+#include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
+#include "duckdb/parser/parsed_data/create_collation_info.hpp"
+#include "duckdb/main/extension_install_info.hpp"
+#include "duckdb/catalog/catalog.hpp"
+#include "duckdb/main/config.hpp"
+#include "duckdb/main/secret/secret_manager.hpp"
+#include "duckdb/main/database.hpp"
+
+namespace duckdb {
+
+ExtensionLoader::ExtensionLoader(ExtensionActiveLoad &load_info)
+    : db(load_info.db), extension_name(load_info.extension_name), extension_info(load_info.info) {
+}
+
+ExtensionLoader::ExtensionLoader(DatabaseInstance &db, const string &name) : db(db), extension_name(name) {
+}
+
+DatabaseInstance &ExtensionLoader::GetDatabaseInstance() {
+	return db;
+}
+
+void ExtensionLoader::SetDescription(const string &description) {
+	extension_description = description;
+}
+
+void ExtensionLoader::FinalizeLoad() {
+	// Set extension description, if provided
+	if (!extension_description.empty() && extension_info) {
+		auto info = make_uniq<ExtensionLoadedInfo>();
+		info->description = extension_description;
+		extension_info->load_info = std::move(info);
+	}
+}
+
+void ExtensionLoader::RegisterFunction(ScalarFunction function) {
+	ScalarFunctionSet set(function.name);
+	set.AddFunction(std::move(function));
+	RegisterFunction(std::move(set));
+}
+
+void ExtensionLoader::RegisterFunction(ScalarFunctionSet function) {
+	CreateScalarFunctionInfo info(std::move(function));
+	info.on_conflict = OnCreateConflict::ALTER_ON_CONFLICT;
+	RegisterFunction(std::move(info));
+}
+
+void ExtensionLoader::RegisterFunction(CreateScalarFunctionInfo function) {
+	D_ASSERT(!function.functions.name.empty());
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreateFunction(data, function);
+}
+
+void ExtensionLoader::RegisterFunction(AggregateFunction function) {
+	AggregateFunctionSet set(function.name);
+	set.AddFunction(std::move(function));
+	RegisterFunction(std::move(set));
+}
+
+void ExtensionLoader::RegisterFunction(AggregateFunctionSet function) {
+	CreateAggregateFunctionInfo info(std::move(function));
+	info.on_conflict = OnCreateConflict::ALTER_ON_CONFLICT;
+	RegisterFunction(std::move(info));
+}
+
+void ExtensionLoader::RegisterFunction(CreateAggregateFunctionInfo function) {
+	D_ASSERT(!function.functions.name.empty());
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreateFunction(data, function);
+}
+
+void ExtensionLoader::RegisterFunction(CreateSecretFunction function) {
+	D_ASSERT(!function.secret_type.empty());
+	auto &config = DBConfig::GetConfig(db);
+	config.secret_manager->RegisterSecretFunction(std::move(function), OnCreateConflict::ERROR_ON_CONFLICT);
+}
+
+void ExtensionLoader::RegisterFunction(TableFunction function) {
+	TableFunctionSet set(function.name);
+	set.AddFunction(std::move(function));
+	RegisterFunction(std::move(set));
+}
+
+void ExtensionLoader::RegisterFunction(TableFunctionSet function) {
+	D_ASSERT(!function.name.empty());
+	CreateTableFunctionInfo info(std::move(function));
+	info.on_conflict = OnCreateConflict::ALTER_ON_CONFLICT;
+	RegisterFunction(std::move(info));
+}
+
+void ExtensionLoader::RegisterFunction(CreateTableFunctionInfo info) {
+	D_ASSERT(!info.functions.name.empty());
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreateFunction(data, info);
+}
+
+void ExtensionLoader::RegisterFunction(PragmaFunction function) {
+	D_ASSERT(!function.name.empty());
+	PragmaFunctionSet set(function.name);
+	set.AddFunction(std::move(function));
+	RegisterFunction(std::move(set));
+}
+
+void ExtensionLoader::RegisterFunction(PragmaFunctionSet function) {
+	D_ASSERT(!function.name.empty());
+	auto function_name = function.name;
+	CreatePragmaFunctionInfo info(std::move(function_name), std::move(function));
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreatePragmaFunction(data, info);
+}
+
+void ExtensionLoader::RegisterFunction(CopyFunction function) {
+	CreateCopyFunctionInfo info(std::move(function));
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreateCopyFunction(data, info);
+}
+
+void ExtensionLoader::RegisterFunction(CreateMacroInfo &info) {
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreateFunction(data, info);
+}
+
+void ExtensionLoader::RegisterCollation(CreateCollationInfo &info) {
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	info.on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
+	system_catalog.CreateCollation(data, info);
+
+	// Also register as a function for serialisation
+	CreateScalarFunctionInfo finfo(info.function);
+	finfo.on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
+	system_catalog.CreateFunction(data, finfo);
+}
+
+void ExtensionLoader::AddFunctionOverload(ScalarFunction function) {
+	auto &scalar_function = GetFunction(function.name);
+	scalar_function.functions.AddFunction(std::move(function));
+}
+
+void ExtensionLoader::AddFunctionOverload(ScalarFunctionSet functions) { // NOLINT
+	D_ASSERT(!functions.name.empty());
+	auto &scalar_function = GetFunction(functions.name);
+	for (auto &function : functions.functions) {
+		function.name = functions.name;
+		scalar_function.functions.AddFunction(std::move(function));
+	}
+}
+
+void ExtensionLoader::AddFunctionOverload(TableFunctionSet functions) { // NOLINT
+	auto &table_function = GetTableFunction(functions.name);
+	for (auto &function : functions.functions) {
+		function.name = functions.name;
+		table_function.functions.AddFunction(std::move(function));
+	}
+}
+
+static optional_ptr<CatalogEntry> TryGetEntry(DatabaseInstance &db, const string &name, CatalogType type) {
+	D_ASSERT(!name.empty());
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	auto &schema = system_catalog.GetSchema(data, DEFAULT_SCHEMA);
+	return schema.GetEntry(data, type, name);
+}
+
+optional_ptr<CatalogEntry> ExtensionLoader::TryGetFunction(const string &name) {
+	return TryGetEntry(db, name, CatalogType::SCALAR_FUNCTION_ENTRY);
+}
+
+ScalarFunctionCatalogEntry &ExtensionLoader::GetFunction(const string &name) {
+	auto catalog_entry = TryGetFunction(name);
+	if (!catalog_entry) {
+		throw InvalidInputException("Function with name \"%s\" not found in ExtensionLoader::GetFunction", name);
+	}
+	return catalog_entry->Cast<ScalarFunctionCatalogEntry>();
+}
+
+optional_ptr<CatalogEntry> ExtensionLoader::TryGetTableFunction(const string &name) {
+	return TryGetEntry(db, name, CatalogType::TABLE_FUNCTION_ENTRY);
+}
+
+TableFunctionCatalogEntry &ExtensionLoader::GetTableFunction(const string &name) {
+	auto catalog_entry = TryGetTableFunction(name);
+	if (!catalog_entry) {
+		throw InvalidInputException("Function with name \"%s\" not found in ExtensionLoader::GetTableFunction", name);
+	}
+	return catalog_entry->Cast<TableFunctionCatalogEntry>();
+}
+
+void ExtensionLoader::RegisterType(string type_name, LogicalType type, bind_logical_type_function_t bind_modifiers) {
+	D_ASSERT(!type_name.empty());
+	CreateTypeInfo info(std::move(type_name), std::move(type), bind_modifiers);
+	info.temporary = true;
+	info.internal = true;
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreateType(data, info);
+}
+
+void ExtensionLoader::RegisterSecretType(SecretType secret_type) {
+	auto &config = DBConfig::GetConfig(db);
+	config.secret_manager->RegisterSecretType(secret_type);
+}
+
+void ExtensionLoader::RegisterCastFunction(const LogicalType &source, const LogicalType &target,
+                                           bind_cast_function_t bind_function, int64_t implicit_cast_cost) {
+	auto &config = DBConfig::GetConfig(db);
+	auto &casts = config.GetCastFunctions();
+	casts.RegisterCastFunction(source, target, bind_function, implicit_cast_cost);
+}
+
+void ExtensionLoader::RegisterCastFunction(const LogicalType &source, const LogicalType &target, BoundCastInfo function,
+                                           int64_t implicit_cast_cost) {
+	auto &config = DBConfig::GetConfig(db);
+	auto &casts = config.GetCastFunctions();
+	casts.RegisterCastFunction(source, target, std::move(function), implicit_cast_cost);
+}
+
+} // namespace duckdb