duckdb 0.9.3-dev0.0 → 0.9.3-dev12.0

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

@@ -20,186 +20,190 @@ struct ExtensionEntry {
 	char extension[48];
 };
 
-static constexpr ExtensionEntry EXTENSION_FUNCTIONS[] = {
-    {"->>", "json"},
-    {"array_to_json", "json"},
-    {"create_fts_index", "fts"},
-    {"current_localtime", "icu"},
-    {"current_localtimestamp", "icu"},
-    {"dbgen", "tpch"},
-    {"drop_fts_index", "fts"},
-    {"dsdgen", "tpcds"},
-    {"excel_text", "excel"},
-    {"from_json", "json"},
-    {"from_json_strict", "json"},
-    {"from_substrait", "substrait"},
-    {"from_substrait_json", "substrait"},
-    {"fuzz_all_functions", "sqlsmith"},
-    {"fuzzyduck", "sqlsmith"},
-    {"get_substrait", "substrait"},
-    {"get_substrait_json", "substrait"},
-    {"host", "inet"},
-    {"iceberg_metadata", "iceberg"},
-    {"iceberg_scan", "iceberg"},
-    {"iceberg_snapshots", "iceberg"},
-    {"icu_calendar_names", "icu"},
-    {"icu_sort_key", "icu"},
-    {"json", "json"},
-    {"json_array", "json"},
-    {"json_array_length", "json"},
-    {"json_contains", "json"},
-    {"json_deserialize_sql", "json"},
-    {"json_execute_serialized_sql", "json"},
-    {"json_extract", "json"},
-    {"json_extract_path", "json"},
-    {"json_extract_path_text", "json"},
-    {"json_extract_string", "json"},
-    {"json_group_array", "json"},
-    {"json_group_object", "json"},
-    {"json_group_structure", "json"},
-    {"json_keys", "json"},
-    {"json_merge_patch", "json"},
-    {"json_object", "json"},
-    {"json_quote", "json"},
-    {"json_serialize_sql", "json"},
-    {"json_structure", "json"},
-    {"json_transform", "json"},
-    {"json_transform_strict", "json"},
-    {"json_type", "json"},
-    {"json_valid", "json"},
-    {"load_aws_credentials", "aws"},
-    {"make_timestamptz", "icu"},
-    {"parquet_metadata", "parquet"},
-    {"parquet_scan", "parquet"},
-    {"parquet_schema", "parquet"},
-    {"pg_clear_cache", "postgres_scanner"},
-    {"pg_timezone_names", "icu"},
-    {"postgres_attach", "postgres_scanner"},
-    {"postgres_query", "postgres_scanner"},
-    {"postgres_scan", "postgres_scanner"},
-    {"postgres_scan_pushdown", "postgres_scanner"},
-    {"read_json", "json"},
-    {"read_json_auto", "json"},
-    {"read_json_objects", "json"},
-    {"read_json_objects_auto", "json"},
-    {"read_ndjson", "json"},
-    {"read_ndjson_auto", "json"},
-    {"read_ndjson_objects", "json"},
-    {"read_parquet", "parquet"},
-    {"reduce_sql_statement", "sqlsmith"},
-    {"row_to_json", "json"},
-    {"scan_arrow_ipc", "arrow"},
-    {"sql_auto_complete", "autocomplete"},
-    {"sqlite_attach", "sqlite_scanner"},
-    {"sqlite_scan", "sqlite_scanner"},
-    {"sqlsmith", "sqlsmith"},
-    {"st_area", "spatial"},
-    {"st_area_spheroid", "spatial"},
-    {"st_asgeojson", "spatial"},
-    {"st_ashexwkb", "spatial"},
-    {"st_astext", "spatial"},
-    {"st_aswkb", "spatial"},
-    {"st_boundary", "spatial"},
-    {"st_buffer", "spatial"},
-    {"st_centroid", "spatial"},
-    {"st_collect", "spatial"},
-    {"st_collectionextract", "spatial"},
-    {"st_contains", "spatial"},
-    {"st_containsproperly", "spatial"},
-    {"st_convexhull", "spatial"},
-    {"st_coveredby", "spatial"},
-    {"st_covers", "spatial"},
-    {"st_crosses", "spatial"},
-    {"st_difference", "spatial"},
-    {"st_dimension", "spatial"},
-    {"st_disjoint", "spatial"},
-    {"st_distance", "spatial"},
-    {"st_distance_spheroid", "spatial"},
-    {"st_drivers", "spatial"},
-    {"st_dump", "spatial"},
-    {"st_dwithin", "spatial"},
-    {"st_dwithin_spheroid", "spatial"},
-    {"st_endpoint", "spatial"},
-    {"st_envelope", "spatial"},
-    {"st_envelope_agg", "spatial"},
-    {"st_equals", "spatial"},
-    {"st_extent", "spatial"},
-    {"st_exteriorring", "spatial"},
-    {"st_flipcoordinates", "spatial"},
-    {"st_geometrytype", "spatial"},
-    {"st_geomfromgeojson", "spatial"},
-    {"st_geomfromhexewkb", "spatial"},
-    {"st_geomfromhexwkb", "spatial"},
-    {"st_geomfromtext", "spatial"},
-    {"st_geomfromwkb", "spatial"},
-    {"st_intersection", "spatial"},
-    {"st_intersection_agg", "spatial"},
-    {"st_intersects", "spatial"},
-    {"st_intersects_extent", "spatial"},
-    {"st_isclosed", "spatial"},
-    {"st_isempty", "spatial"},
-    {"st_isring", "spatial"},
-    {"st_issimple", "spatial"},
-    {"st_isvalid", "spatial"},
-    {"st_length", "spatial"},
-    {"st_length_spheroid", "spatial"},
-    {"st_linemerge", "spatial"},
-    {"st_linestring2dfromwkb", "spatial"},
-    {"st_list_proj_crs", "spatial"},
-    {"st_makeenvelope", "spatial"},
-    {"st_makeline", "spatial"},
-    {"st_makepolygon", "spatial"},
-    {"st_ngeometries", "spatial"},
-    {"st_ninteriorrings", "spatial"},
-    {"st_normalize", "spatial"},
-    {"st_npoints", "spatial"},
-    {"st_numgeometries", "spatial"},
-    {"st_numinteriorrings", "spatial"},
-    {"st_numpoints", "spatial"},
-    {"st_overlaps", "spatial"},
-    {"st_perimeter", "spatial"},
-    {"st_perimeter_spheroid", "spatial"},
-    {"st_point", "spatial"},
-    {"st_point2d", "spatial"},
-    {"st_point2dfromwkb", "spatial"},
-    {"st_point3d", "spatial"},
-    {"st_point4d", "spatial"},
-    {"st_pointn", "spatial"},
-    {"st_pointonsurface", "spatial"},
-    {"st_polygon2dfromwkb", "spatial"},
-    {"st_reverse", "spatial"},
-    {"st_read", "spatial"},
-    {"st_readosm", "spatial"},
-    {"st_reduceprecision", "spatial"},
-    {"st_removerepeatedpoints", "spatial"},
-    {"st_simplify", "spatial"},
-    {"st_simplifypreservetopology", "spatial"},
-    {"st_startpoint", "spatial"},
-    {"st_touches", "spatial"},
-    {"st_transform", "spatial"},
-    {"st_union", "spatial"},
-    {"st_union_agg", "spatial"},
-    {"st_within", "spatial"},
-    {"st_x", "spatial"},
-    {"st_xmax", "spatial"},
-    {"st_xmin", "spatial"},
-    {"st_y", "spatial"},
-    {"st_ymax", "spatial"},
-    {"st_ymin", "spatial"},
-    {"stem", "fts"},
-    {"text", "excel"},
-    {"to_arrow_ipc", "arrow"},
-    {"to_json", "json"},
-    {"tpcds", "tpcds"},
-    {"tpcds_answers", "tpcds"},
-    {"tpcds_queries", "tpcds"},
-    {"tpch", "tpch"},
-    {"tpch_answers", "tpch"},
-    {"tpch_queries", "tpch"},
-    {"visualize_diff_profiling_output", "visualizer"},
-    {"visualize_json_profiling_output", "visualizer"},
-    {"visualize_last_profiling_output", "visualizer"},
-}; // END_OF_EXTENSION_FUNCTIONS
+static constexpr ExtensionEntry EXTENSION_FUNCTIONS[] = {{"->>", "json"},
+                                                         {"add_parquet_key", "parquet"},
+                                                         {"array_to_json", "json"},
+                                                         {"create_fts_index", "fts"},
+                                                         {"current_localtime", "icu"},
+                                                         {"current_localtimestamp", "icu"},
+                                                         {"dbgen", "tpch"},
+                                                         {"drop_fts_index", "fts"},
+                                                         {"dsdgen", "tpcds"},
+                                                         {"excel_text", "excel"},
+                                                         {"from_json", "json"},
+                                                         {"from_json_strict", "json"},
+                                                         {"from_substrait", "substrait"},
+                                                         {"from_substrait_json", "substrait"},
+                                                         {"fuzz_all_functions", "sqlsmith"},
+                                                         {"fuzzyduck", "sqlsmith"},
+                                                         {"get_substrait", "substrait"},
+                                                         {"get_substrait_json", "substrait"},
+                                                         {"host", "inet"},
+                                                         {"iceberg_metadata", "iceberg"},
+                                                         {"iceberg_scan", "iceberg"},
+                                                         {"iceberg_snapshots", "iceberg"},
+                                                         {"icu_calendar_names", "icu"},
+                                                         {"icu_sort_key", "icu"},
+                                                         {"json", "json"},
+                                                         {"json_array", "json"},
+                                                         {"json_array_length", "json"},
+                                                         {"json_contains", "json"},
+                                                         {"json_deserialize_sql", "json"},
+                                                         {"json_execute_serialized_sql", "json"},
+                                                         {"json_extract", "json"},
+                                                         {"json_extract_path", "json"},
+                                                         {"json_extract_path_text", "json"},
+                                                         {"json_extract_string", "json"},
+                                                         {"json_group_array", "json"},
+                                                         {"json_group_object", "json"},
+                                                         {"json_group_structure", "json"},
+                                                         {"json_keys", "json"},
+                                                         {"json_merge_patch", "json"},
+                                                         {"json_object", "json"},
+                                                         {"json_quote", "json"},
+                                                         {"json_serialize_plan", "json"},
+                                                         {"json_serialize_sql", "json"},
+                                                         {"json_structure", "json"},
+                                                         {"json_transform", "json"},
+                                                         {"json_transform_strict", "json"},
+                                                         {"json_type", "json"},
+                                                         {"json_valid", "json"},
+                                                         {"load_aws_credentials", "aws"},
+                                                         {"make_timestamptz", "icu"},
+                                                         {"parquet_file_metadata", "parquet"},
+                                                         {"parquet_kv_metadata", "parquet"},
+                                                         {"parquet_metadata", "parquet"},
+                                                         {"parquet_scan", "parquet"},
+                                                         {"parquet_schema", "parquet"},
+                                                         {"pg_clear_cache", "postgres_scanner"},
+                                                         {"pg_timezone_names", "icu"},
+                                                         {"postgres_attach", "postgres_scanner"},
+                                                         {"postgres_query", "postgres_scanner"},
+                                                         {"postgres_scan", "postgres_scanner"},
+                                                         {"postgres_scan_pushdown", "postgres_scanner"},
+                                                         {"read_json", "json"},
+                                                         {"read_json_auto", "json"},
+                                                         {"read_json_objects", "json"},
+                                                         {"read_json_objects_auto", "json"},
+                                                         {"read_ndjson", "json"},
+                                                         {"read_ndjson_auto", "json"},
+                                                         {"read_ndjson_objects", "json"},
+                                                         {"read_parquet", "parquet"},
+                                                         {"reduce_sql_statement", "sqlsmith"},
+                                                         {"row_to_json", "json"},
+                                                         {"scan_arrow_ipc", "arrow"},
+                                                         {"sql_auto_complete", "autocomplete"},
+                                                         {"sqlite_attach", "sqlite_scanner"},
+                                                         {"sqlite_scan", "sqlite_scanner"},
+                                                         {"sqlsmith", "sqlsmith"},
+                                                         {"shapefile_meta", "spatial"},
+                                                         {"st_area", "spatial"},
+                                                         {"st_area_spheroid", "spatial"},
+                                                         {"st_asgeojson", "spatial"},
+                                                         {"st_ashexwkb", "spatial"},
+                                                         {"st_astext", "spatial"},
+                                                         {"st_aswkb", "spatial"},
+                                                         {"st_boundary", "spatial"},
+                                                         {"st_buffer", "spatial"},
+                                                         {"st_centroid", "spatial"},
+                                                         {"st_collect", "spatial"},
+                                                         {"st_collectionextract", "spatial"},
+                                                         {"st_contains", "spatial"},
+                                                         {"st_containsproperly", "spatial"},
+                                                         {"st_convexhull", "spatial"},
+                                                         {"st_coveredby", "spatial"},
+                                                         {"st_covers", "spatial"},
+                                                         {"st_crosses", "spatial"},
+                                                         {"st_difference", "spatial"},
+                                                         {"st_dimension", "spatial"},
+                                                         {"st_disjoint", "spatial"},
+                                                         {"st_distance", "spatial"},
+                                                         {"st_distance_spheroid", "spatial"},
+                                                         {"st_drivers", "spatial"},
+                                                         {"st_dump", "spatial"},
+                                                         {"st_dwithin", "spatial"},
+                                                         {"st_dwithin_spheroid", "spatial"},
+                                                         {"st_endpoint", "spatial"},
+                                                         {"st_envelope", "spatial"},
+                                                         {"st_envelope_agg", "spatial"},
+                                                         {"st_equals", "spatial"},
+                                                         {"st_extent", "spatial"},
+                                                         {"st_exteriorring", "spatial"},
+                                                         {"st_flipcoordinates", "spatial"},
+                                                         {"st_geometrytype", "spatial"},
+                                                         {"st_geomfromgeojson", "spatial"},
+                                                         {"st_geomfromhexewkb", "spatial"},
+                                                         {"st_geomfromhexwkb", "spatial"},
+                                                         {"st_geomfromtext", "spatial"},
+                                                         {"st_geomfromwkb", "spatial"},
+                                                         {"st_intersection", "spatial"},
+                                                         {"st_intersection_agg", "spatial"},
+                                                         {"st_intersects", "spatial"},
+                                                         {"st_intersects_extent", "spatial"},
+                                                         {"st_isclosed", "spatial"},
+                                                         {"st_isempty", "spatial"},
+                                                         {"st_isring", "spatial"},
+                                                         {"st_issimple", "spatial"},
+                                                         {"st_isvalid", "spatial"},
+                                                         {"st_length", "spatial"},
+                                                         {"st_length_spheroid", "spatial"},
+                                                         {"st_linemerge", "spatial"},
+                                                         {"st_linestring2dfromwkb", "spatial"},
+                                                         {"st_list_proj_crs", "spatial"},
+                                                         {"st_makeenvelope", "spatial"},
+                                                         {"st_makeline", "spatial"},
+                                                         {"st_makepolygon", "spatial"},
+                                                         {"st_makevalid", "spatial"},
+                                                         {"st_ngeometries", "spatial"},
+                                                         {"st_ninteriorrings", "spatial"},
+                                                         {"st_normalize", "spatial"},
+                                                         {"st_npoints", "spatial"},
+                                                         {"st_numgeometries", "spatial"},
+                                                         {"st_numinteriorrings", "spatial"},
+                                                         {"st_numpoints", "spatial"},
+                                                         {"st_overlaps", "spatial"},
+                                                         {"st_perimeter", "spatial"},
+                                                         {"st_perimeter_spheroid", "spatial"},
+                                                         {"st_point", "spatial"},
+                                                         {"st_point2d", "spatial"},
+                                                         {"st_point2dfromwkb", "spatial"},
+                                                         {"st_point3d", "spatial"},
+                                                         {"st_point4d", "spatial"},
+                                                         {"st_pointn", "spatial"},
+                                                         {"st_pointonsurface", "spatial"},
+                                                         {"st_polygon2dfromwkb", "spatial"},
+                                                         {"st_quadkey", "spatial"},
+                                                         {"st_reverse", "spatial"},
+                                                         {"st_read", "spatial"},
+                                                         {"st_read_meta", "spatial"},
+                                                         {"st_readosm", "spatial"},
+                                                         {"st_readshp", "spatial"},
+                                                         {"st_reduceprecision", "spatial"},
+                                                         {"st_removerepeatedpoints", "spatial"},
+                                                         {"st_simplify", "spatial"},
+                                                         {"st_simplifypreservetopology", "spatial"},
+                                                         {"st_startpoint", "spatial"},
+                                                         {"st_touches", "spatial"},
+                                                         {"st_transform", "spatial"},
+                                                         {"st_union", "spatial"},
+                                                         {"st_union_agg", "spatial"},
+                                                         {"st_within", "spatial"},
+                                                         {"st_x", "spatial"},
+                                                         {"st_xmax", "spatial"},
+                                                         {"st_xmin", "spatial"},
+                                                         {"st_y", "spatial"},
+                                                         {"st_ymax", "spatial"},
+                                                         {"st_ymin", "spatial"},
+                                                         {"stem", "fts"},
+                                                         {"text", "excel"},
+                                                         {"to_arrow_ipc", "arrow"},
+                                                         {"to_json", "json"},
+                                                         {"tpcds", "tpcds"},
+                                                         {"tpcds_answers", "tpcds"},
+                                                         {"tpcds_queries", "tpcds"},
+                                                         {"tpch", "tpch"},
+                                                         {"tpch_answers", "tpch"},
+                                                         {"tpch_queries", "tpch"}}; // END_OF_EXTENSION_FUNCTIONS
 
 static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
     {"azure_storage_connection_string", "azure"},
