duckdb 0.8.2-dev37.0 → 0.8.2-dev3989.0

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

@@ -28,7 +28,7 @@
 #include "duckdb/optimizer/optimizer_extension.hpp"
 #include "duckdb/parser/parser_extension.hpp"
 #include "duckdb/planner/operator_extension.hpp"
-#include "duckdb/common/arrow/arrow_options.hpp"
+#include "duckdb/main/client_properties.hpp"
 
 namespace duckdb {
 class BufferPool;
@@ -95,6 +95,18 @@ struct DBConfigOptions {
 	bool use_direct_io = false;
 	//! Whether extensions should be loaded on start-up
 	bool load_extensions = true;
+#ifdef DUCKDB_EXTENSION_AUTOLOAD_DEFAULT
+	//! Whether known extensions are allowed to be automatically loaded when a query depends on them
+	bool autoload_known_extensions = DUCKDB_EXTENSION_AUTOLOAD_DEFAULT;
+#else
+	bool autoload_known_extensions = false;
+#endif
+#ifdef DUCKDB_EXTENSION_AUTOINSTALL_DEFAULT
+	//! Whether known extensions are allowed to be automatically installed when a query depends on them
+	bool autoinstall_known_extensions = DUCKDB_EXTENSION_AUTOINSTALL_DEFAULT;
+#else
+	bool autoinstall_known_extensions = false;
+#endif
 	//! The maximum memory used by the database system (in bytes). Default: 80% of System available memory
 	idx_t maximum_memory = (idx_t)-1;
 	//! The maximum amount of CPU threads used by the database system. Default: all available.
@@ -158,6 +170,8 @@ struct DBConfigOptions {
 	bool lock_configuration = false;
 	//! Whether to print bindings when printing the plan (debug mode only)
 	static bool debug_print_bindings;
+	//! The peak allocation threshold at which to flush the allocator after completing a task (1 << 27, ~128MB)
+	idx_t allocator_flush_threshold = 134217728;
 
 	bool operator==(const DBConfigOptions &other) const;
 };
@@ -234,6 +248,7 @@ public:
 	bool operator!=(const DBConfig &other);
 
 	DUCKDB_API CastFunctionSet &GetCastFunctions();
+	static idx_t GetSystemMaxThreads(FileSystem &fs);
 	void SetDefaultMaxThreads();
 	void SetDefaultMaxMemory();
 

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

@@ -30,7 +30,7 @@ class DatabaseInstance;
 class DuckDB;
 class LogicalOperator;
 class SelectStatement;
-struct BufferedCSVReaderOptions;
+struct CSVReaderOptions;
 
 typedef void (*warning_callback)(std::string);
 
@@ -131,7 +131,7 @@ public:
 
 	//! Reads CSV file
 	DUCKDB_API shared_ptr<Relation> ReadCSV(const string &csv_file);
-	DUCKDB_API shared_ptr<Relation> ReadCSV(const string &csv_file, BufferedCSVReaderOptions &options);
+	DUCKDB_API shared_ptr<Relation> ReadCSV(const string &csv_file, CSVReaderOptions &options);
 	DUCKDB_API shared_ptr<Relation> ReadCSV(const string &csv_file, const vector<string> &columns);
 
 	//! Reads Parquet file
@@ -169,8 +169,7 @@ public:
 	template <typename TR, typename... Args>
 	void CreateScalarFunction(const string &name, vector<LogicalType> args, LogicalType ret_type,
 	                          TR (*udf_func)(Args...)) {
-		scalar_function_t function =
-		    UDFWrapper::CreateScalarFunction<TR, Args...>(name, args, std::move(ret_type), udf_func);
+		scalar_function_t function = UDFWrapper::CreateScalarFunction<TR, Args...>(name, args, ret_type, udf_func);
 		UDFWrapper::RegisterFunction(name, args, ret_type, function, *context);
 	}
 

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

@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/extension/generated_extension_loader.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/main/database.hpp"
+#include "duckdb/common/string.hpp"
+#include "duckdb/common/vector.hpp"
+
+#if defined(GENERATED_EXTENSION_HEADERS) and !defined(DUCKDB_AMALGAMATION)
+#include "generated_extension_headers.hpp"
+#include "duckdb/common/common.hpp"
+
+namespace duckdb {
+
+//! Looks through the CMake-generated list of extensions that are linked into DuckDB currently to try load <extension>
+bool TryLoadLinkedExtension(DuckDB &db, const string &extension);
+extern vector<string> linked_extensions;
+extern vector<string> loaded_extension_test_paths;
+
+} // namespace duckdb
+#endif

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

@@ -10,6 +10,9 @@
 
 #include "duckdb/common/unordered_map.hpp"
 
+// NOTE: this file is generated by scripts/generate_extensions_function.py. Check out the check-load-install-extensions
+//       job in .github/workflows/LinuxRelease.yml on how to use it
+
 namespace duckdb {
 
 struct ExtensionEntry {
@@ -17,157 +20,172 @@ 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"},
-                                                         {"get_substrait", "substrait"},
-                                                         {"get_substrait_json", "substrait"},
-                                                         {"icu_calendar_names", "icu"},
-                                                         {"icu_sort_key", "icu"},
-                                                         {"json", "json"},
-                                                         {"json_array", "json"},
-                                                         {"json_array_length", "json"},
-                                                         {"json_contains", "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_structure", "json"},
-                                                         {"json_transform", "json"},
-                                                         {"json_transform_strict", "json"},
-                                                         {"json_type", "json"},
-                                                         {"json_valid", "json"},
-                                                         {"json_serialize_sql", "json"},
-                                                         {"json_deserialize_sql", "json"},
-                                                         {"json_serialize_sql", "json"},
-                                                         {"json_execute_serialized_sql", "json"},
-                                                         {"make_timestamptz", "icu"},
-                                                         {"parquet_metadata", "parquet"},
-                                                         {"parquet_scan", "parquet"},
-                                                         {"parquet_schema", "parquet"},
-                                                         {"pg_timezone_names", "icu"},
-                                                         {"postgres_attach", "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"},
-                                                         {"row_to_json", "json"},
-                                                         {"scan_arrow_ipc", "arrow"},
-                                                         {"sqlite_attach", "sqlite_scanner"},
-                                                         {"sqlite_scan", "sqlite_scanner"},
-                                                         {"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"},
-                                                         {"st_distance_spheroid", "spatial"},
-                                                         {"st_boundary", "spatial"},
-                                                         {"st_makeline", "spatial"},
-                                                         {"st_buffer", "spatial"},
-                                                         {"st_x", "spatial"},
-                                                         {"st_isring", "spatial"},
-                                                         {"st_centroid", "spatial"},
-                                                         {"st_read", "spatial"},
-                                                         {"st_geomfromwkb", "spatial"},
-                                                         {"st_list_proj_crs", "spatial"},
-                                                         {"st_isvalid", "spatial"},
-                                                         {"st_polygon2dfromwkb", "spatial"},
-                                                         {"st_disjoint", "spatial"},
-                                                         {"st_length", "spatial"},
-                                                         {"st_difference", "spatial"},
-                                                         {"st_area", "spatial"},
-                                                         {"st_union", "spatial"},
-                                                         {"st_isclosed", "spatial"},
-                                                         {"st_asgeojson", "spatial"},
-                                                         {"st_intersection", "spatial"},
-                                                         {"st_transform", "spatial"},
-                                                         {"st_dwithin", "spatial"},
-                                                         {"st_perimeter", "spatial"},
-                                                         {"st_issimple", "spatial"},
-                                                         {"st_geometrytype", "spatial"},
-                                                         {"st_simplifypreservetopology", "spatial"},
-                                                         {"st_distance", "spatial"},
-                                                         {"st_astext", "spatial"},
-                                                         {"st_overlaps", "spatial"},
-                                                         {"st_convexhull", "spatial"},
-                                                         {"st_normalize", "spatial"},
-                                                         {"st_drivers", "spatial"},
-                                                         {"st_point2dfromwkb", "spatial"},
-                                                         {"st_point2d", "spatial"},
-                                                         {"st_y", "spatial"},
-                                                         {"st_dwithin_spheroid", "spatial"},
-                                                         {"st_isempty", "spatial"},
-                                                         {"st_simplify", "spatial"},
-                                                         {"st_area_spheroid", "spatial"},
-                                                         {"st_within", "spatial"},
-                                                         {"st_length_spheroid", "spatial"},
-                                                         {"st_point3d", "spatial"},
-                                                         {"st_containsproperly", "spatial"},
-                                                         {"st_contains", "spatial"},
-                                                         {"st_collect", "spatial"},
-                                                         {"st_touches", "spatial"},
-                                                         {"st_linestring2dfromwkb", "spatial"},
-                                                         {"st_flipcoordinates", "spatial"},
-                                                         {"st_ashexwkb", "spatial"},
-                                                         {"st_geomfromtext", "spatial"},
-                                                         {"st_point4d", "spatial"},
-                                                         {"st_point", "spatial"},
-                                                         {"st_coveredby", "spatial"},
-                                                         {"st_perimeter_spheroid", "spatial"},
-                                                         {"st_intersects", "spatial"},
-                                                         {"st_crosses", "spatial"},
-                                                         {"st_covers", "spatial"},
-                                                         {"st_envelope", "spatial"},
-                                                         {"st_aswkb", "spatial"},
-                                                         {"st_equals", "spatial"},
-                                                         {"st_collectionextract", "spatial"},
-                                                         {"st_npoints", "spatial"},
-                                                         {"st_pointonsurface", "spatial"},
-                                                         {"st_dimension", "spatial"},
-                                                         {"st_removerepeatedpoints", "spatial"},
-                                                         {"st_geomfromgeojson", "spatial"},
-                                                         {"st_readosm", "spatial"},
-                                                         {"st_numpoints", "spatial"}};
+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_timezone_names", "icu"},
+    {"postgres_attach", "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_dwithin", "spatial"},
+    {"st_dwithin_spheroid", "spatial"},
+    {"st_envelope", "spatial"},
+    {"st_equals", "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_intersects", "spatial"},
+    {"st_isclosed", "spatial"},
+    {"st_isempty", "spatial"},
+    {"st_isring", "spatial"},
+    {"st_issimple", "spatial"},
+    {"st_isvalid", "spatial"},
+    {"st_length", "spatial"},
+    {"st_length_spheroid", "spatial"},
+    {"st_linestring2dfromwkb", "spatial"},
+    {"st_list_proj_crs", "spatial"},
+    {"st_makeline", "spatial"},
+    {"st_normalize", "spatial"},
+    {"st_npoints", "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_pointonsurface", "spatial"},
+    {"st_polygon2dfromwkb", "spatial"},
+    {"st_read", "spatial"},
+    {"st_readosm", "spatial"},
+    {"st_reduceprecision", "spatial"},
+    {"st_removerepeatedpoints", "spatial"},
+    {"st_simplify", "spatial"},
+    {"st_simplifypreservetopology", "spatial"},
+    {"st_touches", "spatial"},
+    {"st_transform", "spatial"},
+    {"st_union", "spatial"},
+    {"st_within", "spatial"},
+    {"st_x", "spatial"},
+    {"st_y", "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_SETTINGS[] = {
+    {"azure_storage_connection_string", "azure"},
     {"binary_as_string", "parquet"},
     {"calendar", "icu"},
+    {"force_download", "httpfs"},
     {"http_retries", "httpfs"},
     {"http_retry_backoff", "httpfs"},
     {"http_retry_wait_ms", "httpfs"},
     {"http_timeout", "httpfs"},
-    {"force_download", "httpfs"},
     {"s3_access_key_id", "httpfs"},
     {"s3_endpoint", "httpfs"},
     {"s3_region", "httpfs"},
@@ -181,5 +199,53 @@ static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
     {"s3_use_ssl", "httpfs"},
     {"sqlite_all_varchar", "sqlite_scanner"},
     {"timezone", "icu"},
-};
+}; // END_OF_EXTENSION_SETTINGS
+
+// Note: these are currently hardcoded in scripts/generate_extensions_function.py
+// TODO: automate by passing though to script via duckdb
+static constexpr ExtensionEntry EXTENSION_COPY_FUNCTIONS[] = {{"parquet", "parquet"},
+                                                              {"json", "json"}}; // END_OF_EXTENSION_COPY_FUNCTIONS
+
+// Note: these are currently hardcoded in scripts/generate_extensions_function.py
+// TODO: automate by passing though to script via duckdb
+static constexpr ExtensionEntry EXTENSION_TYPES[] = {
+    {"json", "json"}, {"inet", "inet"}, {"geometry", "spatial"}}; // END_OF_EXTENSION_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_FILE_PREFIXES[] = {
+    {"http://", "httpfs"}, {"https://", "httpfs"}, {"s3://", "httpfs"},
+    //    {"azure://", "azure"}
+}; // END_OF_EXTENSION_FILE_PREFIXES
+
+// 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_POSTFIXES[] = {{".parquet", "parquet"},
+                                                              {".json", "json"},
+                                                              {".jsonl", "json"},
+                                                              {".ndjson", "json"}}; // END_OF_EXTENSION_FILE_POSTFIXES
+
+// 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_CONTAINS[] = {{".parquet?", "parquet"},
+                                                             {".json?", "json"},
+                                                             {".ndjson?", ".jsonl?"},
+                                                             {".jsonl?", ".ndjson?"}}; // EXTENSION_FILE_CONTAINS
+
+static constexpr const char *AUTOLOADABLE_EXTENSIONS[] = {
+    //    "azure",
+    "autocomplete",
+    "excel",
+    "fts",
+    "httpfs",
+    // "inet",
+    // "icu",
+    "json",
+    "parquet",
+    "sqlsmith",
+    "tpcds",
+    "tpch",
+    "visualizer",
+}; // END_OF_AUTOLOADABLE_EXTENSIONS
+
 } // namespace duckdb

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

