duckdb 1.0.1-dev22.0 → 1.0.1-dev27.0

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

@@ -25,6 +25,7 @@ class CatalogSet;
 class ClientContext;
 class DatabaseInstance;
 class TaskScheduler;
+struct AttachOptions;
 
 //! The DatabaseManager is a class that sits at the root of all attached databases
 class DatabaseManager {
@@ -39,12 +40,13 @@ public:
 	static DatabaseManager &Get(ClientContext &db);
 	static DatabaseManager &Get(AttachedDatabase &db);
 
+	//! Initializes the system catalog of the attached SYSTEM_DATABASE.
 	void InitializeSystemCatalog();
 	//! Get an attached database by its name
 	optional_ptr<AttachedDatabase> GetDatabase(ClientContext &context, const string &name);
 	//! Attach a new database
-	optional_ptr<AttachedDatabase> AttachDatabase(ClientContext &context, const AttachInfo &info, const string &db_type,
-	                                              AccessMode access_mode);
+	optional_ptr<AttachedDatabase> AttachDatabase(ClientContext &context, const AttachInfo &info,
+	                                              const AttachOptions &options);
 	//! Detach an existing database
 	void DetachDatabase(ClientContext &context, const string &name, OnEntryNotFound if_not_found);
 	//! Returns a reference to the system catalog
@@ -61,8 +63,7 @@ public:
 	//! 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
 	//! to lock for this operation.
-	void GetDatabaseType(ClientContext &context, string &db_type, AttachInfo &info, const DBConfig &config,
-	                     const string &unrecognized_option);
+	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);
@@ -76,8 +77,8 @@ public:
 	transaction_t ActiveQueryNumber() const {
 		return current_query_number;
 	}
-	idx_t ModifyCatalog() {
-		return catalog_version++;
+	idx_t NextOid() {
+		return next_oid++;
 	}
 	bool HasDefaultDatabase() {
 		return !default_database.empty();
@@ -93,8 +94,8 @@ private:
 	unique_ptr<AttachedDatabase> system;
 	//! The set of attached databases
 	unique_ptr<CatalogSet> databases;
-	//! The global catalog version, incremented whenever anything changes in the catalog
-	atomic<idx_t> catalog_version;
+	//! The next object id handed out by the NextOid method
+	atomic<idx_t> next_oid;
 	//! The current query number
 	atomic<transaction_t> current_query_number;
 	//! The current default database

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

@@ -12,29 +12,44 @@
 #include "duckdb/main/database.hpp"
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/function/replacement_scan.hpp"
+#include <functional>
 
 namespace duckdb {
+class DBInstanceCache;
+
+struct DatabaseCacheEntry {
+	explicit DatabaseCacheEntry(const shared_ptr<DuckDB> &database);
+	~DatabaseCacheEntry();
+
+	weak_ptr<DuckDB> database;
+};
+
 class DBInstanceCache {
 public:
-	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);
 
 	//! Creates and caches a new DB Instance (Fails if a cached instance already exists)
-	shared_ptr<DuckDB> CreateInstance(const string &database, DBConfig &config_dict, bool cache_instance = true);
+	shared_ptr<DuckDB> CreateInstance(const string &database, DBConfig &config_dict, bool cache_instance = true,
+	                                  const std::function<void(DuckDB &)> &on_create = nullptr);
 
-	//! Creates and caches a new DB Instance (Fails if a cached instance already exists)
-	shared_ptr<DuckDB> GetOrCreateInstance(const string &database, DBConfig &config_dict, bool cache_instance);
+	//! Either returns an existing entry, or creates and caches a new DB Instance
+	shared_ptr<DuckDB> GetOrCreateInstance(const string &database, DBConfig &config_dict, bool cache_instance,
+	                                       const std::function<void(DuckDB &)> &on_create = nullptr);
 
 private:
 	//! A map with the cached instances <absolute_path/instance>
-	unordered_map<string, weak_ptr<DuckDB>> db_instances;
+	unordered_map<string, weak_ptr<DatabaseCacheEntry>> db_instances;
 
 	//! Lock to alter cache
 	mutex cache_lock;
 
 private:
 	shared_ptr<DuckDB> GetInstanceInternal(const string &database, const DBConfig &config_dict);
-	shared_ptr<DuckDB> CreateInstanceInternal(const string &database, DBConfig &config_dict, bool cache_instance);
+	shared_ptr<DuckDB> CreateInstanceInternal(const string &database, DBConfig &config_dict, bool cache_instance,
+	                                          const std::function<void(DuckDB &)> &on_create);
 };
 } // namespace duckdb

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

@@ -26,6 +26,12 @@ public:
 	}
 };
 