@@ -210,9 +214,11 @@ static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
     {"http_retry_backoff", "httpfs"},
     {"http_retry_wait_ms", "httpfs"},
     {"http_timeout", "httpfs"},
+    {"http_keep_alive", "httpfs"},
     {"pg_debug_show_queries", "postgres_scanner"},
     {"pg_use_binary_copy", "postgres_scanner"},
     {"pg_experimental_filter_pushdown", "postgres_scanner"},
+    {"pg_connection_cache", "postgres_scanner"},
     {"pg_connection_limit", "postgres_scanner"},
     {"pg_pages_per_task", "postgres_scanner"},
     {"pg_array_as_varchar", "postgres_scanner"},
@@ -270,8 +276,8 @@ static constexpr ExtensionEntry EXTENSION_COLLATIONS[] = {
 // Note: these are currently hardcoded in scripts/generate_extensions_function.py
 // TODO: automate by passing though to script via duckdb
 static constexpr ExtensionEntry EXTENSION_FILE_PREFIXES[] = {
-    {"http://", "httpfs"}, {"https://", "httpfs"}, {"s3://", "httpfs"},
-    //    {"azure://", "azure"}
+    {"http://", "httpfs"}, {"https://", "httpfs"}, {"s3://", "httpfs"}, {"s3a://", "httpfs"},
+    {"s3n://", "httpfs"},  {"gcs://", "httpfs"},   {"gs://", "httpfs"}, {"r2://", "httpfs"} // , {"azure://", "azure"}
 }; // END_OF_EXTENSION_FILE_PREFIXES
 
 // Note: these are currently hardcoded in scripts/generate_extensions_function.py
@@ -287,25 +293,25 @@ static constexpr ExtensionEntry EXTENSION_FILE_CONTAINS[] = {{".parquet?", "parq
                                                              {".ndjson?", ".jsonl?"},
                                                              {".jsonl?", ".ndjson?"}}; // EXTENSION_FILE_CONTAINS
 
+// Note: these are currently hardcoded in scripts/generate_extensions_function.py
+// TODO: automate by passing though to script via duckdb
+static constexpr ExtensionEntry EXTENSION_SECRET_TYPES[] = {
+    {"s3", "httpfs"}, {"r2", "httpfs"}, {"gcs", "httpfs"}, {"azure", "azure"}}; // EXTENSION_SECRET_TYPES
+
+// Note: these are currently hardcoded in scripts/generate_extensions_function.py
+// TODO: automate by passing though to script via duckdb
+static constexpr ExtensionEntry EXTENSION_SECRET_PROVIDERS[] = {
+    {"s3/config", "httpfs"},        {"gcs/config", "httpfs"},           {"r2/config", "httpfs"},
+    {"s3/credential_chain", "aws"}, {"gcs/credential_chain", "aws"},    {"r2/credential_chain", "aws"},
+    {"azure/config", "azure"},      {"azure/credential_chain", "azure"}}; // EXTENSION_SECRET_PROVIDERS
+
 static constexpr const char *AUTOLOADABLE_EXTENSIONS[] = {
     //    "azure",
-    "arrow",
-    "aws",
-    "autocomplete",
-    "excel",
-    "fts",
-    "httpfs",
+    "arrow", "aws", "autocomplete", "excel", "fts", "httpfs",
     // "inet",
     // "icu",
-    "json",
-    "parquet",
-    "postgres_scanner",
+    "json", "parquet", "postgres_scanner",
     // "spatial", TODO: table function isnt always autoloaded so test fails
-    "sqlsmith",
-    "sqlite_scanner",
-    "tpcds",
-    "tpch",
-    "visualizer",
-}; // END_OF_AUTOLOADABLE_EXTENSIONS
+    "sqlsmith", "sqlite_scanner", "tpcds", "tpch"}; // END_OF_AUTOLOADABLE_EXTENSIONS
 
 } // namespace duckdb

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