@@ -10,6 +10,7 @@
 
 #include <string>
 #include "duckdb.hpp"
+#include "duckdb/main/extension_entries.hpp"
 
 namespace duckdb {
 class DuckDB;
@@ -40,13 +41,21 @@ public:
 
 	static ExtensionLoadResult LoadExtension(DuckDB &db, const std::string &extension);
 
-	static void InstallExtension(ClientContext &context, const string &extension, bool force_install);
-	static void InstallExtension(DBConfig &config, FileSystem &fs, const string &extension, bool force_install);
+	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 = "");
 	static void LoadExternalExtension(ClientContext &context, const string &extension);
-	static void LoadExternalExtension(DatabaseInstance &db, FileSystem &fs, const string &extension);
+	static void LoadExternalExtension(DatabaseInstance &db, FileSystem &fs, const string &extension,
+	                                  optional_ptr<const ClientConfig> client_config);
+
+	//! Autoload an extension by name. Depending on the current settings, this will either load or install+load
+	static void AutoLoadExtension(ClientContext &context, const string &extension_name);
 
 	static string ExtensionDirectory(ClientContext &context);
 	static string ExtensionDirectory(DBConfig &config, FileSystem &fs);
+	static string ExtensionUrlTemplate(optional_ptr<const ClientConfig> config, const string &repository);
+	static string ExtensionFinalizeUrlTemplate(const string &url, const string &name);
 
 	static idx_t DefaultExtensionCount();
 	static DefaultExtension GetDefaultExtension(idx_t index);