+enum class ExtensionABIType : uint8_t {
+	UNKNOWN = 0,
+	CPP = 1,
+	C_STRUCT = 2,
+};
+
 //! The parsed extension metadata footer
 struct ParsedExtensionMetaData {
 	static constexpr const idx_t FOOTER_SIZE = 512;
@@ -35,8 +41,13 @@ struct ParsedExtensionMetaData {
 
 	string magic_value;
 
+	ExtensionABIType abi_type;
+
 	string platform;
+	// (only for ExtensionABIType::CPP) the DuckDB version this extension is compiled for
 	string duckdb_version;
+	// (only for ExtensionABIType::C_STRUCT) the CAPI version of the C_STRUCT
+	string duckdb_capi_version;
 	string extension_version;
 	string signature;
 
@@ -48,4 +59,13 @@ struct ParsedExtensionMetaData {
 	string GetInvalidMetadataError();
 };
 
+struct VersioningUtils {
+	//! Note: only supports format v{major}.{minor}.{patch}
+	static bool ParseSemver(string &semver, idx_t &major_out, idx_t &minor_out, idx_t &patch_out);
+
+	//! Note: only supports format v{major}.{minor}.{patch}
+	static bool IsSupportedCAPIVersion(string &capi_version_string);
+	static bool IsSupportedCAPIVersion(idx_t major, idx_t minor, idx_t patch);
+};
+
 } // namespace duckdb

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

@@ -29,8 +29,12 @@ struct ExtensionFunctionEntry {
 
 static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"->>", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"<<=", "inet", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {">>=", "inet", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"add_numbers_together", "demo_capi", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"add_parquet_key", "parquet", CatalogType::PRAGMA_FUNCTION_ENTRY},
     {"array_to_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"broadcast", "inet", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"create_fts_index", "fts", CatalogType::PRAGMA_FUNCTION_ENTRY},
     {"current_localtime", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"current_localtimestamp", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
@@ -51,6 +55,8 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"hnsw_compact_index", "vss", CatalogType::PRAGMA_FUNCTION_ENTRY},
     {"hnsw_index_scan", "vss", CatalogType::TABLE_FUNCTION_ENTRY},
     {"host", "inet", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"html_escape", "inet", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"html_unescape", "inet", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"iceberg_metadata", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY},
     {"iceberg_scan", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY},
     {"iceberg_snapshots", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY},
@@ -138,6 +144,7 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"icu_collate_ne", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"icu_collate_nl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"icu_collate_nn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"icu_collate_noaccent", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"icu_collate_om", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"icu_collate_or", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"icu_collate_pa", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
@@ -193,6 +200,7 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"json_deserialize_sql", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"json_execute_serialized_sql", "json", CatalogType::PRAGMA_FUNCTION_ENTRY},
     {"json_execute_serialized_sql", "json", CatalogType::TABLE_FUNCTION_ENTRY},
+    {"json_exists", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"json_extract", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"json_extract_path", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"json_extract_path_text", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
@@ -203,6 +211,7 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"json_keys", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"json_merge_patch", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"json_object", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"json_pretty", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"json_quote", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"json_serialize_plan", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"json_serialize_sql", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
@@ -211,11 +220,14 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"json_transform_strict", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"json_type", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"json_valid", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"json_value", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"load_aws_credentials", "aws", CatalogType::TABLE_FUNCTION_ENTRY},
     {"make_timestamptz", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"mysql_clear_cache", "mysql_scanner", CatalogType::TABLE_FUNCTION_ENTRY},
     {"mysql_execute", "mysql_scanner", CatalogType::TABLE_FUNCTION_ENTRY},
     {"mysql_query", "mysql_scanner", CatalogType::TABLE_FUNCTION_ENTRY},
+    {"netmask", "inet", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"network", "inet", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"parquet_file_metadata", "parquet", CatalogType::TABLE_FUNCTION_ENTRY},
     {"parquet_kv_metadata", "parquet", CatalogType::TABLE_FUNCTION_ENTRY},
     {"parquet_metadata", "parquet", CatalogType::TABLE_FUNCTION_ENTRY},
@@ -229,6 +241,7 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"postgres_scan", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY},
     {"postgres_scan_pushdown", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY},
     {"pragma_hnsw_index_info", "vss", CatalogType::TABLE_FUNCTION_ENTRY},
+    {"pragma_rtree_index_info", "spatial", CatalogType::TABLE_FUNCTION_ENTRY},
     {"read_json", "json", CatalogType::TABLE_FUNCTION_ENTRY},
     {"read_json_auto", "json", CatalogType::TABLE_FUNCTION_ENTRY},
     {"read_json_objects", "json", CatalogType::TABLE_FUNCTION_ENTRY},
@@ -239,6 +252,8 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"read_parquet", "parquet", CatalogType::TABLE_FUNCTION_ENTRY},
     {"reduce_sql_statement", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY},
     {"row_to_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"rtree_index_dump", "spatial", CatalogType::TABLE_FUNCTION_ENTRY},
+    {"rtree_index_scan", "spatial", CatalogType::TABLE_FUNCTION_ENTRY},
     {"scan_arrow_ipc", "arrow", CatalogType::TABLE_FUNCTION_ENTRY},
     {"shapefile_meta", "spatial", CatalogType::TABLE_FUNCTION_ENTRY},
     {"sql_auto_complete", "autocomplete", CatalogType::TABLE_FUNCTION_ENTRY},
@@ -249,6 +264,7 @@ 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_assvg", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_astext", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_aswkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_boundary", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
@@ -277,18 +293,22 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"st_envelope_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY},
     {"st_equals", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_extent", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"st_extent_approx", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_exteriorring", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_flipcoordinates", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_force2d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_force3dm", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_force3dz", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_force4d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"st_generatepoints", "spatial", CatalogType::TABLE_FUNCTION_ENTRY},
     {"st_geometrytype", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_geomfromgeojson", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_geomfromhexewkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_geomfromhexwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_geomfromtext", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_geomfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"st_hasm", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"st_hasz", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_hilbert", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_intersection", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_intersection_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY},
@@ -328,6 +348,7 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"st_point4d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_pointn", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_pointonsurface", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"st_points", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_polygon2dfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_quadkey", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_read", "spatial", CatalogType::TABLE_FUNCTION_ENTRY},
@@ -354,6 +375,7 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"st_ymin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_z", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_zmax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"st_zmflag", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_zmin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"stem", "fts", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"text", "excel", CatalogType::SCALAR_FUNCTION_ENTRY},
@@ -365,6 +387,8 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"tpch", "tpch", CatalogType::PRAGMA_FUNCTION_ENTRY},
     {"tpch_answers", "tpch", CatalogType::TABLE_FUNCTION_ENTRY},
     {"tpch_queries", "tpch", CatalogType::TABLE_FUNCTION_ENTRY},