@@ -30,7 +30,7 @@ struct ExtensionAlias {
 
 struct ExtensionInitResult {
 	string filename;
-	string basename;
+	string filebase;
 
 	void *lib_hdl;
 };
@@ -41,42 +41,54 @@ public:
 
 	static ExtensionLoadResult LoadExtension(DuckDB &db, const std::string &extension);
 
+	//! Install an extension
 	static void InstallExtension(ClientContext &context, const string &extension, bool force_install,
 	                             const string &respository = "");
 	static void InstallExtension(DBConfig &config, FileSystem &fs, const string &extension, bool force_install,
 	                             const string &respository = "");
+	//! Load an extension
 	static void LoadExternalExtension(ClientContext &context, const string &extension);
-	static void LoadExternalExtension(DatabaseInstance &db, FileSystem &fs, const string &extension,
-	                                  optional_ptr<const ClientConfig> client_config);
+	static void LoadExternalExtension(DatabaseInstance &db, FileSystem &fs, const string &extension);
 
-	//! Autoload an extension by name. Depending on the current settings, this will either load or install+load
+	//! Autoload an extension (depending on config, potentially a nop. Throws when installation fails)
 	static void AutoLoadExtension(ClientContext &context, const string &extension_name);
+	static void AutoLoadExtension(DatabaseInstance &db, const string &extension_name);
+
+	//! Autoload an extension (depending on config, potentially a nop. Returns false on failure)
 	DUCKDB_API static bool TryAutoLoadExtension(ClientContext &context, const string &extension_name) noexcept;
 
+	//! Get the extension directory base on the current config
 	static string ExtensionDirectory(ClientContext &context);
 	static string ExtensionDirectory(DBConfig &config, FileSystem &fs);
-	static string ExtensionUrlTemplate(optional_ptr<const ClientConfig> config, const string &repository);
+
+	//! Get the extension url template, containing placeholders for version, platform and extension name
+	static string ExtensionUrlTemplate(optional_ptr<const DBConfig> config, const string &repository);
+	//! Return the extension url template with the variables replaced
 	static string ExtensionFinalizeUrlTemplate(const string &url, const string &name);
 
+	//! Default extensions are all extensions that DuckDB knows and expect to be available (both in-tree and
+	//! out-of-tree)
 	static idx_t DefaultExtensionCount();
 	static DefaultExtension GetDefaultExtension(idx_t index);
 
+	//! Extension can have aliases
 	static idx_t ExtensionAliasCount();
 	static ExtensionAlias GetExtensionAlias(idx_t index);
 
+	//! Get public signing keys for extension signing
 	static const vector<string> GetPublicKeys();
 
 	// Returns extension name, or empty string if not a replacement open path
 	static string ExtractExtensionPrefixFromPath(const string &path);
 
-	//! Apply any known extension aliases
-	static string ApplyExtensionAlias(string extension_name);
+	//! Apply any known extension aliases, return the lowercase name
+	static string ApplyExtensionAlias(const string &extension_name);
 
 	static string GetExtensionName(const string &extension);
 	static bool IsFullPath(const string &extension);
 
 	//! Lookup a name in an ExtensionEntry list
-	template <size_t N>
+	template <idx_t N>
 	static string FindExtensionInEntries(const string &name, const ExtensionEntry (&entries)[N]) {
 		auto lcase = StringUtil::Lower(name);
 
@@ -89,6 +101,20 @@ public:
 		return "";
 	}
 
+	//! Lookup a name in an extension entry and try to autoload it
+	template <idx_t N>
+	static void TryAutoloadFromEntry(DatabaseInstance &db, const string &entry, const ExtensionEntry (&entries)[N]) {
+		auto &dbconfig = DBConfig::GetConfig(db);
+#ifndef DUCKDB_DISABLE_EXTENSION_LOAD
+		if (dbconfig.options.autoload_known_extensions) {
+			auto extension_name = ExtensionHelper::FindExtensionInEntries(entry, entries);
+			if (ExtensionHelper::CanAutoloadExtension(extension_name)) {
+				ExtensionHelper::AutoLoadExtension(db, extension_name);
+			}
+		}
+#endif
+	}
+
 	//! Whether an extension can be autoloaded (i.e. it's registered as an autoloadable extension in
 	//! extension_entries.hpp)
 	static bool CanAutoloadExtension(const string &ext_name);
@@ -99,18 +125,18 @@ public:
 	static string AddExtensionInstallHintToErrorMsg(ClientContext &context, const string &base_error,
 	                                                const string &extension_name);
 
+	//! For tagged releases we use the tag, else we use the git commit hash
+	static const string GetVersionDirectoryName();
+
 private:
-	static void InstallExtensionInternal(DBConfig &config, ClientConfig *client_config, FileSystem &fs,
-	                                     const string &local_path, const string &extension, bool force_install,
-	                                     const string &repository);
+	static void InstallExtensionInternal(DBConfig &config, FileSystem &fs, const string &local_path,
+	                                     const string &extension, bool force_install, const string &repository);
 	static const vector<string> PathComponents();
+	static string DefaultExtensionFolder(FileSystem &fs);
 	static bool AllowAutoInstall(const string &extension);
-	static ExtensionInitResult InitialLoad(DBConfig &config, FileSystem &fs, const string &extension,
-	                                       optional_ptr<const ClientConfig> client_config);
+	static ExtensionInitResult InitialLoad(DBConfig &config, FileSystem &fs, const string &extension);
 	static bool TryInitialLoad(DBConfig &config, FileSystem &fs, const string &extension, ExtensionInitResult &result,
-	                           string &error, optional_ptr<const ClientConfig> client_config);
-	//! For tagged releases we use the tag, else we use the git commit hash
-	static const string GetVersionDirectoryName();
+	                           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 bool IsRelease(const string &version_tag);

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

@@ -11,6 +11,7 @@
 #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"
 
 namespace duckdb {
 struct CreateMacroInfo;
@@ -36,6 +37,10 @@ public:
 	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, PragmaFunction function);
 	//! Register a new pragma function set - throw an exception if the function already exists
 	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, PragmaFunctionSet function);