@@ -65,14 +74,40 @@ public:
 	static string GetExtensionName(const string &extension);
 	static bool IsFullPath(const string &extension);
 
+	//! Lookup a name in an ExtensionEntry list
+	template <size_t N>
+	static string FindExtensionInEntries(const string &name, const ExtensionEntry (&entries)[N]) {
+		auto lcase = StringUtil::Lower(name);
+
+		auto it =
+		    std::find_if(entries, entries + N, [&](const ExtensionEntry &element) { return element.name == lcase; });
+
+		if (it != entries + N && it->name == lcase) {
+			return it->extension;
+		}
+		return "";
+	}
+
+	//! 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);
+
+	//! Utility functions for creating meaningful error messages regarding missing extensions
+	static string WrapAutoLoadExtensionErrorMsg(ClientContext &context, const string &base_error,
+	                                            const string &extension_name);
+	static string AddExtensionInstallHintToErrorMsg(ClientContext &context, const string &base_error,
+	                                                const string &extension_name);
+
 private:
 	static void InstallExtensionInternal(DBConfig &config, ClientConfig *client_config, FileSystem &fs,
-	                                     const string &local_path, const string &extension, bool force_install);
+	                                     const string &local_path, const string &extension, bool force_install,
+	                                     const string &repository);
 	static const vector<string> PathComponents();
 	static bool AllowAutoInstall(const string &extension);
