duckdb 1.3.4 → 1.4.1-dev2.0

package/src/duckdb/src/include/duckdb/main/database_manager.hpp

@@ -17,6 +17,7 @@
 #include "duckdb/common/optional_ptr.hpp"
 #include "duckdb/main/config.hpp"
 #include "duckdb/parser/parsed_data/attach_info.hpp"
+#include "duckdb/main/database_file_path_manager.hpp"
 
 namespace duckdb {
 class AttachedDatabase;
@@ -47,10 +48,16 @@ public:
 	void FinalizeStartup();
 	//! Get an attached database by its name
 	optional_ptr<AttachedDatabase> GetDatabase(ClientContext &context, const string &name);
+	shared_ptr<AttachedDatabase> GetDatabase(const string &name);
 	//! Attach a new database
-	optional_ptr<AttachedDatabase> AttachDatabase(ClientContext &context, AttachInfo &info, AttachOptions &options);
+	shared_ptr<AttachedDatabase> AttachDatabase(ClientContext &context, AttachInfo &info, AttachOptions &options);
+
+	optional_ptr<AttachedDatabase> FinalizeAttach(ClientContext &context, AttachInfo &info,
+	                                              shared_ptr<AttachedDatabase> database);
 	//! Detach an existing database
 	void DetachDatabase(ClientContext &context, const string &name, OnEntryNotFound if_not_found);
+	//! Rollback the attach of a database
+	shared_ptr<AttachedDatabase> DetachInternal(const string &name);
 	//! Returns a reference to the system catalog
 	Catalog &GetSystemCatalog();
 
@@ -58,9 +65,7 @@ public:
 	void SetDefaultDatabase(ClientContext &context, const string &new_value);
 
 	//! Inserts a path to name mapping to the database paths map
-	void InsertDatabasePath(ClientContext &context, const string &path, const string &name);
-	//! Erases a path from the database paths map
-	void EraseDatabasePath(const string &path);
+	InsertDatabasePathResult InsertDatabasePath(const AttachInfo &info, AttachOptions &options);
 
 	//! Returns the database type. This might require checking the header of the file, in which case the file handle is
 	//! necessary. We can only grab the file handle, if it is not yet held, even for uncommitted changes. Thus, we have
@@ -68,10 +73,12 @@ public:
 	void GetDatabaseType(ClientContext &context, AttachInfo &info, const DBConfig &config, AttachOptions &options);
 	//! Scans the catalog set and adds each committed database entry, and each database entry of the current
 	//! transaction, to a vector holding AttachedDatabase references
-	vector<reference<AttachedDatabase>> GetDatabases(ClientContext &context,
-	                                                 const optional_idx max_db_count = optional_idx());
+	vector<shared_ptr<AttachedDatabase>> GetDatabases(ClientContext &context,
+	                                                  const optional_idx max_db_count = optional_idx());
 	//! Scans the catalog set and returns each committed database entry
-	vector<reference<AttachedDatabase>> GetDatabases();
+	vector<shared_ptr<AttachedDatabase>> GetDatabases();
+	//! Returns the approximate count of attached databases.
+	idx_t ApproxDatabaseCount();
 	//! Removes all databases from the catalog set. This is necessary for the database instance's destructor,
 	//! as the database manager has to be alive when destroying the catalog set objects.
 	void ResetDatabases(unique_ptr<TaskScheduler> &scheduler);
@@ -97,16 +104,15 @@ public:
 	//! Gets a list of all attached database paths
 	vector<string> GetAttachedDatabasePaths();
 
-private:
-	//! Returns a database with a specified path
-	optional_ptr<AttachedDatabase> GetDatabaseFromPath(ClientContext &context, const string &path);
-	void CheckPathConflict(ClientContext &context, const string &path);
+	shared_ptr<AttachedDatabase> GetDatabaseInternal(const lock_guard<mutex> &, const string &name);
 
 private:
 	//! The system database is a special database that holds system entries (e.g. functions)
-	unique_ptr<AttachedDatabase> system;
+	shared_ptr<AttachedDatabase> system;
+	//! Lock for databases
+	mutex databases_lock;
 	//! The set of attached databases
-	unique_ptr<CatalogSet> databases;
+	case_insensitive_map_t<shared_ptr<AttachedDatabase>> databases;
 	//! The next object id handed out by the NextOid method
 	atomic<idx_t> next_oid;
 	//! The current query number
@@ -115,13 +121,8 @@ private:
 	atomic<transaction_t> current_transaction_id;
 	//! The current default database
 	string default_database;
-
-	//! The lock to add entries to the database path map
-	mutex db_paths_lock;
-	//! A set containing all attached database path
-	//! This allows to attach many databases efficiently, and to avoid attaching the
-	//! same file path twice
-	case_insensitive_set_t db_paths;
+	//! Manager for ensuring we never open the same database file twice in the same program
+	shared_ptr<DatabaseFilePathManager> path_manager;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/main/database_path_and_type.hpp

@@ -13,11 +13,13 @@
 
 namespace duckdb {
 
+class QueryContext;
+
 struct DBPathAndType {
 	//! Parse database extension type and rest of path from combined form (type:path)
 	static void ExtractExtensionPrefix(string &path, string &db_type);
 	//! Check the magic bytes of a file and set the database type based on that
-	static void CheckMagicBytes(FileSystem &fs, string &path, string &db_type);
+	static void CheckMagicBytes(QueryContext context, FileSystem &fs, string &path, string &db_type);
 
 	//! Run ExtractExtensionPrefix followed by CheckMagicBytes
 	static void ResolveDatabaseType(FileSystem &fs, string &path, string &db_type);

package/src/duckdb/src/include/duckdb/main/db_instance_cache.hpp

@@ -11,11 +11,11 @@
 #include "duckdb/main/connection_manager.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/common/unordered_map.hpp"
-#include "duckdb/function/replacement_scan.hpp"
 #include <functional>
 
 namespace duckdb {
 class DBInstanceCache;
+class DatabaseFilePathManager;
 
 struct DatabaseCacheEntry {
 	DatabaseCacheEntry();
@@ -23,12 +23,13 @@ struct DatabaseCacheEntry {
 	~DatabaseCacheEntry();
 
 	weak_ptr<DuckDB> database;
+	mutex update_database_mutex;
 };
 
 class DBInstanceCache {
 public:
-	DBInstanceCache() {
-	}
+	DBInstanceCache();
+	~DBInstanceCache();
 
 	//! Gets a DB Instance from the cache if already exists (Fails if the configurations do not match)
 	shared_ptr<DuckDB> GetInstance(const string &database, const DBConfig &config_dict);
@@ -42,6 +43,7 @@ public:
 	                                       const std::function<void(DuckDB &)> &on_create = nullptr);
 
 private:
+	shared_ptr<DatabaseFilePathManager> path_manager;
 	//! A map with the cached instances <absolute_path/instance>
 	unordered_map<string, weak_ptr<DatabaseCacheEntry>> db_instances;
 
@@ -49,8 +51,10 @@ private:
 	mutex cache_lock;
 
 private:
-	shared_ptr<DuckDB> GetInstanceInternal(const string &database, const DBConfig &config_dict);
+	shared_ptr<DuckDB> GetInstanceInternal(const string &database, const DBConfig &config,
+	                                       std::unique_lock<std::mutex> &db_instances_lock);
 	shared_ptr<DuckDB> CreateInstanceInternal(const string &database, DBConfig &config_dict, bool cache_instance,
+	                                          std::unique_lock<std::mutex> db_instances_lock,
 	                                          const std::function<void(DuckDB &)> &on_create);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/main/error_manager.hpp

@@ -13,6 +13,7 @@
 #include "duckdb/common/map.hpp"
 
 namespace duckdb {
+class String;
 class ClientContext;
 class DatabaseInstance;
 class TransactionException;
@@ -52,7 +53,8 @@ public:
 		return Get(context).FormatException(error_type, params...);
 	}
 
-	DUCKDB_API static InvalidInputException InvalidUnicodeError(const string &input, const string &context);
+	DUCKDB_API static InvalidInputException InvalidUnicodeError(const String &input, const string &context);
+
 	DUCKDB_API static FatalException InvalidatedDatabase(ClientContext &context, const string &invalidated_msg);
 	DUCKDB_API static TransactionException InvalidatedTransaction(ClientContext &context);
 

package/src/duckdb/src/include/duckdb/main/extension/extension_loader.hpp

@@ -0,0 +1,120 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/extension/extension_loader.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/constants.hpp"
+#include "duckdb/function/cast/cast_function_set.hpp"
+#include "duckdb/function/function_set.hpp"
+#include "duckdb/main/secret/secret.hpp"
+#include "duckdb/parser/parsed_data/create_type_info.hpp"
+#include "duckdb/main/extension_install_info.hpp"
+#include "duckdb/main/extension_manager.hpp"
+
+namespace duckdb {
+
+class DatabaseInstance;
+struct CreateMacroInfo;
+struct CreateCollationInfo;
+struct CreateAggregateFunctionInfo;
+struct CreateScalarFunctionInfo;
+struct CreateTableFunctionInfo;
+
+class ExtensionLoader {
+	friend class DuckDB;
+	friend class ExtensionHelper;
+
+public:
+	explicit ExtensionLoader(ExtensionActiveLoad &load_info);
+	ExtensionLoader(DatabaseInstance &db, const string &extension_name);
+
+	//! Returns the DatabaseInstance associated with this extension loader
+	DUCKDB_API DatabaseInstance &GetDatabaseInstance();
+
+public:
+	//! Set the description of the extension
+	DUCKDB_API void SetDescription(const string &description);
+
+public:
+	//! Register a new scalar function - merge overloads if the function already exists
+	DUCKDB_API void RegisterFunction(ScalarFunction function);
+	DUCKDB_API void RegisterFunction(ScalarFunctionSet function);
+	DUCKDB_API void RegisterFunction(CreateScalarFunctionInfo info);
+
+	//! Register a new aggregate function - merge overloads if the function already exists
+	DUCKDB_API void RegisterFunction(AggregateFunction function);
+	DUCKDB_API void RegisterFunction(AggregateFunctionSet function);
+	DUCKDB_API void RegisterFunction(CreateAggregateFunctionInfo info);
+
+	//! Register a new table function - merge overloads if the function already exists
+	DUCKDB_API void RegisterFunction(TableFunction function);
+	DUCKDB_API void RegisterFunction(TableFunctionSet function);
+	DUCKDB_API void RegisterFunction(CreateTableFunctionInfo info);
+
+	//! Register a new pragma function - throw an exception if the function already exists
+	DUCKDB_API void RegisterFunction(PragmaFunction function);
+
+	//! Register a new pragma function set - throw an exception if the function already exists
+	DUCKDB_API void RegisterFunction(PragmaFunctionSet function);
+
+	//! Register a CreateSecretFunction
+	DUCKDB_API void RegisterFunction(CreateSecretFunction function);
+
+	//! Register a new copy function - throw an exception if the function already exists
+	DUCKDB_API void RegisterFunction(CopyFunction function);
+	//! Register a new macro function - throw an exception if the function already exists
+	DUCKDB_API void RegisterFunction(CreateMacroInfo &info);
+
+	//! Register a new collation
+	DUCKDB_API void RegisterCollation(CreateCollationInfo &info);
+
+	//! Returns a reference to the function in the catalog - throws an exception if it does not exist
+	DUCKDB_API ScalarFunctionCatalogEntry &GetFunction(const string &name);
+	DUCKDB_API TableFunctionCatalogEntry &GetTableFunction(const string &name);
+	DUCKDB_API optional_ptr<CatalogEntry> TryGetFunction(const string &name);
+	DUCKDB_API optional_ptr<CatalogEntry> TryGetTableFunction(const string &name);
+
+	//! Add a function overload
+	DUCKDB_API void AddFunctionOverload(ScalarFunction function);
+	DUCKDB_API void AddFunctionOverload(ScalarFunctionSet function);
+	DUCKDB_API void AddFunctionOverload(TableFunctionSet function);
+
+	//! Registers a new type
+	DUCKDB_API void RegisterType(string type_name, LogicalType type,
+	                             bind_logical_type_function_t bind_function = nullptr);
+
+	//! Registers a new secret type
+	DUCKDB_API void RegisterSecretType(SecretType secret_type);
+
+	//! Registers a cast between two types
+	DUCKDB_API void RegisterCastFunction(const LogicalType &source, const LogicalType &target,
+	                                     bind_cast_function_t function, int64_t implicit_cast_cost = -1);
+	DUCKDB_API void RegisterCastFunction(const LogicalType &source, const LogicalType &target, BoundCastInfo function,
+	                                     int64_t implicit_cast_cost = -1);
+
+private:
+	void FinalizeLoad();
+
+private:
+	DatabaseInstance &db;
+	string extension_name;
+	string extension_description;
+	optional_ptr<ExtensionInfo> extension_info;
+};
+
+} // namespace duckdb
+
+//! Helper macro to define the entrypoint for a C++ extension
+//! Usage:
+//!
+//!		DUCKDB_CPP_EXTENSION_ENTRY(my_extension, loader) {
+//!			loader.RegisterFunction(...);
+//!		}
+//!
+#define DUCKDB_CPP_EXTENSION_ENTRY(EXTENSION_NAME, LOADER_NAME)                                                        \
+	DUCKDB_EXTENSION_API void EXTENSION_NAME##_duckdb_cpp_init(duckdb::ExtensionLoader &LOADER_NAME)

package/src/duckdb/src/include/duckdb/main/extension.hpp

@@ -12,14 +12,14 @@
 #include "duckdb/common/winapi.hpp"
 
 namespace duckdb {
-class DuckDB;
+class ExtensionLoader;
 
 //! The Extension class is the base class used to define extensions
 class Extension {
 public:
 	DUCKDB_API virtual ~Extension();
 
-	DUCKDB_API virtual void Load(DuckDB &db) = 0;
+	DUCKDB_API virtual void Load(ExtensionLoader &db) = 0;
 	DUCKDB_API virtual std::string Name() = 0;
 	DUCKDB_API virtual std::string Version() const {
 		return "";

package/src/duckdb/src/include/duckdb/main/extension_entries.hpp

@@ -154,10 +154,16 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"duckdb_proj_version", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"ducklake_add_data_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
     {"ducklake_cleanup_old_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
+    {"ducklake_current_snapshot", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
+    {"ducklake_delete_orphaned_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
     {"ducklake_expire_snapshots", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
+    {"ducklake_flush_inlined_data", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
+    {"ducklake_last_committed_snapshot", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
     {"ducklake_list_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
     {"ducklake_merge_adjacent_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
     {"ducklake_options", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
+    {"ducklake_rewrite_data_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
+    {"ducklake_set_commit_message", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
     {"ducklake_set_option", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
     {"ducklake_snapshots", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
     {"ducklake_table_changes", "ducklake", CatalogType::TABLE_MACRO_ENTRY},
@@ -440,6 +446,7 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"make_date", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"make_time", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"make_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"make_timestamp_ms", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"make_timestamp_ns", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"make_timestamptz", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"map", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
@@ -520,6 +527,7 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"regr_syy", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
     {"repeat", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"replace", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"replace_type", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"reservoir_quantile", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
     {"reverse", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"right", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
@@ -550,6 +558,8 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"st_area_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_asgeojson", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_ashexwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"st_asmvt", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY},
+    {"st_asmvtgeom", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_assvg", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_astext", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_aswkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
@@ -608,6 +618,7 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"st_hasm", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_hasz", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_hilbert", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"st_interpolatepoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_intersection", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_intersection_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY},
     {"st_intersects", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
@@ -621,13 +632,17 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"st_length_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_lineinterpolatepoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_lineinterpolatepoints", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"st_linelocatepoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_linemerge", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_linestring2dfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_linesubstring", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"st_locatealong", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"st_locatebetween", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_m", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_makebox2d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_makeenvelope", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_makeline", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"st_makepoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_makepolygon", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_makevalid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_maximuminscribedcircle", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
@@ -706,6 +721,7 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"string_agg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
     {"strpos", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"struct_insert", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"struct_update", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"sum", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
     {"sum_no_overflow", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
     {"sumkahan", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
@@ -790,11 +806,13 @@ static constexpr ExtensionFunctionOverloadEntry EXTENSION_FUNCTION_OVERLOADS[] =
     {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIME]>STRUCT()"},
     {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMESTAMP]>STRUCT()"},
     {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMETZ]>STRUCT()"},
+    {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIME_NS]>STRUCT()"},
     {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE]>BIGINT"},
     {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,INTERVAL]>BIGINT"},
     {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME]>BIGINT"},
     {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP]>BIGINT"},
     {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMETZ]>BIGINT"},
+    {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME_NS]>BIGINT"},
     {"date_part", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMESTAMPTZ]>STRUCT()"},
     {"date_part", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ]>BIGINT"},
     {"date_sub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE,DATE]>BIGINT"},
@@ -814,11 +832,13 @@ static constexpr ExtensionFunctionOverloadEntry EXTENSION_FUNCTION_OVERLOADS[] =
     {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIME]>STRUCT()"},
     {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMESTAMP]>STRUCT()"},
     {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMETZ]>STRUCT()"},
+    {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIME_NS]>STRUCT()"},
     {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE]>BIGINT"},
     {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,INTERVAL]>BIGINT"},
     {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME]>BIGINT"},
     {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP]>BIGINT"},
     {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMETZ]>BIGINT"},
+    {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME_NS]>BIGINT"},
     {"datepart", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMESTAMPTZ]>STRUCT()"},
     {"datepart", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ]>BIGINT"},
     {"datesub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE,DATE]>BIGINT"},
@@ -857,6 +877,7 @@ static constexpr ExtensionFunctionOverloadEntry EXTENSION_FUNCTION_OVERLOADS[] =
     {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>DOUBLE"},
     {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>DOUBLE"},
     {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>DOUBLE"},
+    {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME_NS]>DOUBLE"},
     {"epoch", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>DOUBLE"},
     {"era", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"},
     {"era", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"},
@@ -873,6 +894,7 @@ static constexpr ExtensionFunctionOverloadEntry EXTENSION_FUNCTION_OVERLOADS[] =
     {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"},
     {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"},
     {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"},
+    {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME_NS]>BIGINT"},
     {"hour", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"},
     {"isodow", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"},
     {"isodow", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"},
@@ -893,6 +915,7 @@ static constexpr ExtensionFunctionOverloadEntry EXTENSION_FUNCTION_OVERLOADS[] =
     {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"},
     {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"},
     {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"},
+    {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME_NS]>BIGINT"},
     {"microsecond", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"},
     {"millennium", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"},
     {"millennium", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"},
@@ -903,12 +926,14 @@ static constexpr ExtensionFunctionOverloadEntry EXTENSION_FUNCTION_OVERLOADS[] =
     {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"},
     {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"},
     {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"},
+    {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME_NS]>BIGINT"},
     {"millisecond", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"},
     {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"},
     {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"},
     {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"},
     {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"},
     {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"},
+    {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME_NS]>BIGINT"},
     {"minute", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"},
     {"month", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"},
     {"month", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"},
@@ -931,6 +956,7 @@ static constexpr ExtensionFunctionOverloadEntry EXTENSION_FUNCTION_OVERLOADS[] =
     {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"},
     {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"},
     {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"},
+    {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME_NS]>BIGINT"},
     {"second", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"},
     {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,DATE]>DATE"},
     {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,DATE,DATE]>DATE"},
@@ -981,6 +1007,7 @@ static constexpr ExtensionFunctionOverloadEntry EXTENSION_FUNCTION_OVERLOADS[] =
 }; // END_OF_EXTENSION_FUNCTION_OVERLOADS
 
 static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
+    {"auto_fallback_to_full_download", "httpfs"},
     {"azure_account_name", "azure"},
     {"azure_context_caching", "azure"},
     {"azure_credential_chain", "azure"},
@@ -1001,6 +1028,7 @@ static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
     {"ducklake_max_retry_count", "ducklake"},
     {"ducklake_retry_backoff", "ducklake"},
     {"ducklake_retry_wait_ms", "ducklake"},
+    {"enable_curl_server_cert_verification", "httpfs"},
     {"enable_geoparquet_conversion", "parquet"},
     {"enable_server_cert_verification", "httpfs"},
     {"force_download", "httpfs"},
@@ -1012,9 +1040,12 @@ static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
     {"http_retry_backoff", "httpfs"},
     {"http_retry_wait_ms", "httpfs"},
     {"http_timeout", "httpfs"},
+    {"httpfs_client_implementation", "httpfs"},
     {"mysql_bit1_as_boolean", "mysql_scanner"},
     {"mysql_debug_show_queries", "mysql_scanner"},
     {"mysql_experimental_filter_pushdown", "mysql_scanner"},
+    {"mysql_session_time_zone", "mysql_scanner"},
+    {"mysql_time_as_time", "mysql_scanner"},
     {"mysql_tinyint1_as_boolean", "mysql_scanner"},
     {"parquet_metadata_cache", "parquet"},
     {"pg_array_as_varchar", "postgres_scanner"},
@@ -1026,11 +1057,13 @@ static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
     {"pg_pages_per_task", "postgres_scanner"},
     {"pg_use_binary_copy", "postgres_scanner"},
     {"pg_use_ctid_scan", "postgres_scanner"},
+    {"pg_use_text_protocol", "postgres_scanner"},
     {"prefetch_all_parquet_files", "parquet"},
     {"s3_access_key_id", "httpfs"},
     {"s3_endpoint", "httpfs"},
     {"s3_kms_key_id", "httpfs"},
     {"s3_region", "httpfs"},
+    {"s3_requester_pays", "httpfs"},
     {"s3_secret_access_key", "httpfs"},
     {"s3_session_token", "httpfs"},
     {"s3_uploader_max_filesize", "httpfs"},
@@ -1045,7 +1078,9 @@ static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
     {"ui_local_port", "ui"},
     {"ui_polling_interval", "ui"},
     {"ui_remote_url", "ui"},
+    {"unsafe_disable_etag_checks", "httpfs"},
     {"unsafe_enable_version_guessing", "iceberg"},
+    {"variant_legacy_encoding", "parquet"},
 }; // END_OF_EXTENSION_SETTINGS
 
 static constexpr ExtensionEntry EXTENSION_SECRET_TYPES[] = {

package/src/duckdb/src/include/duckdb/main/extension_helper.hpp

@@ -250,6 +250,8 @@ private:
 	                           ExtensionInitResult &result, string &error);
 	//! Version tags occur with and without 'v', tag in extension path is always with 'v'
 	static const string NormalizeVersionTag(const string &version_tag);
+	static void LoadExternalExtensionInternal(DatabaseInstance &db, FileSystem &fs, const string &extension,
+	                                          ExtensionActiveLoad &info);
 
 private:
 	static ExtensionLoadResult LoadExtensionInternal(DuckDB &db, const std::string &extension, bool initial_load);

package/src/duckdb/src/include/duckdb/main/extension_manager.hpp

@@ -0,0 +1,59 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/extension_manager.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/main/extension_install_info.hpp"
+
+namespace duckdb {
+class ErrorData;
+
+class ExtensionInfo {
+public:
+	ExtensionInfo();
+
+	mutex lock;
+	atomic<bool> is_loaded;
+	unique_ptr<ExtensionInstallInfo> install_info;
+	unique_ptr<ExtensionLoadedInfo> load_info;
+};
+
+class ExtensionActiveLoad {
+public:
+	ExtensionActiveLoad(DatabaseInstance &db, ExtensionInfo &info, string extension_name);
+
+	DatabaseInstance &db;
+	unique_lock<mutex> load_lock;
+	ExtensionInfo &info;
+	string extension_name;
+
+public:
+	void FinishLoad(ExtensionInstallInfo &install_info);
+	void LoadFail(const ErrorData &error);
+};
+
+class ExtensionManager {
+public:
+	explicit ExtensionManager(DatabaseInstance &db);
+
+	DUCKDB_API bool ExtensionIsLoaded(const string &name);
+	DUCKDB_API vector<string> GetExtensions();
+	DUCKDB_API optional_ptr<ExtensionInfo> GetExtensionInfo(const string &name);
+	DUCKDB_API unique_ptr<ExtensionActiveLoad> BeginLoad(const string &extension);
+
+	DUCKDB_API static ExtensionManager &Get(DatabaseInstance &db);
+	DUCKDB_API static ExtensionManager &Get(ClientContext &context);
+
+private:
+	DatabaseInstance &db;
+	mutex lock;
+	unordered_map<string, unique_ptr<ExtensionInfo>> loaded_extensions_info;
+};
+
+} // namespace duckdb