+
+	//! Register a CreateSecretFunction
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, CreateSecretFunction function);
+
 	//! Register a new copy function - throw an exception if the function already exists
 	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, CopyFunction function);
 	//! Register a new macro function - throw an exception if the function already exists
@@ -51,12 +56,14 @@ public:
 	//! Add a function overload
 	DUCKDB_API static void AddFunctionOverload(DatabaseInstance &db, ScalarFunction function);
 	DUCKDB_API static void AddFunctionOverload(DatabaseInstance &db, ScalarFunctionSet function);
-
 	DUCKDB_API static void AddFunctionOverload(DatabaseInstance &db, TableFunctionSet function);
 
 	//! Registers a new type
 	DUCKDB_API static void RegisterType(DatabaseInstance &db, string type_name, LogicalType type);
 
+	//! Registers a new secret type
+	DUCKDB_API static void RegisterSecretType(DatabaseInstance &db, SecretType secret_type);
+
 	//! Registers a cast between two types
 	DUCKDB_API static void RegisterCastFunction(DatabaseInstance &db, const LogicalType &source,
 	                                            const LogicalType &target, BoundCastInfo function,

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

@@ -27,7 +27,7 @@ public:
 	                                   vector<string> names, unique_ptr<ColumnDataCollection> collection,
 	                                   ClientProperties client_properties);
 	//! Creates an unsuccessful query result with error condition
-	DUCKDB_API explicit MaterializedQueryResult(PreservedError error);
+	DUCKDB_API explicit MaterializedQueryResult(ErrorData error);
 
 public:
 	//! Fetches a DataChunk from the query result.