-	static ExtensionInitResult InitialLoad(DBConfig &config, FileSystem &fs, const string &extension);
+	static ExtensionInitResult InitialLoad(DBConfig &config, FileSystem &fs, const string &extension,
+	                                       optional_ptr<const ClientConfig> client_config);
 	static bool TryInitialLoad(DBConfig &config, FileSystem &fs, const string &extension, ExtensionInitResult &result,
-	                           string &error);
+	                           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();
 	//! Version tags occur with and without 'v', tag in extension path is always with 'v'

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

@@ -23,6 +23,10 @@ public:
 	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, ScalarFunction function);
 	//! Register a new scalar function set - throw an exception if the function already exists
 	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, ScalarFunctionSet function);
+	//! Register a new aggregate function - throw an exception if the function already exists
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, AggregateFunction function);
+	//! Register a new aggregate function set - throw an exception if the function already exists
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, AggregateFunctionSet function);
 	//! Register a new table function - throw an exception if the function already exists
 	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, TableFunction function);
 	//! Register a new table function set - throw an exception if the function already exists

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

@@ -34,6 +34,8 @@ public:
 	//! If this returns RESULT_READY, the Execute function can be called to obtain a pointer to the result.
 	//! If this returns RESULT_NOT_READY, the ExecuteTask function should be called again.
 	//! If this returns EXECUTION_ERROR, an error occurred during execution.
+	//! If this returns NO_TASKS_AVAILABLE, this means currently no meaningful work can be done by the current executor,
+	//!	    but tasks may become available in the future.
 	//! The error message can be obtained by calling GetError() on the PendingQueryResult.
 	DUCKDB_API PendingExecutionResult ExecuteTask();
 
@@ -43,6 +45,9 @@ public:
 
 	DUCKDB_API void Close();
 
+	//! Function to determine whether execution is considered finished
+	DUCKDB_API static bool IsFinished(PendingExecutionResult result);
+
 private:
 	shared_ptr<ClientContext> context;
 	bool allow_stream_result;