duckdb 0.8.2-dev87.0 → 0.9.1-dev0.0

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

@@ -4,8 +4,10 @@
 #include "duckdb/common/string_util.hpp"
 
 #ifndef DISABLE_DUCKDB_REMOTE_INSTALL
+#ifndef DUCKDB_DISABLE_EXTENSION_LOAD
 #include "httplib.hpp"
 #endif
+#endif
 #include "duckdb/common/windows_undefs.hpp"
 
 #include <fstream>
@@ -27,6 +29,9 @@ bool ExtensionHelper::IsRelease(const string &version_tag) {
 }
 
 const string ExtensionHelper::GetVersionDirectoryName() {
+#ifdef DUCKDB_WASM_VERSION
+	return DUCKDB_QUOTE_DEFINE(DUCKDB_WASM_VERSION);
+#endif
 	if (IsRelease(DuckDB::LibraryVersion())) {
 		return NormalizeVersionTag(DuckDB::LibraryVersion());
 	} else {
@@ -40,7 +45,7 @@ const vector<string> ExtensionHelper::PathComponents() {
 
 string ExtensionHelper::ExtensionDirectory(DBConfig &config, FileSystem &fs) {
 #ifdef WASM_LOADABLE_EXTENSIONS
-	static_assertion(0, "ExtensionDirectory functionality is not supported in duckdb-wasm");
+	throw PermissionException("ExtensionDirectory functionality is not supported in duckdb-wasm");
 #endif
 	string extension_directory;
 	if (!config.options.extension_directory.empty()) { // create the extension directory if not present
@@ -51,7 +56,7 @@ string ExtensionHelper::ExtensionDirectory(DBConfig &config, FileSystem &fs) {
 		// expand ~ in extension directory
 		extension_directory = fs.ExpandPath(extension_directory);
 		if (!fs.DirectoryExists(extension_directory)) {
-			auto sep = fs.PathSeparator();
+			auto sep = fs.PathSeparator(extension_directory);
 			auto splits = StringUtil::Split(extension_directory, sep);
 			D_ASSERT(!splits.empty());
 			string extension_directory_prefix;
@@ -112,16 +117,18 @@ bool ExtensionHelper::CreateSuggestions(const string &extension_name, string &me
 	return false;
 }
 
-void ExtensionHelper::InstallExtension(DBConfig &config, FileSystem &fs, const string &extension, bool force_install) {
+void ExtensionHelper::InstallExtension(DBConfig &config, FileSystem &fs, const string &extension, bool force_install,
+                                       const string &repository) {
 #ifdef WASM_LOADABLE_EXTENSIONS
 	// Install is currently a no-op
 	return;
 #endif
 	string local_path = ExtensionDirectory(config, fs);
-	InstallExtensionInternal(config, nullptr, fs, local_path, extension, force_install);
+	InstallExtensionInternal(config, nullptr, fs, local_path, extension, force_install, repository);
 }
 
-void ExtensionHelper::InstallExtension(ClientContext &context, const string &extension, bool force_install) {
+void ExtensionHelper::InstallExtension(ClientContext &context, const string &extension, bool force_install,
+                                       const string &repository) {
 #ifdef WASM_LOADABLE_EXTENSIONS
 	// Install is currently a no-op
 	return;
@@ -130,7 +137,7 @@ void ExtensionHelper::InstallExtension(ClientContext &context, const string &ext
 	auto &fs = FileSystem::GetFileSystem(context);
 	string local_path = ExtensionDirectory(context);
 	auto &client_config = ClientConfig::GetConfig(context);
-	InstallExtensionInternal(config, &client_config, fs, local_path, extension, force_install);
+	InstallExtensionInternal(config, &client_config, fs, local_path, extension, force_install, repository);
 }
 
 unsafe_unique_array<data_t> ReadExtensionFileFromDisk(FileSystem &fs, const string &path, idx_t &file_size) {
@@ -150,8 +157,41 @@ void WriteExtensionFileToDisk(FileSystem &fs, const string &path, void *data, id
 	target_file.reset();
 }
 
+string ExtensionHelper::ExtensionUrlTemplate(optional_ptr<const ClientConfig> client_config, const string &repository) {
+	string versioned_path = "/${REVISION}/${PLATFORM}/${NAME}.duckdb_extension";
+#ifdef WASM_LOADABLE_EXTENSIONS
+	string default_endpoint = "https://extensions.duckdb.org";
+	versioned_path = "/duckdb-wasm" + versioned_path + ".wasm";
+#else
+	string default_endpoint = "http://extensions.duckdb.org";
+	versioned_path = versioned_path + ".gz";
+#endif
+	string custom_endpoint = client_config ? client_config->custom_extension_repo : string();
+	string endpoint;
+	if (!repository.empty()) {
+		endpoint = repository;
+	} else if (!custom_endpoint.empty()) {
+		endpoint = custom_endpoint;
+	} else {
+		endpoint = default_endpoint;
+	}
+	string url_template = endpoint + versioned_path;
+	return url_template;
+}
+
+string ExtensionHelper::ExtensionFinalizeUrlTemplate(const string &url_template, const string &extension_name) {
+	auto url = StringUtil::Replace(url_template, "${REVISION}", GetVersionDirectoryName());
+	url = StringUtil::Replace(url, "${PLATFORM}", DuckDB::Platform());
+	url = StringUtil::Replace(url, "${NAME}", extension_name);
+	return url;
+}
+
 void ExtensionHelper::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) {
+#ifdef DUCKDB_DISABLE_EXTENSION_LOAD
+	throw PermissionException("Installing external extensions is disabled through a compile time flag");
+#else
 	if (!config.options.enable_external_access) {
 		throw PermissionException("Installing extensions is disabled through configuration");
 	}
@@ -173,6 +213,9 @@ void ExtensionHelper::InstallExtensionInternal(DBConfig &config, ClientConfig *c
 		auto in_buffer = ReadExtensionFileFromDisk(fs, extension, file_size);
 		WriteExtensionFileToDisk(fs, temp_path, in_buffer.get(), file_size);
 
+		if (fs.FileExists(local_extension_path) && force_install) {
+			fs.RemoveFile(local_extension_path);
+		}
 		fs.MoveFile(temp_path, local_extension_path);
 		return;
 	} else if (StringUtil::Contains(extension, "/") && !is_http_url) {
@@ -183,20 +226,14 @@ void ExtensionHelper::InstallExtensionInternal(DBConfig &config, ClientConfig *c
 	throw BinderException("Remote extension installation is disabled through configuration");
 #else
 
-	string default_endpoint = "http://extensions.duckdb.org";
-	string versioned_path = "/${REVISION}/${PLATFORM}/${NAME}.duckdb_extension.gz";
-	string custom_endpoint = client_config ? client_config->custom_extension_repo : string();
-	string &endpoint = !custom_endpoint.empty() ? custom_endpoint : default_endpoint;
-	string url_template = endpoint + versioned_path;
+	string url_template = ExtensionUrlTemplate(client_config, repository);
 
 	if (is_http_url) {
 		url_template = extension;
 		extension_name = "";
 	}
 
-	auto url = StringUtil::Replace(url_template, "${REVISION}", GetVersionDirectoryName());
-	url = StringUtil::Replace(url, "${PLATFORM}", DuckDB::Platform());
-	url = StringUtil::Replace(url, "${NAME}", extension_name);
+	string url = ExtensionFinalizeUrlTemplate(url_template, extension_name);
 
 	string no_http = StringUtil::Replace(url, "http://", "");
 
@@ -205,6 +242,28 @@ void ExtensionHelper::InstallExtensionInternal(DBConfig &config, ClientConfig *c
 		throw IOException("No slash in URL template");
 	}
 
+	// Special case to install extension from a local file, useful for testing
+	if (!StringUtil::Contains(url_template, "http://")) {
+		string file = fs.ConvertSeparators(url);
+		if (!fs.FileExists(file)) {
+			// check for non-gzipped variant
+			file = file.substr(0, file.size() - 3);
+			if (!fs.FileExists(file)) {
+				throw IOException("Failed to copy local extension \"%s\" at PATH \"%s\"\n", extension_name, file);
+			}
+		}
+		auto read_handle = fs.OpenFile(file, FileFlags::FILE_FLAGS_READ);
+		auto test_data = std::unique_ptr<unsigned char[]> {new unsigned char[read_handle->GetFileSize()]};
+		read_handle->Read(test_data.get(), read_handle->GetFileSize());
+		WriteExtensionFileToDisk(fs, temp_path, (void *)test_data.get(), read_handle->GetFileSize());
+
+		if (fs.FileExists(local_extension_path) && force_install) {
+			fs.RemoveFile(local_extension_path);
+		}
+		fs.MoveFile(temp_path, local_extension_path);
+		return;
+	}
+
 	// Push the substring [last, next) on to splits
 	auto hostname_without_http = no_http.substr(0, next);
 	auto url_local_part = no_http.substr(next);
@@ -235,8 +294,13 @@ void ExtensionHelper::InstallExtensionInternal(DBConfig &config, ClientConfig *c
 	auto decompressed_body = GZipFileSystem::UncompressGZIPString(res->body);
 
 	WriteExtensionFileToDisk(fs, temp_path, (void *)decompressed_body.data(), decompressed_body.size());
+
+	if (fs.FileExists(local_extension_path) && force_install) {
+		fs.RemoveFile(local_extension_path);
+	}
 	fs.MoveFile(temp_path, local_extension_path);
 #endif
+#endif
 }
 
 } // namespace duckdb

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

@@ -17,6 +17,7 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 // Load External Extension
 //===--------------------------------------------------------------------===//
+#ifndef DUCKDB_DISABLE_EXTENSION_LOAD
 typedef void (*ext_init_fun_t)(DatabaseInstance &);
 typedef const char *(*ext_version_fun_t)(void);
 typedef bool (*ext_is_storage_t)(void);
@@ -36,16 +37,32 @@ static void ComputeSHA256String(const std::string &to_hash, std::string *res) {
 }
 
 static void ComputeSHA256FileSegment(FileHandle *handle, const idx_t start, const idx_t end, std::string *res) {
-	const idx_t len = end - start;
-	string file_content;
-	file_content.resize(len);
-	handle->Read((void *)file_content.data(), len, start);
+	idx_t iter = start;
+	const idx_t segment_size = 1024 * 8;
 
-	ComputeSHA256String(file_content, res);
+	duckdb_mbedtls::MbedTlsWrapper::SHA256State state;
+
+	std::string to_hash;
+	while (iter < end) {
+		idx_t len = std::min(end - iter, segment_size);
+		to_hash.resize(len);
+		handle->Read((void *)to_hash.data(), len, iter);
+
+		state.AddString(to_hash);
+
+		iter += segment_size;
+	}
+
+	*res = state.Finalize();
 }
+#endif
 
 bool ExtensionHelper::TryInitialLoad(DBConfig &config, FileSystem &fs, const string &extension,
-                                     ExtensionInitResult &result, string &error) {
+                                     ExtensionInitResult &result, string &error,
+                                     optional_ptr<const ClientConfig> client_config) {
+#ifdef DUCKDB_DISABLE_EXTENSION_LOAD
+	throw PermissionException("Loading external extensions is disabled through a compile time flag");
+#else
 	if (!config.options.enable_external_access) {
 		throw PermissionException("Loading external extensions is disabled through configuration");
 	}
@@ -53,6 +70,31 @@ bool ExtensionHelper::TryInitialLoad(DBConfig &config, FileSystem &fs, const str
 
 	// shorthand case
 	if (!ExtensionHelper::IsFullPath(extension)) {
+		string extension_name = ApplyExtensionAlias(extension);
+#ifdef WASM_LOADABLE_EXTENSIONS
+		string url_template = ExtensionUrlTemplate(client_config, "");
+		string url = ExtensionFinalizeUrlTemplate(url_template, extension_name);
+
+		char *str = (char *)EM_ASM_PTR(
+		    {
+			    var jsString = ((typeof runtime == 'object') && runtime && (typeof runtime.whereToLoad == 'function') &&
+			                    runtime.whereToLoad)
+			                       ? runtime.whereToLoad(UTF8ToString($0))
+			                       : (UTF8ToString($1));
+			    var lengthBytes = lengthBytesUTF8(jsString) + 1;
+			    // 'jsString.length' would return the length of the string as UTF-16
+			    // units, but Emscripten C strings operate as UTF-8.
+			    var stringOnWasmHeap = _malloc(lengthBytes);
+			    stringToUTF8(jsString, stringOnWasmHeap, lengthBytes);
+			    return stringOnWasmHeap;
+		    },
+		    filename.c_str(), url.c_str());
+		std::string address(str);
+		free(str);
+
+		filename = address;
+#else
+
 		string local_path =
 		    !config.options.extension_directory.empty() ? config.options.extension_directory : fs.GetHomeDirectory();
 
@@ -64,8 +106,8 @@ bool ExtensionHelper::TryInitialLoad(DBConfig &config, FileSystem &fs, const str
 		for (auto &path_ele : path_components) {
 			local_path = fs.JoinPath(local_path, path_ele);
 		}
-		string extension_name = ApplyExtensionAlias(extension);
 		filename = fs.JoinPath(local_path, extension_name + ".duckdb_extension");
+#endif
 	}
 	if (!fs.FileExists(filename)) {
 		string message;
@@ -197,19 +239,21 @@ bool ExtensionHelper::TryInitialLoad(DBConfig &config, FileSystem &fs, const str
 	result.filename = filename;
 	result.lib_hdl = lib_hdl;
 	return true;
+#endif
 }
 
-ExtensionInitResult ExtensionHelper::InitialLoad(DBConfig &config, FileSystem &fs, const string &extension) {
+ExtensionInitResult ExtensionHelper::InitialLoad(DBConfig &config, FileSystem &fs, const string &extension,
+                                                 optional_ptr<const ClientConfig> client_config) {
 	string error;
 	ExtensionInitResult result;
-	if (!TryInitialLoad(config, fs, extension, result, error)) {
+	if (!TryInitialLoad(config, fs, extension, result, error, client_config)) {
 		if (!ExtensionHelper::AllowAutoInstall(extension)) {
 			throw IOException(error);
 		}
 		// the extension load failed - try installing the extension
 		ExtensionHelper::InstallExtension(config, fs, extension, false);
 		// try loading again
-		if (!TryInitialLoad(config, fs, extension, result, error)) {
+		if (!TryInitialLoad(config, fs, extension, result, error, client_config)) {
 			throw IOException(error);
 		}
 	}
@@ -237,12 +281,15 @@ string ExtensionHelper::GetExtensionName(const string &original_name) {
 	return ExtensionHelper::ApplyExtensionAlias(splits.front());
 }
 
-void ExtensionHelper::LoadExternalExtension(DatabaseInstance &db, FileSystem &fs, const string &extension) {
+void ExtensionHelper::LoadExternalExtension(DatabaseInstance &db, FileSystem &fs, const string &extension,
+                                            optional_ptr<const ClientConfig> client_config) {
 	if (db.ExtensionIsLoaded(extension)) {
 		return;
 	}
-
-	auto res = InitialLoad(DBConfig::GetConfig(db), fs, extension);
+#ifdef DUCKDB_DISABLE_EXTENSION_LOAD
+	throw PermissionException("Loading external extensions is disabled through a compile time flag");
+#else
+	auto res = InitialLoad(DBConfig::GetConfig(db), fs, extension, client_config);
 	auto init_fun_name = res.basename + "_init";
 
 	ext_init_fun_t init_fun;
@@ -256,10 +303,12 @@ void ExtensionHelper::LoadExternalExtension(DatabaseInstance &db, FileSystem &fs
 	}
 
 	db.SetExtensionLoaded(extension);
+#endif
 }
 
 void ExtensionHelper::LoadExternalExtension(ClientContext &context, const string &extension) {
-	LoadExternalExtension(DatabaseInstance::GetDatabase(context), FileSystem::GetFileSystem(context), extension);
+	LoadExternalExtension(DatabaseInstance::GetDatabase(context), FileSystem::GetFileSystem(context), extension,
+	                      &ClientConfig::GetConfig(context));
 }
 
 string ExtensionHelper::ExtractExtensionPrefixFromPath(const string &path) {

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

@@ -1,11 +1,15 @@
 #include "duckdb/main/extension_util.hpp"
 #include "duckdb/function/scalar_function.hpp"
+#include "duckdb/parser/parsed_data/create_aggregate_function_info.hpp"
 #include "duckdb/parser/parsed_data/create_type_info.hpp"
 #include "duckdb/parser/parsed_data/create_copy_function_info.hpp"
 #include "duckdb/parser/parsed_data/create_pragma_function_info.hpp"
 #include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
 #include "duckdb/parser/parsed_data/create_table_function_info.hpp"
 #include "duckdb/parser/parsed_data/create_macro_info.hpp"
+#include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
+#include "duckdb/parser/parsed_data/create_collation_info.hpp"
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/main/config.hpp"
 
@@ -26,6 +30,21 @@ void ExtensionUtil::RegisterFunction(DatabaseInstance &db, ScalarFunction functi
 	RegisterFunction(db, std::move(set));
 }
 
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, AggregateFunction function) {
+	D_ASSERT(!function.name.empty());
+	AggregateFunctionSet set(function.name);
+	set.AddFunction(std::move(function));
+	RegisterFunction(db, std::move(set));
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, AggregateFunctionSet set) {
+	D_ASSERT(!set.name.empty());
+	CreateAggregateFunctionInfo info(std::move(set));
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreateFunction(data, info);
+}
+
 void ExtensionUtil::RegisterFunction(DatabaseInstance &db, TableFunction function) {
 	D_ASSERT(!function.name.empty());
 	TableFunctionSet set(function.name);
@@ -70,6 +89,59 @@ void ExtensionUtil::RegisterFunction(DatabaseInstance &db, CreateMacroInfo &info
 	system_catalog.CreateFunction(data, info);
 }
 
+void ExtensionUtil::RegisterCollation(DatabaseInstance &db, CreateCollationInfo &info) {
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	info.on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
+	system_catalog.CreateCollation(data, info);
+}
+
+void ExtensionUtil::AddFunctionOverload(DatabaseInstance &db, ScalarFunction function) {
+	auto &scalar_function = ExtensionUtil::GetFunction(db, function.name);
+	scalar_function.functions.AddFunction(std::move(function));
+}
+
+void ExtensionUtil::AddFunctionOverload(DatabaseInstance &db, ScalarFunctionSet functions) { // NOLINT
+	D_ASSERT(!functions.name.empty());
+	auto &scalar_function = ExtensionUtil::GetFunction(db, functions.name);
+	for (auto &function : functions.functions) {
+		function.name = functions.name;
+		scalar_function.functions.AddFunction(std::move(function));
+	}
+}
+
+void ExtensionUtil::AddFunctionOverload(DatabaseInstance &db, TableFunctionSet functions) { // NOLINT
+	auto &table_function = ExtensionUtil::GetTableFunction(db, functions.name);
+	for (auto &function : functions.functions) {
+		function.name = functions.name;
+		table_function.functions.AddFunction(std::move(function));
+	}
+}
+
+ScalarFunctionCatalogEntry &ExtensionUtil::GetFunction(DatabaseInstance &db, const string &name) {
+	D_ASSERT(!name.empty());
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	auto &schema = system_catalog.GetSchema(data, DEFAULT_SCHEMA);
+	auto catalog_entry = schema.GetEntry(data, CatalogType::SCALAR_FUNCTION_ENTRY, name);
+	if (!catalog_entry) {
+		throw InvalidInputException("Function with name \"%s\" not found in ExtensionUtil::GetFunction", name);
+	}
+	return catalog_entry->Cast<ScalarFunctionCatalogEntry>();
+}
+
+TableFunctionCatalogEntry &ExtensionUtil::GetTableFunction(DatabaseInstance &db, const string &name) {
+	D_ASSERT(!name.empty());
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	auto &schema = system_catalog.GetSchema(data, DEFAULT_SCHEMA);
+	auto catalog_entry = schema.GetEntry(data, CatalogType::TABLE_FUNCTION_ENTRY, name);
+	if (!catalog_entry) {
+		throw InvalidInputException("Function with name \"%s\" not found in ExtensionUtil::GetTableFunction", name);
+	}
+	return catalog_entry->Cast<TableFunctionCatalogEntry>();
+}
+
 void ExtensionUtil::RegisterType(DatabaseInstance &db, string type_name, LogicalType type) {
 	D_ASSERT(!type_name.empty());
 	CreateTypeInfo info(std::move(type_name), std::move(type));

package/src/duckdb/src/main/pending_query_result.cpp

@@ -55,7 +55,8 @@ PendingExecutionResult PendingQueryResult::ExecuteTaskInternal(ClientContextLock
 
 unique_ptr<QueryResult> PendingQueryResult::ExecuteInternal(ClientContextLock &lock) {
 	CheckExecutableInternal(lock);
-	while (ExecuteTaskInternal(lock) == PendingExecutionResult::RESULT_NOT_READY) {
+	// Busy wait while execution is not finished
+	while (!IsFinished(ExecuteTaskInternal(lock))) {
 	}
 	if (HasError()) {
 		return make_uniq<MaterializedQueryResult>(error);
@@ -74,4 +75,11 @@ void PendingQueryResult::Close() {
 	context.reset();
 }
 
+bool PendingQueryResult::IsFinished(PendingExecutionResult result) {
+	if (result == PendingExecutionResult::RESULT_READY || result == PendingExecutionResult::EXECUTION_ERROR) {
+		return true;
+	}
+	return false;
+}
+
 } // namespace duckdb

package/src/duckdb/src/main/prepared_statement.cpp

@@ -6,9 +6,9 @@
 namespace duckdb {
 
 PreparedStatement::PreparedStatement(shared_ptr<ClientContext> context, shared_ptr<PreparedStatementData> data_p,
-                                     string query, idx_t n_param, case_insensitive_map_t<idx_t> named_param_pam_p)
+                                     string query, idx_t n_param, case_insensitive_map_t<idx_t> named_param_map_p)
     : context(std::move(context)), data(std::move(data_p)), query(std::move(query)), success(true), n_param(n_param),
-      named_param_map(std::move(named_param_pam_p)) {
+      named_param_map(std::move(named_param_map_p)) {
 	D_ASSERT(data || !success);
 }
 
@@ -56,19 +56,27 @@ const vector<string> &PreparedStatement::GetNames() {
 	return data->names;
 }
 
-vector<LogicalType> PreparedStatement::GetExpectedParameterTypes() const {
+case_insensitive_map_t<LogicalType> PreparedStatement::GetExpectedParameterTypes() const {
 	D_ASSERT(data);
-	vector<LogicalType> expected_types(data->value_map.size());
+	case_insensitive_map_t<LogicalType> expected_types(data->value_map.size());
 	for (auto &it : data->value_map) {
-		D_ASSERT(it.first >= 1);
-		idx_t param_index = it.first - 1;
-		D_ASSERT(param_index < expected_types.size());
+		auto &identifier = it.first;
+		D_ASSERT(data->value_map.count(identifier));
 		D_ASSERT(it.second);
-		expected_types[param_index] = it.second->value.type();
+		expected_types[identifier] = it.second->GetValue().type();
 	}
 	return expected_types;
 }
 
+unique_ptr<QueryResult> PreparedStatement::Execute(case_insensitive_map_t<Value> &named_values,
+                                                   bool allow_stream_result) {
+	auto pending = PendingQuery(named_values, allow_stream_result);
+	if (pending->HasError()) {
+		return make_uniq<MaterializedQueryResult>(pending->GetErrorObject());
+	}
+	return pending->Execute();
+}
+
 unique_ptr<QueryResult> PreparedStatement::Execute(vector<Value> &values, bool allow_stream_result) {
 	auto pending = PendingQuery(values, allow_stream_result);
 	if (pending->HasError()) {
@@ -78,14 +86,33 @@ unique_ptr<QueryResult> PreparedStatement::Execute(vector<Value> &values, bool a
 }
 
 unique_ptr<PendingQueryResult> PreparedStatement::PendingQuery(vector<Value> &values, bool allow_stream_result) {
+	case_insensitive_map_t<Value> named_values;
+	for (idx_t i = 0; i < values.size(); i++) {
+		auto &val = values[i];
+		named_values[std::to_string(i + 1)] = val;
+	}
+	return PendingQuery(named_values, allow_stream_result);
+}
+
+unique_ptr<PendingQueryResult> PreparedStatement::PendingQuery(case_insensitive_map_t<Value> &named_values,
+                                                               bool allow_stream_result) {
 	if (!success) {
-		throw InvalidInputException("Attempting to execute an unsuccessfully prepared statement!");
+		auto exception = InvalidInputException("Attempting to execute an unsuccessfully prepared statement!");
+		return make_uniq<PendingQueryResult>(PreservedError(exception));
 	}
-	D_ASSERT(data);
 	PendingQueryParameters parameters;
-	parameters.parameters = &values;
+	parameters.parameters = &named_values;
+
+	try {
+		VerifyParameters(named_values, named_param_map);
+	} catch (const Exception &ex) {
+		return make_uniq<PendingQueryResult>(PreservedError(ex));
+	}
+
+	D_ASSERT(data);
 	parameters.allow_stream_result = allow_stream_result && data->properties.allow_stream_result;
 	auto result = context->PendingQuery(query, data, parameters);
+	// The result should not contain any reference to the 'vector<Value> parameters.parameters'
 	return result;
 }
 

package/src/duckdb/src/main/prepared_statement_data.cpp

@@ -18,8 +18,9 @@ void PreparedStatementData::CheckParameterCount(idx_t parameter_count) {
 	}
 }
 
-bool PreparedStatementData::RequireRebind(ClientContext &context, const vector<Value> &values) {
-	CheckParameterCount(values.size());
+bool PreparedStatementData::RequireRebind(ClientContext &context, optional_ptr<case_insensitive_map_t<Value>> values) {
+	idx_t count = values ? values->size() : 0;
+	CheckParameterCount(count);
 	if (!unbound_statement) {
 		// no unbound statement!? cannot rebind?
 		return false;
@@ -33,52 +34,56 @@ bool PreparedStatementData::RequireRebind(ClientContext &context, const vector<V
 		return true;
 	}
 	for (auto &it : value_map) {
-		const idx_t i = it.first - 1;
-		if (values[i].type() != it.second->return_type) {
+		auto &identifier = it.first;
+		auto lookup = values->find(identifier);
+		D_ASSERT(lookup != values->end());
+		if (lookup->second.type() != it.second->return_type) {
 			return true;
 		}
 	}
 	return false;
 }
 
-void PreparedStatementData::Bind(vector<Value> values) {
+void PreparedStatementData::Bind(case_insensitive_map_t<Value> values) {
 	// set parameters
 	D_ASSERT(!unbound_statement || unbound_statement->n_param == properties.parameter_count);
 	CheckParameterCount(values.size());
 
 	// bind the required values
 	for (auto &it : value_map) {
-		const idx_t i = it.first - 1;
-		if (i >= values.size()) {
-			throw BinderException("Could not find parameter with index %llu", i + 1);
+		const string &identifier = it.first;
+		auto lookup = values.find(identifier);
+		if (lookup == values.end()) {
+			throw BinderException("Could not find parameter with identifier %s", identifier);
 		}
 		D_ASSERT(it.second);
-		if (!values[i].DefaultTryCastAs(it.second->return_type)) {
+		auto &value = lookup->second;
+		if (!value.DefaultTryCastAs(it.second->return_type)) {
 			throw BinderException(
-			    "Type mismatch for binding parameter with index %llu, expected type %s but got type %s", i + 1,
-			    it.second->return_type.ToString().c_str(), values[i].type().ToString().c_str());
+			    "Type mismatch for binding parameter with identifier %s, expected type %s but got type %s", identifier,
+			    it.second->return_type.ToString().c_str(), value.type().ToString().c_str());
 		}
-		it.second->value = values[i];
+		it.second->SetValue(value);
 	}
 }
 
-bool PreparedStatementData::TryGetType(idx_t param_idx, LogicalType &result) {
-	auto it = value_map.find(param_idx);
+bool PreparedStatementData::TryGetType(const string &identifier, LogicalType &result) {
+	auto it = value_map.find(identifier);
 	if (it == value_map.end()) {
 		return false;
 	}
 	if (it->second->return_type.id() != LogicalTypeId::INVALID) {
 		result = it->second->return_type;
 	} else {
-		result = it->second->value.type();
+		result = it->second->GetValue().type();
 	}
 	return true;
 }
 
-LogicalType PreparedStatementData::GetType(idx_t param_idx) {
+LogicalType PreparedStatementData::GetType(const string &identifier) {
 	LogicalType result;
-	if (!TryGetType(param_idx, result)) {
-		throw BinderException("Could not find parameter with index %llu", param_idx);
+	if (!TryGetType(identifier, result)) {
+		throw BinderException("Could not find parameter identified with: %s", identifier);
 	}
 	return result;
 }