duckdb 1.1.4-dev2.0 → 1.1.4-dev9.0

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

@@ -32,6 +32,9 @@ optional_ptr<AttachedDatabase> DatabaseManager::GetDatabase(ClientContext &conte
 	if (StringUtil::Lower(name) == TEMP_CATALOG) {
 		return context.client_data->temporary_objects.get();
 	}
+	if (StringUtil::Lower(name) == SYSTEM_CATALOG) {
+		return system;
+	}
 	return reinterpret_cast<AttachedDatabase *>(databases->GetEntry(context, name).get());
 }
 
@@ -134,17 +137,21 @@ void DatabaseManager::EraseDatabasePath(const string &path) {
 	}
 }
 
+vector<string> DatabaseManager::GetAttachedDatabasePaths() {
+	lock_guard<mutex> path_lock(db_paths_lock);
+	vector<string> paths;
+	for (auto &path : db_paths) {
+		paths.push_back(path);
+	}
+	return paths;
+}
+
 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")) {
 		options.db_type = "";
-
-		// The DuckDB format does not allow unrecognized options.
-		if (!options.unrecognized_option.empty()) {
-			throw BinderException("Unrecognized option for attach \"%s\"", options.unrecognized_option);
-		}
 		return;
 	}
 
@@ -166,12 +173,6 @@ void DatabaseManager::GetDatabaseType(ClientContext &context, AttachInfo &info,
 		}
 		return;
 	}