+    {"vss_join", "vss", CatalogType::TABLE_MACRO_ENTRY},
+    {"vss_match", "vss", CatalogType::TABLE_MACRO_ENTRY},
 }; // END_OF_EXTENSION_FUNCTIONS
 
 static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
@@ -403,6 +427,7 @@ static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
     {"pg_connection_limit", "postgres_scanner"},
     {"pg_debug_show_queries", "postgres_scanner"},
     {"pg_experimental_filter_pushdown", "postgres_scanner"},
+    {"pg_null_byte_replacement", "postgres_scanner"},
     {"pg_pages_per_task", "postgres_scanner"},
     {"pg_use_binary_copy", "postgres_scanner"},
     {"pg_use_ctid_scan", "postgres_scanner"},

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

@@ -14,8 +14,6 @@
 
 #include <string>
 
-#include <string>
-
 namespace duckdb {
 
 class DuckDB;
@@ -78,6 +76,20 @@ struct ExtensionUpdateResult {
 	string installed_version;
 };
 
+struct ExtensionInstallOptions {
+	//! Install from a different repository that the default one
+	optional_ptr<ExtensionRepository> repository;
+	//! Install a specific version of the extension
+	string version;
+
+	//! Overwrite existing installation
+	bool force_install = false;
+	//! Use etags to avoid downloading unchanged extension files
+	bool use_etags = false;
+	//! Throw an error when installing an extension with a different origin than the one that is installed
+	bool throw_on_origin_mismatch = false;
+};
+
 class ExtensionHelper {
 public:
 	static void LoadAllExtensions(DuckDB &db);
@@ -86,15 +98,9 @@ public:
 
 	//! Install an extension
 	static unique_ptr<ExtensionInstallInfo> InstallExtension(ClientContext &context, const string &extension,
-	                                                         bool force_install,
-	                                                         optional_ptr<ExtensionRepository> repository = nullptr,
-	                                                         bool throw_on_origin_mismatch = false,
-	                                                         const string &version = "");
-	static unique_ptr<ExtensionInstallInfo> InstallExtension(DBConfig &config, FileSystem &fs, const string &extension,
-	                                                         bool force_install,
-	                                                         optional_ptr<ExtensionRepository> repository = nullptr,
-	                                                         bool throw_on_origin_mismatch = false,
-	                                                         const string &version = "");
+	                                                         ExtensionInstallOptions &options);
+	static unique_ptr<ExtensionInstallInfo> InstallExtension(DatabaseInstance &db, FileSystem &fs,
+	                                                         const string &extension, ExtensionInstallOptions &options);
 	//! Load an extension
 	static void LoadExternalExtension(ClientContext &context, const string &extension);
 	static void LoadExternalExtension(DatabaseInstance &db, FileSystem &fs, const string &extension);
@@ -104,18 +110,17 @@ public:
 	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(DatabaseInstance &db, const string &extension_name) noexcept;
 	DUCKDB_API static bool TryAutoLoadExtension(ClientContext &context, const string &extension_name) noexcept;
 
 	//! Update all extensions, return a vector of extension names that were updated;
 	static vector<ExtensionUpdateResult> UpdateExtensions(ClientContext &context);
-	static vector<ExtensionUpdateResult> UpdateExtensions(DatabaseInstance &db, FileSystem &fs);
 	//! Update a specific extension
 	static ExtensionUpdateResult UpdateExtension(ClientContext &context, const string &extension_name);
-	static ExtensionUpdateResult UpdateExtension(DatabaseInstance &db, FileSystem &fs, const string &extension_name);
 
 	//! Get the extension directory base on the current config
 	static string ExtensionDirectory(ClientContext &context);
-	static string ExtensionDirectory(DBConfig &config, FileSystem &fs);
+	static string ExtensionDirectory(DatabaseInstance &db, FileSystem &fs);
 
 	static bool CheckExtensionSignature(FileHandle &handle, ParsedExtensionMetaData &parsed_metadata,
 	                                    const bool allow_community_extensions);
@@ -123,7 +128,7 @@ public:
 	static ParsedExtensionMetaData ParseExtensionMetaData(FileHandle &handle);
 
 	//! Get the extension url template, containing placeholders for version, platform and extension name
-	static string ExtensionUrlTemplate(optional_ptr<const DBConfig> config, const ExtensionRepository &repository,
+	static string ExtensionUrlTemplate(optional_ptr<const DatabaseInstance> db, const ExtensionRepository &repository,
 	                                   const string &version);
 	//! Return the extension url template with the variables replaced
 	static string ExtensionFinalizeUrlTemplate(const string &url, const string &name);
@@ -205,7 +210,7 @@ public:
 	                                            const string &extension_name);
 	static string AddExtensionInstallHintToErrorMsg(ClientContext &context, const string &base_error,
 	                                                const string &extension_name);
-	static string AddExtensionInstallHintToErrorMsg(DBConfig &config, const string &base_error,
+	static string AddExtensionInstallHintToErrorMsg(DatabaseInstance &db, const string &base_error,
 	                                                const string &extension_name);
 
 	//! For tagged releases we use the tag, else we use the git commit hash
@@ -215,16 +220,17 @@ public:
 	static bool CreateSuggestions(const string &extension_name, string &message);
 
 private:
-	static unique_ptr<ExtensionInstallInfo> InstallExtensionInternal(
-	    DBConfig &config, FileSystem &fs, const string &local_path, const string &extension, bool force_install,
-	    bool throw_on_origin_mismatch, const string &version, optional_ptr<ExtensionRepository> repository,
-	    optional_ptr<HTTPLogger> http_logger = nullptr, optional_ptr<ClientContext> context = nullptr);
+	static unique_ptr<ExtensionInstallInfo> InstallExtensionInternal(DatabaseInstance &db, FileSystem &fs,
+	                                                                 const string &local_path, const string &extension,
+	                                                                 ExtensionInstallOptions &options,
+	                                                                 optional_ptr<HTTPLogger> http_logger = nullptr,
+	                                                                 optional_ptr<ClientContext> context = nullptr);
 	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);
-	static bool TryInitialLoad(DBConfig &config, FileSystem &fs, const string &extension, ExtensionInitResult &result,
-	                           string &error);
+	static ExtensionInitResult InitialLoad(DatabaseInstance &db, FileSystem &fs, const string &extension);
+	static bool TryInitialLoad(DatabaseInstance &db, FileSystem &fs, const string &extension,
+	                           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);
 

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

@@ -27,6 +27,10 @@ enum class ExtensionInstallMode : uint8_t {
 	NOT_INSTALLED = 4
 };
 
+struct ExtensionLoadedInfo {
+	string description;
+};
+
 class ExtensionInstallInfo {
 public:
 	//! How the extension was installed
@@ -37,6 +41,8 @@ public:
 	string repository_url;
 	//! (optional) Version of the extension
 	string version;
+	//! (optional) ETag of last fetched resource
+	string etag;
 
 	void Serialize(Serializer &serializer) const;
 

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

@@ -13,6 +13,7 @@
 #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"
 
 namespace duckdb {
 struct CreateMacroInfo;
@@ -22,6 +23,8 @@ class DatabaseInstance;
 //! The ExtensionUtil class contains methods that are useful for extensions
 class ExtensionUtil {
 public:
+	//! Register a new DuckDB extension
+	DUCKDB_API static void RegisterExtension(DatabaseInstance &db, const string &name, const ExtensionLoadedInfo &info);
 	//! Register a new scalar function - throw an exception if the function already exists
 	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, ScalarFunction function);
 	//! Register a new scalar function set - throw an exception if the function already exists

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

@@ -40,6 +40,8 @@ public:
 	//! The error message can be obtained by calling GetError() on the PendingQueryResult.
 	DUCKDB_API PendingExecutionResult ExecuteTask();
 	DUCKDB_API PendingExecutionResult CheckPulse();
+	//! Halt execution of the thread until a Task is ready to be executed (use with caution)
+	void WaitForTask();
 
 	//! Returns the result of the query as an actual query result.
 	//! This returns (mostly) instantly if ExecuteTask has been called until RESULT_READY was returned.
@@ -48,8 +50,8 @@ public:
 	DUCKDB_API void Close();
 
 	//! Function to determine whether execution is considered finished
-	DUCKDB_API static bool IsFinished(PendingExecutionResult result);
-	DUCKDB_API static bool IsFinishedOrBlocked(PendingExecutionResult result);
+	DUCKDB_API static bool IsResultReady(PendingExecutionResult result);
+	DUCKDB_API static bool IsExecutionFinished(PendingExecutionResult result);
 
 private:
 	shared_ptr<ClientContext> context;

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

@@ -13,6 +13,7 @@
 #include "duckdb/main/pending_query_result.hpp"
 #include "duckdb/common/error_data.hpp"
 #include "duckdb/common/case_insensitive_map.hpp"
+#include "duckdb/planner/expression/bound_parameter_data.hpp"
 
 namespace duckdb {
 class ClientContext;
@@ -23,7 +24,7 @@ class PreparedStatement {
 public:
 	//! Create a successfully prepared prepared statement object with the given name
 	DUCKDB_API PreparedStatement(shared_ptr<ClientContext> context, shared_ptr<PreparedStatementData> data,
-	                             string query, idx_t n_param, case_insensitive_map_t<idx_t> named_param_map);
+	                             string query, case_insensitive_map_t<idx_t> named_param_map);
 	//! Create a prepared statement that was not successfully prepared
 	DUCKDB_API explicit PreparedStatement(ErrorData error);
 
@@ -40,9 +41,7 @@ public:
 	bool success;
 	//! The error message (if success = false)
 	ErrorData error;
-	//! The amount of bound parameters
-	idx_t n_param;
-	//! The (optional) named parameters
+	//! The parameter mapping
 	case_insensitive_map_t<idx_t> named_param_map;
 
 public:
@@ -76,14 +75,14 @@ public:
 	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(vector<Value> &values, bool allow_stream_result = true);
 
 	//! Create a pending query result of the prepared statement with the given set named arguments
-	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(case_insensitive_map_t<Value> &named_values,
+	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(case_insensitive_map_t<BoundParameterData> &named_values,
 	                                                       bool allow_stream_result = true);
 
 	//! Execute the prepared statement with the given set of values
 	DUCKDB_API unique_ptr<QueryResult> Execute(vector<Value> &values, bool allow_stream_result = true);
 
 	//! Execute the prepared statement with the given set of named+unnamed values
-	DUCKDB_API unique_ptr<QueryResult> Execute(case_insensitive_map_t<Value> &named_values,
+	DUCKDB_API unique_ptr<QueryResult> Execute(case_insensitive_map_t<BoundParameterData> &named_values,
 	                                           bool allow_stream_result = true);
 
 	//! Execute the prepared statement with the given set of arguments

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

@@ -41,9 +41,6 @@ public:
 	//! The statement properties
 	StatementProperties properties;
 
-	//! The catalog version of when the prepared statement was bound
-	//! If this version is lower than the current catalog version, we have to rebind the prepared statement
-	idx_t catalog_version;
 	//! The map of parameter index to the actual value entry
 	bound_parameter_map_t value_map;
 	//! Whether we are creating a streaming result or not
@@ -52,9 +49,9 @@ public:
 public:
 	void CheckParameterCount(idx_t parameter_count);
 	//! Whether or not the prepared statement data requires the query to rebound for the given parameters
-	bool RequireRebind(ClientContext &context, optional_ptr<case_insensitive_map_t<Value>> values);
+	bool RequireRebind(ClientContext &context, optional_ptr<case_insensitive_map_t<BoundParameterData>> values);
 	//! Bind a set of values to the prepared statement data
-	DUCKDB_API void Bind(case_insensitive_map_t<Value> values);
+	DUCKDB_API void Bind(case_insensitive_map_t<BoundParameterData> values);
 	//! Get the expected SQL Type of the bound parameter
 	DUCKDB_API LogicalType GetType(const string &identifier);
 	//! Try to get the expected SQL Type of the bound parameter

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

@@ -0,0 +1,87 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/profiling_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/enums/output_type.hpp"
+#include "duckdb/common/enums/profiler_format.hpp"
+#include "duckdb/common/progress_bar/progress_bar.hpp"
+#include "duckdb/common/types/value.hpp"
+#include "duckdb/common/unordered_set.hpp"
+#include "duckdb/common/constants.hpp"
+#include "duckdb/common/enums/metric_type.hpp"
+
+namespace duckdb_yyjson {
+struct yyjson_mut_doc;
+struct yyjson_mut_val;
+} // namespace duckdb_yyjson
+
+namespace duckdb {
+
+class ProfilingInfo {
+public:
+	// Enabling a metric adds it to this set.
+	profiler_settings_t settings;
+	// Contains all enabled metrics.
+	profiler_metrics_t metrics;
+	// Additional metrics.
+	// FIXME: move to metrics.
+	InsertionOrderPreservingMap<string> extra_info;
+
+public:
+	ProfilingInfo() = default;
+	explicit ProfilingInfo(profiler_settings_t &n_settings, idx_t depth = 0) : settings(n_settings) {
+		if (depth == 0) {
+			settings.insert(MetricsType::QUERY_NAME);
+		} else {
+			settings.insert(MetricsType::OPERATOR_TYPE);
+		}
+		ResetMetrics();
+	}
+	ProfilingInfo(ProfilingInfo &) = default;
+	ProfilingInfo &operator=(ProfilingInfo const &) = default;
+
+public:
+	static profiler_settings_t DefaultSettings();
+	static profiler_settings_t DefaultOperatorSettings();
+	static profiler_settings_t AllSettings();
+
+public:
+	void ResetMetrics();
+	bool Enabled(const MetricsType setting) const;
+
+public:
+	string GetMetricAsString(MetricsType setting) const;
+	void WriteMetricsToJSON(duckdb_yyjson::yyjson_mut_doc *doc, duckdb_yyjson::yyjson_mut_val *destination);
+
+public:
+	template <class METRIC_TYPE>
+	METRIC_TYPE GetMetricValue(const MetricsType setting) const {
+		auto val = metrics.at(setting);
+		return val.GetValue<METRIC_TYPE>();
+	}
+
+	template <class METRIC_TYPE>
+	void AddToMetric(const MetricsType setting, const Value &value) {
+		D_ASSERT(!metrics[setting].IsNull());
+		if (metrics.find(setting) == metrics.end()) {
+			metrics[setting] = value;
+			return;
+		}
+		auto new_value = metrics[setting].GetValue<METRIC_TYPE>() + value.GetValue<METRIC_TYPE>();
+		metrics[setting] = Value::CreateValue(new_value);
+	}
+
+	template <class METRIC_TYPE>
+	void AddToMetric(const MetricsType setting, const METRIC_TYPE &value) {
+		auto new_value = Value::CreateValue(value);
+		return AddToMetric<METRIC_TYPE>(setting, new_value);
+	}
+};
+} // namespace duckdb