-
-	// The DuckDB file format does not allow unrecognized options, except for the block_size option,
-	// which is specific to DuckDB files.
-	if (!options.unrecognized_option.empty() && options.unrecognized_option != "block_size") {
-		throw BinderException("Unrecognized option for attach \"%s\"", options.unrecognized_option);
-	}
 }
 
 const string &DatabaseManager::GetDefaultDatabase(ClientContext &context) {

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

@@ -3,6 +3,9 @@
 
 namespace duckdb {
 
+DatabaseCacheEntry::DatabaseCacheEntry() {
+}
+
 DatabaseCacheEntry::DatabaseCacheEntry(const shared_ptr<DuckDB> &database_p) : database(database_p) {
 }
 
@@ -91,18 +94,22 @@ shared_ptr<DuckDB> DBInstanceCache::CreateInstanceInternal(const string &databas
 	if (abs_database_path.rfind(IN_MEMORY_PATH, 0) == 0) {
 		instance_path = IN_MEMORY_PATH;
 	}
-	auto db_instance = make_shared_ptr<DuckDB>(instance_path, &config);
-	if (on_create) {
-		on_create(*db_instance);
-	}
+	shared_ptr<DatabaseCacheEntry> cache_entry;
 	if (cache_instance) {
-		// create the cache entry and attach it to the database
-		auto cache_entry = make_shared_ptr<DatabaseCacheEntry>(db_instance);
-		db_instance->instance->SetDatabaseCacheEntry(cache_entry);
+		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
 		db_instances[abs_database_path] = cache_entry;
 	}
+	if (on_create) {
+		on_create(*db_instance);
+	}
 	return db_instance;
 }
 

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

@@ -12,6 +12,10 @@
 
 // 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
+#ifndef DUCKDB_EXTENSION_CORE_FUNCTIONS_LINKED
+#define DUCKDB_EXTENSION_CORE_FUNCTIONS_LINKED false
+#endif
+
 #ifndef DUCKDB_EXTENSION_ICU_LINKED
 #define DUCKDB_EXTENSION_ICU_LINKED false
 #endif
@@ -32,10 +36,6 @@
 #define DUCKDB_EXTENSION_TPCDS_LINKED false
 #endif
 
-#ifndef DUCKDB_EXTENSION_FTS_LINKED
-#define DUCKDB_EXTENSION_FTS_LINKED false
-#endif
-
 #ifndef DUCKDB_EXTENSION_HTTPFS_LINKED
 #define DUCKDB_EXTENSION_HTTPFS_LINKED false
 #endif
@@ -58,6 +58,10 @@
 #else
 // TODO: rewrite package_build.py to allow also loading out-of-tree extensions in non-cmake builds, after that
 //		 these can be removed
+#if DUCKDB_EXTENSION_CORE_FUNCTIONS_LINKED
+#include "core_functions_extension.hpp"
+#endif
+
 #if DUCKDB_EXTENSION_ICU_LINKED
 #include "icu_extension.hpp"
 #endif
@@ -74,14 +78,6 @@
 #include "tpcds_extension.hpp"
 #endif
 
-#if DUCKDB_EXTENSION_FTS_LINKED
-#include "fts_extension.hpp"
-#endif
-
-#if DUCKDB_EXTENSION_HTTPFS_LINKED
-#include "httpfs_extension.hpp"
-#endif
-
 #if DUCKDB_EXTENSION_JSON_LINKED
 #include "json_extension.hpp"
 #endif
@@ -93,6 +89,7 @@
 #if DUCKDB_EXTENSION_AUTOCOMPLETE_LINKED
 #include "autocomplete_extension.hpp"
 #endif
+
 #endif
 
 namespace duckdb {
@@ -101,12 +98,12 @@ namespace duckdb {
 // Default Extensions
 //===--------------------------------------------------------------------===//
 static const DefaultExtension internal_extensions[] = {
+    {"core_functions", "Core function library", DUCKDB_EXTENSION_CORE_FUNCTIONS_LINKED},
     {"icu", "Adds support for time zones and collations using the ICU library", DUCKDB_EXTENSION_ICU_LINKED},
     {"excel", "Adds support for Excel-like format strings", DUCKDB_EXTENSION_EXCEL_LINKED},
     {"parquet", "Adds support for reading and writing parquet files", DUCKDB_EXTENSION_PARQUET_LINKED},
     {"tpch", "Adds TPC-H data generation and query support", DUCKDB_EXTENSION_TPCH_LINKED},
     {"tpcds", "Adds TPC-DS data generation and query support", DUCKDB_EXTENSION_TPCDS_LINKED},
-    {"fts", "Adds support for Full-Text Search Indexes", DUCKDB_EXTENSION_FTS_LINKED},
     {"httpfs", "Adds support for reading and writing files over a HTTP(S) connection", DUCKDB_EXTENSION_HTTPFS_LINKED},
     {"json", "Adds support for JSON operations", DUCKDB_EXTENSION_JSON_LINKED},
     {"jemalloc", "Overwrites system allocator with JEMalloc", DUCKDB_EXTENSION_JEMALLOC_LINKED},
@@ -124,6 +121,7 @@ static const DefaultExtension internal_extensions[] = {
     {"iceberg", "Adds support for Apache Iceberg", false},
     {"vss", "Adds indexing support to accelerate Vector Similarity Search", false},
     {"delta", "Adds support for Delta Lake", false},
+    {"fts", "Adds support for Full-Text Search Indexes", false},
     {nullptr, nullptr, false}};
 
 idx_t ExtensionHelper::DefaultExtensionCount() {
@@ -212,7 +210,8 @@ bool ExtensionHelper::TryAutoLoadExtension(ClientContext &context, const string
 	try {
 		if (dbconfig.options.autoinstall_known_extensions) {
 			auto &config = DBConfig::GetConfig(context);
-			auto autoinstall_repo = ExtensionRepository::GetRepositoryByUrl(config.options.autoinstall_extension_repo);
+			auto autoinstall_repo = ExtensionRepository::GetRepositoryByUrl(
+			    StringValue::Get(config.GetSetting<AutoinstallExtensionRepositorySetting>(context)));
 			ExtensionInstallOptions options;
 			options.repository = autoinstall_repo;
 			ExtensionHelper::InstallExtension(context, extension_name, options);
@@ -390,6 +389,8 @@ void ExtensionHelper::AutoLoadExtension(DatabaseInstance &db, const string &exte
 		}
 #endif
 		ExtensionHelper::LoadExternalExtension(db, *fs, extension_name);
+		Logger::Info("duckdb.Extensions.ExtensionAutoloaded", db, extension_name);
+
 	} catch (std::exception &e) {
 		ErrorData error(e);
 		throw AutoloadException(extension_name, error.RawMessage());
@@ -403,8 +404,8 @@ void ExtensionHelper::LoadAllExtensions(DuckDB &db) {
 	// The in-tree extensions that we check. Non-cmake builds are currently limited to these for static linking
 	// TODO: rewrite package_build.py to allow also loading out-of-tree extensions in non-cmake builds, after that
 	//		 these can be removed
-	unordered_set<string> extensions {"parquet", "icu",   "tpch", "tpcds",    "fts",         "httpfs",
-	                                  "json",    "excel", "inet", "jemalloc", "autocomplete"};
+	vector<string> extensions {"parquet", "icu",  "tpch",     "tpcds",        "httpfs",        "json",
+	                           "excel",   "inet", "jemalloc", "autocomplete", "core_functions"};
 	for (auto &ext : extensions) {
 		LoadExtensionInternal(db, ext, true);
 	}
@@ -491,13 +492,6 @@ ExtensionLoadResult ExtensionHelper::LoadExtensionInternal(DuckDB &db, const std
 #else
 		// icu extension required but not build: skip this test
 		return ExtensionLoadResult::NOT_LOADED;
-#endif
-	} else if (extension == "fts") {
-#if DUCKDB_EXTENSION_FTS_LINKED
-//		db.LoadStaticExtension<FtsExtension>();
-#else
-		// fts extension required but not build: skip this test
-		return ExtensionLoadResult::NOT_LOADED;
 #endif
 	} else if (extension == "httpfs") {
 #if DUCKDB_EXTENSION_HTTPFS_LINKED
@@ -539,6 +533,13 @@ ExtensionLoadResult ExtensionHelper::LoadExtensionInternal(DuckDB &db, const std
 #else
 		// inet extension required but not build: skip this test
 		return ExtensionLoadResult::NOT_LOADED;
+#endif
+	} else if (extension == "core_functions") {
+#if DUCKDB_EXTENSION_CORE_FUNCTIONS_LINKED
+		db.LoadStaticExtension<CoreFunctionsExtension>();
+#else
+		// core_functions extension required but not build: skip this test
+		return ExtensionLoadResult::NOT_LOADED;
 #endif
 	}
 

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

@@ -70,10 +70,13 @@ duckdb::string ExtensionHelper::DefaultExtensionFolder(FileSystem &fs) {
 	return res;
 }
 
-string ExtensionHelper::ExtensionDirectory(DatabaseInstance &db, FileSystem &fs) {
-#ifdef WASM_LOADABLE_EXTENSIONS
-	throw PermissionException("ExtensionDirectory functionality is not supported in duckdb-wasm");
-#endif
+string ExtensionHelper::GetExtensionDirectoryPath(ClientContext &context) {
+	auto &db = DatabaseInstance::GetDatabase(context);
+	auto &fs = FileSystem::GetFileSystem(context);
+	return GetExtensionDirectoryPath(db, fs);
+}
+
+string ExtensionHelper::GetExtensionDirectoryPath(DatabaseInstance &db, FileSystem &fs) {
 	string extension_directory;
 	auto &config = db.config;
 	if (!config.options.extension_directory.empty()) { // create the extension directory if not present
@@ -83,10 +86,19 @@ string ExtensionHelper::ExtensionDirectory(DatabaseInstance &db, FileSystem &fs)
 	} else { // otherwise default to home
 		extension_directory = DefaultExtensionFolder(fs);
 	}
+
+	extension_directory = fs.ConvertSeparators(extension_directory);
+	// expand ~ in extension directory
+	extension_directory = fs.ExpandPath(extension_directory);
+	return extension_directory;
+}
+
+string ExtensionHelper::ExtensionDirectory(DatabaseInstance &db, FileSystem &fs) {
+#ifdef WASM_LOADABLE_EXTENSIONS
+	throw PermissionException("ExtensionDirectory functionality is not supported in duckdb-wasm");
+#endif
+	string extension_directory = GetExtensionDirectoryPath(db, fs);
 	{
-		extension_directory = fs.ConvertSeparators(extension_directory);
-		// expand ~ in extension directory
-		extension_directory = fs.ExpandPath(extension_directory);
 		if (!fs.DirectoryExists(extension_directory)) {
 			auto sep = fs.PathSeparator(extension_directory);
 			auto splits = StringUtil::Split(extension_directory, sep);

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

@@ -25,7 +25,8 @@ namespace duckdb {
 
 //! State that is kept during the load phase of a C API extension
 struct DuckDBExtensionLoadState {
-	explicit DuckDBExtensionLoadState(DatabaseInstance &db_p) : db(db_p), database_data(nullptr) {
+	explicit DuckDBExtensionLoadState(DatabaseInstance &db_p, ExtensionInitResult &init_result_p)
+	    : db(db_p), init_result(init_result_p), database_data(nullptr) {
 	}
 
 	//! Create a DuckDBExtensionLoadState reference from a C API opaque pointer
@@ -42,13 +43,16 @@ struct DuckDBExtensionLoadState {
 	//! Ref to the database being loaded
 	DatabaseInstance &db;
 
+	//! The init result from initializing the extension
+	ExtensionInitResult &init_result;
+
 	//! This is the duckdb_database struct that will be passed to the extension during initialization. Note that the
 	//! extension does not need to free it.
-	unique_ptr<DatabaseData> database_data;
+	unique_ptr<DatabaseWrapper> database_data;
 
 	//! The function pointer struct passed to the extension. The extension is expected to copy this struct during
 	//! initialization
-	duckdb_ext_api_v0 api_struct;
+	duckdb_ext_api_v1 api_struct;
 
 	//! Error handling
 	bool has_error = false;
@@ -67,8 +71,15 @@ struct ExtensionAccess {
 	static void SetError(duckdb_extension_info info, const char *error) {
 		auto &load_state = DuckDBExtensionLoadState::Get(info);
 
-		load_state.has_error = true;
-		load_state.error_data = ErrorData(ExceptionType::UNKNOWN_TYPE, error);
+		if (error) {
+			load_state.has_error = true;
+			load_state.error_data = ErrorData(error);
+		} else {
+			load_state.has_error = true;
+			load_state.error_data = ErrorData(
+			    ExceptionType::UNKNOWN_TYPE,
+			    "Extension has indicated an error occured during initialization, but did not set an error message.");
+		}
 	}
 
 	//! Called by the extension get a pointer to the database that is loading it
@@ -77,8 +88,8 @@ struct ExtensionAccess {
 
 		try {
 			// Create the duckdb_database
-			load_state.database_data = make_uniq<DatabaseData>();
-			load_state.database_data->database = make_uniq<DuckDB>(load_state.db);
+			load_state.database_data = make_uniq<DatabaseWrapper>();
+			load_state.database_data->database = make_shared_ptr<DuckDB>(load_state.db);
 			return reinterpret_cast<duckdb_database *>(load_state.database_data.get());
 		} catch (std::exception &ex) {
 			load_state.error_data = ErrorData(ex);
@@ -92,22 +103,34 @@ struct ExtensionAccess {
 
 	//! Called by the extension get a pointer the correctly versioned extension C API struct.
 	static const void *GetAPI(duckdb_extension_info info, const char *version) {
-
 		string version_string = version;
-		idx_t major, minor, patch;
-		auto parsed = VersioningUtils::ParseSemver(version_string, major, minor, patch);
-
 		auto &load_state = DuckDBExtensionLoadState::Get(info);
 
-		if (!parsed || !VersioningUtils::IsSupportedCAPIVersion(major, minor, patch)) {
+		if (load_state.init_result.abi_type == ExtensionABIType::C_STRUCT) {
+			idx_t major, minor, patch;
+			auto parsed = VersioningUtils::ParseSemver(version_string, major, minor, patch);
+
+			if (!parsed || !VersioningUtils::IsSupportedCAPIVersion(major, minor, patch)) {
+				load_state.has_error = true;
+				load_state.error_data = ErrorData(
+				    ExceptionType::UNKNOWN_TYPE,
+				    "Unsupported C CAPI version detected during extension initialization: " + string(version));
+				return nullptr;
+			}
+		} else if (load_state.init_result.abi_type == ExtensionABIType::C_STRUCT_UNSTABLE) {
+			// NOTE: we currently don't check anything here: the version of extensions of ABI type C_STRUCT_UNSTABLE is
+			// ignored because C_STRUCT_UNSTABLE extensions are tied 1:1 to duckdb verions meaning they will always
+			// receive the whole function pointer struct
+		} else {
 			load_state.has_error = true;
 			load_state.error_data =
 			    ErrorData(ExceptionType::UNKNOWN_TYPE,
-			              "Unsupported C CAPI version detected during extension initialization: " + string(version));
+			              StringUtil::Format("Unknown ABI Type '%s' found when loading extension '%s'",
+			                                 load_state.init_result.abi_type, load_state.init_result.filename));
 			return nullptr;
 		}
 
-		load_state.api_struct = load_state.db.GetExtensionAPIV0();
+		load_state.api_struct = load_state.db.GetExtensionAPIV1();
 		return &load_state.api_struct;
 	}
 };
@@ -119,7 +142,7 @@ struct ExtensionAccess {
 // The C++ init function
 typedef void (*ext_init_fun_t)(DatabaseInstance &);
 // The C init function
-typedef void (*ext_init_c_api_fun_t)(duckdb_extension_info info, duckdb_extension_access *access);
+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);
 
@@ -200,6 +223,9 @@ ParsedExtensionMetaData ExtensionHelper::ParseExtensionMetaData(const char *meta
 	if (extension_abi_metadata == "C_STRUCT") {
 		result.abi_type = ExtensionABIType::C_STRUCT;
 		result.duckdb_capi_version = FilterZeroAtEnd(metadata_field[2]);
+	} else if (extension_abi_metadata == "C_STRUCT_UNSTABLE") {
+		result.abi_type = ExtensionABIType::C_STRUCT_UNSTABLE;
+		result.duckdb_version = FilterZeroAtEnd(metadata_field[2]);
 	} else if (extension_abi_metadata == "CPP" || extension_abi_metadata.empty()) {
 		result.abi_type = ExtensionABIType::CPP;
 		result.duckdb_version = FilterZeroAtEnd(metadata_field[2]);
@@ -425,6 +451,7 @@ bool ExtensionHelper::TryInitialLoad(DatabaseInstance &db, FileSystem &fs, const
 	result.filebase = lowercase_extension_name;
 	result.filename = filename;
 	result.lib_hdl = lib_hdl;
+	result.abi_type = parsed_metadata.abi_type;
 
 	if (!direct_load) {
 		auto info_file_name = filename + ".info";
@@ -498,50 +525,73 @@ void ExtensionHelper::LoadExternalExtension(DatabaseInstance &db, FileSystem &fs
 #ifdef DUCKDB_DISABLE_EXTENSION_LOAD
 	throw PermissionException("Loading external extensions is disabled through a compile time flag");
 #else
-	auto res = InitialLoad(db, fs, extension);
-	auto init_fun_name = res.filebase + "_init";
+	auto extension_init_result = InitialLoad(db, fs, extension);
+
+	// C++ ABI
+	if (extension_init_result.abi_type == ExtensionABIType::CPP) {
+		auto init_fun_name = extension_init_result.filebase + "_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) {
+			throw IOException("Extension '%s' did not contain the expected entrypoint function '%s'", extension,
+			                  init_fun_name);
+		}
 
-	// "OLD WAY" of loading extensions. If the <ext_name>_init exists, we choose that
-	ext_init_fun_t init_fun = TryLoadFunctionFromDLL<ext_init_fun_t>(res.lib_hdl, init_fun_name, res.filename);
-	if (init_fun) {
 		try {
 			(*init_fun)(db);
 		} catch (std::exception &e) {
 			ErrorData error(e);
 			throw InvalidInputException("Initialization function \"%s\" from file \"%s\" threw an exception: \"%s\"",
-			                            init_fun_name, res.filename, error.RawMessage());
+			                            init_fun_name, extension_init_result.filename, error.RawMessage());
 		}
 
-		D_ASSERT(res.install_info);
+		D_ASSERT(extension_init_result.install_info);
 
-		db.SetExtensionLoaded(extension, *res.install_info);
+		db.SetExtensionLoaded(extension, *extension_init_result.install_info);
 		return;
 	}
 
-	// TODO: make this the only way of calling extensions?
-	// "NEW WAY" of loading extensions enabling C API only
-	init_fun_name = res.filebase + "_init_c_api";
-	ext_init_c_api_fun_t init_fun_capi =
-	    TryLoadFunctionFromDLL<ext_init_c_api_fun_t>(res.lib_hdl, init_fun_name, res.filename);
+	// C ABI
+	if (extension_init_result.abi_type == ExtensionABIType::C_STRUCT ||
+	    extension_init_result.abi_type == ExtensionABIType::C_STRUCT_UNSTABLE) {
+		auto init_fun_name = extension_init_result.filebase + "_init_c_api";
+		ext_init_c_api_fun_t init_fun_capi = TryLoadFunctionFromDLL<ext_init_c_api_fun_t>(
+		    extension_init_result.lib_hdl, init_fun_name, extension_init_result.filename);
 
-	if (!init_fun_capi) {
-		throw IOException("File \"%s\" did not contain function \"%s\": %s", res.filename, init_fun_name, GetDLError());
-	}
+		if (!init_fun_capi) {
+			throw IOException("File \"%s\" did not contain function \"%s\": %s", extension_init_result.filename,
+			                  init_fun_name, GetDLError());
+		}
+		// Create the load state
+		DuckDBExtensionLoadState load_state(db, extension_init_result);
 
-	// Create the load state
-	DuckDBExtensionLoadState load_state(db);
+		auto access = ExtensionAccess::CreateAccessStruct();
+		auto result = (*init_fun_capi)(load_state.ToCStruct(), &access);
 
-	auto access = ExtensionAccess::CreateAccessStruct();
-	(*init_fun_capi)(load_state.ToCStruct(), &access);
+		// Throw any error that the extension might have encountered
+		if (load_state.has_error) {
+			load_state.error_data.Throw("An error was thrown during initialization of the extension '" + extension +
+			                            "': ");
+		}
 
-	// Throw any error that the extension might have encountered
-	if (load_state.has_error) {
-		load_state.error_data.Throw("An error was thrown during initialization of the extension '" + extension + "': ");
-	}
+		// Extensions are expected to either set an error or return true indicating successful initialization
+		if (result == false) {
+			throw FatalException(
+			    "Extension '%s' failed to initialize but did not return an error. This indicates an "
+			    "error in the extension: C API extensions should return a boolean `true` to indicate succesful "
+			    "initialization. "
+			    "This means that the Extension may be partially initialized resulting in an inconsistent state of "
+			    "DuckDB.",
+			    extension);
+		}
+
+		D_ASSERT(extension_init_result.install_info);
 
-	D_ASSERT(res.install_info);
+		db.SetExtensionLoaded(extension, *extension_init_result.install_info);
+		return;
+	}
 
-	db.SetExtensionLoaded(extension, *res.install_info);
+	throw IOException("Unknown ABI type '%s' for extension '%s'", extension_init_result.abi_type, extension);
 #endif
 }
 

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

@@ -24,31 +24,39 @@ void ExtensionUtil::RegisterExtension(DatabaseInstance &db, const string &name,
 	db.AddExtensionInfo(name, description);
 }
 
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, ScalarFunction function) {
+	ScalarFunctionSet set(function.name);
+	set.AddFunction(std::move(function));
+	RegisterFunction(db, std::move(set));
+}
+
 void ExtensionUtil::RegisterFunction(DatabaseInstance &db, ScalarFunctionSet set) {
-	D_ASSERT(!set.name.empty());
 	CreateScalarFunctionInfo info(std::move(set));
+	info.on_conflict = OnCreateConflict::ALTER_ON_CONFLICT;
+	RegisterFunction(db, std::move(info));
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, CreateScalarFunctionInfo info) {
+	D_ASSERT(!info.functions.name.empty());
 	auto &system_catalog = Catalog::GetSystemCatalog(db);
 	auto data = CatalogTransaction::GetSystemTransaction(db);
 	system_catalog.CreateFunction(data, info);
 }
 
-void ExtensionUtil::RegisterFunction(DatabaseInstance &db, ScalarFunction function) {
-	D_ASSERT(!function.name.empty());
-	ScalarFunctionSet set(function.name);
-	set.AddFunction(std::move(function));
-	RegisterFunction(db, std::move(set));
-}
-
 void ExtensionUtil::RegisterFunction(DatabaseInstance &db, AggregateFunction function) {
-	D_ASSERT(!function.name.empty());
 	AggregateFunctionSet set(function.name);
 	set.AddFunction(std::move(function));
 	RegisterFunction(db, std::move(set));
 }
 
 void ExtensionUtil::RegisterFunction(DatabaseInstance &db, AggregateFunctionSet set) {
-	D_ASSERT(!set.name.empty());
 	CreateAggregateFunctionInfo info(std::move(set));
+	info.on_conflict = OnCreateConflict::ALTER_ON_CONFLICT;
+	RegisterFunction(db, std::move(info));
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, CreateAggregateFunctionInfo info) {
+	D_ASSERT(!info.functions.name.empty());
 	auto &system_catalog = Catalog::GetSystemCatalog(db);
 	auto data = CatalogTransaction::GetSystemTransaction(db);
 	system_catalog.CreateFunction(data, info);
@@ -61,7 +69,6 @@ void ExtensionUtil::RegisterFunction(DatabaseInstance &db, CreateSecretFunction
 }
 
 void ExtensionUtil::RegisterFunction(DatabaseInstance &db, TableFunction function) {
-	D_ASSERT(!function.name.empty());
 	TableFunctionSet set(function.name);
 	set.AddFunction(std::move(function));
 	RegisterFunction(db, std::move(set));
@@ -70,6 +77,12 @@ void ExtensionUtil::RegisterFunction(DatabaseInstance &db, TableFunction functio
 void ExtensionUtil::RegisterFunction(DatabaseInstance &db, TableFunctionSet function) {
 	D_ASSERT(!function.name.empty());
 	CreateTableFunctionInfo info(std::move(function));
+	info.on_conflict = OnCreateConflict::ALTER_ON_CONFLICT;
+	RegisterFunction(db, std::move(info));
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, CreateTableFunctionInfo info) {
+	D_ASSERT(!info.functions.name.empty());
 	auto &system_catalog = Catalog::GetSystemCatalog(db);
 	auto data = CatalogTransaction::GetSystemTransaction(db);
 	system_catalog.CreateFunction(data, info);
@@ -138,24 +151,32 @@ void ExtensionUtil::AddFunctionOverload(DatabaseInstance &db, TableFunctionSet f
 	}
 }
 
-ScalarFunctionCatalogEntry &ExtensionUtil::GetFunction(DatabaseInstance &db, const string &name) {
+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);
-	auto catalog_entry = schema.GetEntry(data, CatalogType::SCALAR_FUNCTION_ENTRY, name);
+	return schema.GetEntry(data, type, name);
+}
+
+optional_ptr<CatalogEntry> ExtensionUtil::TryGetFunction(DatabaseInstance &db, const string &name) {
+	return TryGetEntry(db, name, CatalogType::SCALAR_FUNCTION_ENTRY);
+}
+
+ScalarFunctionCatalogEntry &ExtensionUtil::GetFunction(DatabaseInstance &db, const string &name) {
+	auto catalog_entry = TryGetFunction(db, name);
 	if (!catalog_entry) {
 		throw InvalidInputException("Function with name \"%s\" not found in ExtensionUtil::GetFunction", name);
 	}
 	return catalog_entry->Cast<ScalarFunctionCatalogEntry>();
 }
 
+optional_ptr<CatalogEntry> ExtensionUtil::TryGetTableFunction(DatabaseInstance &db, const string &name) {
+	return TryGetEntry(db, name, CatalogType::TABLE_FUNCTION_ENTRY);
+}
+
 TableFunctionCatalogEntry &ExtensionUtil::GetTableFunction(DatabaseInstance &db, const string &name) {
-	D_ASSERT(!name.empty());
-	auto &system_catalog = Catalog::GetSystemCatalog(db);
-	auto data = CatalogTransaction::GetSystemTransaction(db);
-	auto &schema = system_catalog.GetSchema(data, DEFAULT_SCHEMA);
-	auto catalog_entry = schema.GetEntry(data, CatalogType::TABLE_FUNCTION_ENTRY, name);
+	auto catalog_entry = TryGetTableFunction(db, name);
 	if (!catalog_entry) {
 		throw InvalidInputException("Function with name \"%s\" not found in ExtensionUtil::GetTableFunction", name);
 	}
@@ -163,7 +184,7 @@ TableFunctionCatalogEntry &ExtensionUtil::GetTableFunction(DatabaseInstance &db,
 }
 
 void ExtensionUtil::RegisterType(DatabaseInstance &db, string type_name, LogicalType type,
-                                 bind_type_modifiers_function_t bind_modifiers) {
+                                 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;

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

@@ -1,8 +1,9 @@
 #include "duckdb/main/extension.hpp"
+
+#include "duckdb/common/operator/cast_operators.hpp"
 #include "duckdb/common/string_util.hpp"
-#include "duckdb/main/extension_helper.hpp"
 #include "duckdb/main/capi/extension_api.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
+#include "duckdb/main/extension_helper.hpp"
 
 namespace duckdb {
 
@@ -44,7 +45,8 @@ string ParsedExtensionMetaData::GetInvalidMetadataError() {
 
 	string result;
 
-	if (abi_type == ExtensionABIType::CPP) {
+	// CPP or C_STRUCT_UNSTABLE ABI versioning needs to match the DuckDB version exactly
+	if (abi_type == ExtensionABIType::CPP || abi_type == ExtensionABIType::C_STRUCT_UNSTABLE) {
 		const string engine_version = string(ExtensionHelper::GetVersionDirectoryName());
 
 		if (engine_version != duckdb_version) {
@@ -52,14 +54,14 @@ string ParsedExtensionMetaData::GetInvalidMetadataError() {
 			                             "built for DuckDB version '%s'.",
 			                             PrettyPrintString(duckdb_version), engine_version);
 		}
+		// C_STRUCT ABI versioning works when current duckdb version >= required version
 	} else if (abi_type == ExtensionABIType::C_STRUCT) {
 
 		if (!VersioningUtils::IsSupportedCAPIVersion(duckdb_capi_version)) {
-			result +=
-			    StringUtil::Format("The file was built for DuckDB C API version '%s', but we can only load extensions "
-			                       "built for DuckDB C API 'v%lld.%lld.%lld' and lower.",
-			                       duckdb_capi_version, DUCKDB_EXTENSION_API_VERSION_MAJOR,
-			                       DUCKDB_EXTENSION_API_VERSION_MINOR, DUCKDB_EXTENSION_API_VERSION_PATCH);
+			result += StringUtil::Format("The file was built for DuckDB version '%s', but we can only load extensions "
+			                             "built for DuckDB C API 'v%lld.%lld.%lld' and lower.",
+			                             duckdb_capi_version, DUCKDB_EXTENSION_API_VERSION_MAJOR,
+			                             DUCKDB_EXTENSION_API_VERSION_MINOR, DUCKDB_EXTENSION_API_VERSION_PATCH);
 		}
 	} else {
 		throw InternalException("Unknown ABI type for extension: " + extension_abi_metadata);
@@ -89,11 +91,18 @@ bool VersioningUtils::IsSupportedCAPIVersion(string &capi_version_string) {
 }
 
 bool VersioningUtils::IsSupportedCAPIVersion(idx_t major, idx_t minor, idx_t patch) {
-	if (major > DUCKDB_EXTENSION_API_VERSION_MAJOR || minor > DUCKDB_EXTENSION_API_VERSION_MINOR ||
-	    patch > DUCKDB_EXTENSION_API_VERSION_PATCH) {
+	if (major != DUCKDB_EXTENSION_API_VERSION_MAJOR) {
+		return false;
+	}
+	if (minor > DUCKDB_EXTENSION_API_VERSION_MINOR) {
+		return false;
+	}
+	if (minor < DUCKDB_EXTENSION_API_VERSION_MINOR) {
+		return true;
+	}
+	if (patch > DUCKDB_EXTENSION_API_VERSION_PATCH) {
 		return false;
 	}
-
 	return true;
 }