duckdb 0.8.2-dev2509.0 → 0.8.2-dev2673.0

package/src/duckdb/src/parallel/executor.cpp

@@ -589,6 +589,9 @@ bool Executor::GetPipelinesProgress(double &current_progress) { // LCOV_EXCL_STA
 		total_cardinality += child_cardinality;
 	}
 	current_progress = 0;
+	if (total_cardinality == 0) {
+		return true;
+	}
 	for (size_t i = 0; i < progress.size(); i++) {
 		current_progress += progress[i] * double(cardinality[i]) / double(total_cardinality);
 	}

package/src/duckdb/src/parser/expression/parameter_expression.cpp

@@ -11,36 +11,36 @@
 namespace duckdb {
 
 ParameterExpression::ParameterExpression()
-    : ParsedExpression(ExpressionType::VALUE_PARAMETER, ExpressionClass::PARAMETER), parameter_nr(0) {
+    : ParsedExpression(ExpressionType::VALUE_PARAMETER, ExpressionClass::PARAMETER) {
 }
 
 string ParameterExpression::ToString() const {
-	return "$" + to_string(parameter_nr);
+	return "$" + identifier;
 }
 
 unique_ptr<ParsedExpression> ParameterExpression::Copy() const {
 	auto copy = make_uniq<ParameterExpression>();
-	copy->parameter_nr = parameter_nr;
+	copy->identifier = identifier;
 	copy->CopyProperties(*this);
 	return std::move(copy);
 }
 
 bool ParameterExpression::Equal(const ParameterExpression &a, const ParameterExpression &b) {
-	return a.parameter_nr == b.parameter_nr;
+	return StringUtil::CIEquals(a.identifier, b.identifier);
 }
 
 hash_t ParameterExpression::Hash() const {
 	hash_t result = ParsedExpression::Hash();
-	return CombineHash(duckdb::Hash(parameter_nr), result);
+	return CombineHash(duckdb::Hash(identifier.c_str(), identifier.size()), result);
 }
 
 void ParameterExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteField<idx_t>(parameter_nr);
+	writer.WriteString(identifier);
 }
 
 unique_ptr<ParsedExpression> ParameterExpression::Deserialize(ExpressionType type, FieldReader &reader) {
 	auto expression = make_uniq<ParameterExpression>();
-	expression->parameter_nr = reader.ReadRequired<idx_t>();
+	expression->identifier = reader.ReadRequired<string>();
 	return std::move(expression);
 }
 

package/src/duckdb/src/parser/statement/execute_statement.cpp

@@ -6,8 +6,8 @@ ExecuteStatement::ExecuteStatement() : SQLStatement(StatementType::EXECUTE_STATE
 }
 
 ExecuteStatement::ExecuteStatement(const ExecuteStatement &other) : SQLStatement(other), name(other.name) {
-	for (const auto &value : other.values) {
-		values.push_back(value->Copy());
+	for (const auto &item : other.named_values) {
+		named_values.emplace(std::make_pair(item.first, item.second->Copy()));
 	}
 }
 

package/src/duckdb/src/parser/transform/expression/transform_param_ref.cpp

@@ -4,40 +4,59 @@
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformParamRef(duckdb_libpgquery::PGParamRef &node) {
-	auto expr = make_uniq<ParameterExpression>();
+namespace {
+
+struct PreparedParam {
+	PreparedParamType type;
+	string identifier;
+};
+
+} // namespace
+
+static PreparedParam GetParameterIdentifier(duckdb_libpgquery::PGParamRef &node) {
+	PreparedParam param;
+	if (node.name) {
+		param.type = PreparedParamType::NAMED;
+		param.identifier = node.name;
+		return param;
+	}
 	if (node.number < 0) {
 		throw ParserException("Parameter numbers cannot be negative");
 	}
+	param.identifier = StringUtil::Format("%d", node.number);
+	param.type = node.number == 0 ? PreparedParamType::AUTO_INCREMENT : PreparedParamType::POSITIONAL;
+	return param;
+}
 
-	if (node.name) {
-		// This is a named parameter, try to find an entry for it
-		D_ASSERT(node.number == 0);
-		int32_t index;
-		if (GetNamedParam(node.name, index)) {
-			// We've seen this named parameter before and assigned it an index!
-			node.number = index;
-		}
-	}
-	if (node.number == 0) {
-		expr->parameter_nr = ParamCount() + 1;
-		if (node.name && !HasNamedParameters() && ParamCount() != 0) {
-			// This parameter is named, but there were other parameter before it, and they were not named
-			throw NotImplementedException("Mixing positional and named parameters is not supported yet");
+unique_ptr<ParsedExpression> Transformer::TransformParamRef(duckdb_libpgquery::PGParamRef &node) {
+	auto expr = make_uniq<ParameterExpression>();
+
+	auto param = GetParameterIdentifier(node);
+	idx_t known_param_index = DConstants::INVALID_INDEX;
+	// This is a named parameter, try to find an entry for it
+	GetParam(param.identifier, known_param_index, param.type);
+
+	if (known_param_index == DConstants::INVALID_INDEX) {
+		// We have not seen this parameter before
+		if (node.number != 0) {
+			// Preserve the parameter number
+			known_param_index = node.number;
+		} else {
+			known_param_index = ParamCount() + 1;
+			if (!node.name) {
+				param.identifier = StringUtil::Format("%d", known_param_index);
+			}
 		}
-		if (node.name) {
-			D_ASSERT(!named_param_map.count(node.name));
+
+		if (!named_param_map.count(param.identifier)) {
 			// Add it to the named parameter map so we can find it next time it's referenced
-			SetNamedParam(node.name, expr->parameter_nr);
+			SetParam(param.identifier, known_param_index, param.type);
 		}
-	} else {
-		if (!node.name && HasNamedParameters()) {
-			// This parameter does not have a name, but the named param map is not empty
-			throw NotImplementedException("Mixing positional and named parameters is not supported yet");
-		}
-		expr->parameter_nr = node.number;
 	}
-	SetParamCount(MaxValue<idx_t>(ParamCount(), expr->parameter_nr));
+
+	expr->identifier = param.identifier;
+	idx_t new_param_count = MaxValue<idx_t>(ParamCount(), known_param_index);
+	SetParamCount(new_param_count);
 	return std::move(expr);
 }
 

package/src/duckdb/src/parser/transform/statement/transform_prepare.cpp

@@ -2,6 +2,8 @@
 #include "duckdb/parser/statement/execute_statement.hpp"
 #include "duckdb/parser/statement/prepare_statement.hpp"
 #include "duckdb/parser/transformer.hpp"
+#include "duckdb/parser/expression/comparison_expression.hpp"
+#include "duckdb/parser/expression/columnref_expression.hpp"
 
 namespace duckdb {
 
@@ -13,26 +15,46 @@ unique_ptr<PrepareStatement> Transformer::TransformPrepare(duckdb_libpgquery::PG
 	auto result = make_uniq<PrepareStatement>();
 	result->name = string(stmt.name);
 	result->statement = TransformStatement(*stmt.query);
-	if (!result->statement->named_param_map.empty()) {
-		throw NotImplementedException("Named parameters are not supported in this client yet");
-	}
 	SetParamCount(0);
 
 	return result;
 }
 
+static string NotAcceptedExpressionException() {
+	return "Only scalar parameters, named parameters or NULL supported for EXECUTE";
+}
+
 unique_ptr<ExecuteStatement> Transformer::TransformExecute(duckdb_libpgquery::PGExecuteStmt &stmt) {
 	auto result = make_uniq<ExecuteStatement>();
 	result->name = string(stmt.name);
 
+	vector<unique_ptr<ParsedExpression>> intermediate_values;
 	if (stmt.params) {
-		TransformExpressionList(*stmt.params, result->values);
+		TransformExpressionList(*stmt.params, intermediate_values);
 	}
-	for (auto &expr : result->values) {
+
+	idx_t param_idx = 0;
+	for (idx_t i = 0; i < intermediate_values.size(); i++) {
+		auto &expr = intermediate_values[i];
 		if (!expr->IsScalar()) {
-			throw Exception("Only scalar parameters or NULL supported for EXECUTE");
+			throw InvalidInputException(NotAcceptedExpressionException());
+		}
+		if (!expr->alias.empty() && param_idx != 0) {
+			// Found unnamed parameters mixed with named parameters
+			throw NotImplementedException("Mixing named parameters and positional parameters is not supported yet");
+		}
+		auto param_name = expr->alias;
+		if (expr->alias.empty()) {
+			param_name = std::to_string(param_idx + 1);
+			if (param_idx != i) {
+				throw NotImplementedException("Mixing named parameters and positional parameters is not supported yet");
+			}
+			param_idx++;
 		}
+		expr->alias.clear();
+		result->named_values[param_name] = std::move(expr);
 	}
+	intermediate_values.clear();
 	return result;
 }
 

package/src/duckdb/src/parser/transformer.cpp

@@ -91,24 +91,42 @@ void Transformer::SetParamCount(idx_t new_count) {
 	auto &root = RootTransformer();
 	root.prepared_statement_parameter_index = new_count;
 }
-void Transformer::SetNamedParam(const string &name, int32_t index) {
+
+static void ParamTypeCheck(PreparedParamType last_type, PreparedParamType new_type) {
+	// Mixing positional/auto-increment and named parameters is not supported
+	if (last_type == PreparedParamType::INVALID) {
+		return;
+	}
+	if (last_type == PreparedParamType::NAMED) {
+		if (new_type != PreparedParamType::NAMED) {
+			throw NotImplementedException("Mixing named and positional parameters is not supported yet");
+		}
+	}
+	if (last_type != PreparedParamType::NAMED) {
+		if (new_type == PreparedParamType::NAMED) {
+			throw NotImplementedException("Mixing named and positional parameters is not supported yet");
+		}
+	}
+}
+
+void Transformer::SetParam(const string &identifier, idx_t index, PreparedParamType type) {
 	auto &root = RootTransformer();
-	D_ASSERT(!root.named_param_map.count(name));
-	root.named_param_map[name] = index;
+	ParamTypeCheck(root.last_param_type, type);
+	root.last_param_type = type;
+	D_ASSERT(!root.named_param_map.count(identifier));
+	root.named_param_map[identifier] = index;
 }
-bool Transformer::GetNamedParam(const string &name, int32_t &index) {
+
+bool Transformer::GetParam(const string &identifier, idx_t &index, PreparedParamType type) {
 	auto &root = RootTransformer();
-	auto entry = root.named_param_map.find(name);
+	ParamTypeCheck(root.last_param_type, type);
+	auto entry = root.named_param_map.find(identifier);
 	if (entry == root.named_param_map.end()) {
 		return false;
 	}
 	index = entry->second;
 	return true;
 }
-bool Transformer::HasNamedParameters() const {
-	auto &root = RootTransformer();
-	return !root.named_param_map.empty();
-}
 
 unique_ptr<SQLStatement> Transformer::TransformStatementInternal(duckdb_libpgquery::PGNode &stmt) {
 	switch (stmt.type) {

package/src/duckdb/src/planner/binder/expression/bind_parameter_expression.cpp

@@ -7,34 +7,34 @@
 namespace duckdb {
 
 BindResult ExpressionBinder::BindExpression(ParameterExpression &expr, idx_t depth) {
-	D_ASSERT(expr.parameter_nr > 0);
-	auto bound_parameter = make_uniq<BoundParameterExpression>(expr.parameter_nr);
+	auto bound_parameter = make_uniq<BoundParameterExpression>(expr.identifier);
 	bound_parameter->alias = expr.alias;
 	if (!binder.parameters) {
 		throw BinderException("Unexpected prepared parameter. This type of statement can't be prepared!");
 	}
-	auto parameter_idx = expr.parameter_nr;
+	auto parameter_id = expr.identifier;
 	// check if a parameter value has already been supplied
-	if (parameter_idx <= binder.parameters->parameter_data.size()) {
+	if (binder.parameters->parameter_data.count(parameter_id)) {
 		// it has! emit a constant directly
-		auto &data = binder.parameters->parameter_data[parameter_idx - 1];
-		auto constant = make_uniq<BoundConstantExpression>(data.value);
+		auto &data = binder.parameters->parameter_data[parameter_id];
+		auto constant = make_uniq<BoundConstantExpression>(data.GetValue());
 		constant->alias = expr.alias;
 		return BindResult(std::move(constant));
 	}
-	auto entry = binder.parameters->parameters.find(parameter_idx);
+
+	auto entry = binder.parameters->parameters.find(parameter_id);
 	if (entry == binder.parameters->parameters.end()) {
 		// no entry yet: create a new one
 		auto data = make_shared<BoundParameterData>();
-		data->return_type = binder.parameters->GetReturnType(parameter_idx - 1);
+		data->return_type = binder.parameters->GetReturnType(parameter_id);
 		bound_parameter->return_type = data->return_type;
 		bound_parameter->parameter_data = data;
-		binder.parameters->parameters[parameter_idx] = std::move(data);
+		binder.parameters->parameters[parameter_id] = std::move(data);
 	} else {
 		// a prepared statement with this parameter index was already there: use it
 		auto &data = entry->second;
 		bound_parameter->parameter_data = data;
-		bound_parameter->return_type = binder.parameters->GetReturnType(parameter_idx - 1);
+		bound_parameter->return_type = binder.parameters->GetReturnType(parameter_id);
 	}
 	return BindResult(std::move(bound_parameter));
 }

package/src/duckdb/src/planner/binder/statement/bind_execute.cpp

@@ -6,6 +6,7 @@
 #include "duckdb/main/client_config.hpp"
 #include "duckdb/main/client_data.hpp"
 #include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/common/case_insensitive_map.hpp"
 
 namespace duckdb {
 
@@ -23,24 +24,29 @@ BoundStatement Binder::Bind(ExecuteStatement &stmt) {
 	// check if we need to rebind the prepared statement
 	// this happens if the catalog changes, since in this case e.g. tables we relied on may have been deleted
 	auto prepared = entry->second;
+	auto &named_param_map = prepared->unbound_statement->named_param_map;
 
+	PreparedStatement::VerifyParameters(stmt.named_values, named_param_map);
+
+	auto &mapped_named_values = stmt.named_values;
 	// bind any supplied parameters
-	vector<Value> bind_values;
+	case_insensitive_map_t<Value> bind_values;
 	auto constant_binder = Binder::CreateBinder(context);
 	constant_binder->SetCanContainNulls(true);
-	for (idx_t i = 0; i < stmt.values.size(); i++) {
+	for (auto &pair : mapped_named_values) {
 		ConstantBinder cbinder(*constant_binder, context, "EXECUTE statement");
-		auto bound_expr = cbinder.Bind(stmt.values[i]);
+		auto bound_expr = cbinder.Bind(pair.second);
 
 		Value value = ExpressionExecutor::EvaluateScalar(context, *bound_expr, true);
-		bind_values.push_back(std::move(value));
+		bind_values[pair.first] = std::move(value);
 	}
 	unique_ptr<LogicalOperator> rebound_plan;
-	if (prepared->RequireRebind(context, bind_values)) {
+
+	if (prepared->RequireRebind(context, &bind_values)) {
 		// catalog was modified or statement does not have clear types: rebind the statement before running the execute
 		Planner prepared_planner(context);
-		for (idx_t i = 0; i < bind_values.size(); i++) {
-			prepared_planner.parameter_data.emplace_back(bind_values[i]);
+		for (auto &pair : bind_values) {
+			prepared_planner.parameter_data.emplace(pair);
 		}
 		prepared = prepared_planner.PrepareSQLStatement(entry->second->unbound_statement->Copy());
 		rebound_plan = std::move(prepared_planner.plan);

package/src/duckdb/src/planner/expression/bound_parameter_expression.cpp

@@ -6,22 +6,22 @@
 
 namespace duckdb {
 
-BoundParameterExpression::BoundParameterExpression(idx_t parameter_nr)
+BoundParameterExpression::BoundParameterExpression(const string &identifier)
     : Expression(ExpressionType::VALUE_PARAMETER, ExpressionClass::BOUND_PARAMETER,
                  LogicalType(LogicalTypeId::UNKNOWN)),
-      parameter_nr(parameter_nr) {
+      identifier(identifier) {
 }
 
-BoundParameterExpression::BoundParameterExpression(bound_parameter_map_t &global_parameter_set, idx_t parameter_nr,
+BoundParameterExpression::BoundParameterExpression(bound_parameter_map_t &global_parameter_set, string identifier,
                                                    LogicalType return_type,
                                                    shared_ptr<BoundParameterData> parameter_data)
     : Expression(ExpressionType::VALUE_PARAMETER, ExpressionClass::BOUND_PARAMETER, std::move(return_type)),
-      parameter_nr(parameter_nr) {
+      identifier(std::move(identifier)) {
 	// check if we have already deserialized a parameter with this number
-	auto entry = global_parameter_set.find(parameter_nr);
+	auto entry = global_parameter_set.find(this->identifier);
 	if (entry == global_parameter_set.end()) {
 		// we have not - store the entry we deserialized from this parameter expression
-		global_parameter_set[parameter_nr] = parameter_data;
+		global_parameter_set[this->identifier] = parameter_data;
 	} else {
 		// we have! use the previously deserialized entry
 		parameter_data = entry->second;
@@ -57,7 +57,7 @@ bool BoundParameterExpression::IsFoldable() const {
 }
 
 string BoundParameterExpression::ToString() const {
-	return "$" + to_string(parameter_nr);
+	return "$" + identifier;
 }
 
 bool BoundParameterExpression::Equals(const BaseExpression &other_p) const {
@@ -65,17 +65,17 @@ bool BoundParameterExpression::Equals(const BaseExpression &other_p) const {
 		return false;
 	}
 	auto &other = other_p.Cast<BoundParameterExpression>();
-	return parameter_nr == other.parameter_nr;
+	return StringUtil::CIEquals(identifier, other.identifier);
 }
 
 hash_t BoundParameterExpression::Hash() const {
 	hash_t result = Expression::Hash();
-	result = CombineHash(duckdb::Hash(parameter_nr), result);
+	result = CombineHash(duckdb::Hash(identifier.c_str(), identifier.size()), result);
 	return result;
 }
 
 unique_ptr<Expression> BoundParameterExpression::Copy() {
-	auto result = make_uniq<BoundParameterExpression>(parameter_nr);
+	auto result = make_uniq<BoundParameterExpression>(identifier);
 	result->parameter_data = parameter_data;
 	result->return_type = return_type;
 	result->CopyProperties(*this);
@@ -83,7 +83,7 @@ unique_ptr<Expression> BoundParameterExpression::Copy() {
 }
 
 void BoundParameterExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteField(parameter_nr);
+	writer.WriteString(identifier);
 	writer.WriteSerializable(return_type);
 	writer.WriteSerializable(*parameter_data);
 }
@@ -91,11 +91,11 @@ void BoundParameterExpression::Serialize(FieldWriter &writer) const {
 unique_ptr<Expression> BoundParameterExpression::Deserialize(ExpressionDeserializationState &state,
                                                              FieldReader &reader) {
 	auto &global_parameter_set = state.gstate.parameter_data;
-	auto parameter_nr = reader.ReadRequired<idx_t>();
+	auto identifier = reader.ReadRequired<string>();
 	auto return_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
 	auto parameter_data = reader.ReadRequiredSerializable<BoundParameterData, shared_ptr<BoundParameterData>>();
 	auto result = unique_ptr<BoundParameterExpression>(new BoundParameterExpression(
-	    global_parameter_set, parameter_nr, std::move(return_type), std::move(parameter_data)));
+	    global_parameter_set, std::move(identifier), std::move(return_type), std::move(parameter_data)));
 	return std::move(result);
 }
 

package/src/duckdb/src/planner/planner.cpp

@@ -83,15 +83,15 @@ void Planner::CreatePlan(SQLStatement &statement) {
 
 	// set up a map of parameter number -> value entries
 	for (auto &kv : bound_parameters.parameters) {
-		auto parameter_index = kv.first;
-		auto &parameter_data = kv.second;
+		auto &identifier = kv.first;
+		auto &param = kv.second;
 		// check if the type of the parameter could be resolved
-		if (!parameter_data->return_type.IsValid()) {
+		if (!param->return_type.IsValid()) {
 			properties.bound_all_parameters = false;
 			continue;
 		}
-		parameter_data->value = Value(parameter_data->return_type);
-		value_map[parameter_index] = parameter_data;
+		param->SetValue(Value(param->return_type));
+		value_map[identifier] = param;
 	}
 }
 
@@ -153,7 +153,8 @@ static bool OperatorSupportsSerialization(LogicalOperator &op) {
 	return op.SupportSerialization();
 }
 
-void Planner::VerifyPlan(ClientContext &context, unique_ptr<LogicalOperator> &op, bound_parameter_map_t *map) {
+void Planner::VerifyPlan(ClientContext &context, unique_ptr<LogicalOperator> &op,
+                         optional_ptr<bound_parameter_map_t> map) {
 #ifdef DUCKDB_ALTERNATIVE_VERIFY
 	// if alternate verification is enabled we run the original operator
 	return;

package/src/duckdb/src/storage/checkpoint_manager.cpp

@@ -394,7 +394,7 @@ void CheckpointReader::ReadIndex(ClientContext &context, MetaBlockReader &reader
 	case IndexType::ART: {
 		auto &storage = table_catalog.GetStorage();
 		auto art = make_uniq<ART>(index_info.column_ids, TableIOManager::Get(storage), std::move(unbound_expressions),
-		                          index_info.constraint_type, storage.db, root_block_id, root_offset);
+		                          index_info.constraint_type, storage.db, nullptr, root_block_id, root_offset);
 		index_catalog.index = art.get();
 		storage.info->indexes.AddIndex(std::move(art));
 		break;

package/src/duckdb/src/storage/serialization/serialize_expression.cpp

@@ -241,16 +241,16 @@ unique_ptr<Expression> BoundOperatorExpression::FormatDeserialize(FormatDeserial
 
 void BoundParameterExpression::FormatSerialize(FormatSerializer &serializer) const {
 	Expression::FormatSerialize(serializer);
-	serializer.WriteProperty("parameter_nr", parameter_nr);
+	serializer.WriteProperty("identifier", identifier);
 	serializer.WriteProperty("return_type", return_type);
 	serializer.WriteProperty("parameter_data", *parameter_data);
 }
 
 unique_ptr<Expression> BoundParameterExpression::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto parameter_nr = deserializer.ReadProperty<idx_t>("parameter_nr");
+	auto identifier = deserializer.ReadProperty<string>("identifier");
 	auto return_type = deserializer.ReadProperty<LogicalType>("return_type");
 	auto parameter_data = deserializer.ReadProperty<shared_ptr<BoundParameterData>>("parameter_data");
-	auto result = duckdb::unique_ptr<BoundParameterExpression>(new BoundParameterExpression(deserializer.Get<bound_parameter_map_t &>(), parameter_nr, std::move(return_type), std::move(parameter_data)));
+	auto result = duckdb::unique_ptr<BoundParameterExpression>(new BoundParameterExpression(deserializer.Get<bound_parameter_map_t &>(), std::move(identifier), std::move(return_type), std::move(parameter_data)));
 	return std::move(result);
 }
 

package/src/duckdb/src/storage/serialization/serialize_parsed_expression.cpp

@@ -246,12 +246,12 @@ unique_ptr<ParsedExpression> OperatorExpression::FormatDeserialize(FormatDeseria
 
 void ParameterExpression::FormatSerialize(FormatSerializer &serializer) const {
 	ParsedExpression::FormatSerialize(serializer);
-	serializer.WriteProperty("parameter_nr", parameter_nr);
+	serializer.WriteProperty("identifier", identifier);
 }
 
 unique_ptr<ParsedExpression> ParameterExpression::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<ParameterExpression>(new ParameterExpression());
-	deserializer.ReadProperty("parameter_nr", result->parameter_nr);
+	deserializer.ReadProperty("identifier", result->identifier);
 	return std::move(result);
 }
 

package/src/duckdb/src/verification/prepared_statement_verifier.cpp

@@ -23,6 +23,9 @@ void PreparedStatementVerifier::Extract() {
 	ParsedExpressionIterator::EnumerateQueryNodeChildren(
 	    *select.node, [&](unique_ptr<ParsedExpression> &child) { ConvertConstants(child); });
 	statement->n_param = values.size();
+	for (auto &kv : values) {
+		statement->named_param_map[kv.first] = 0;
+	}
 	// create the PREPARE and EXECUTE statements
 	string name = "__duckdb_verification_prepared_statement";
 	auto prepare = make_uniq<PrepareStatement>();
@@ -31,7 +34,7 @@ void PreparedStatementVerifier::Extract() {
 
 	auto execute = make_uniq<ExecuteStatement>();
 	execute->name = name;
-	execute->values = std::move(values);
+	execute->named_values = std::move(values);
 
 	auto dealloc = make_uniq<DropStatement>();
 	dealloc->info->type = CatalogType::PREPARED_STATEMENT;
@@ -49,19 +52,21 @@ void PreparedStatementVerifier::ConvertConstants(unique_ptr<ParsedExpression> &c
 		child->alias = string();
 		// check if the value already exists
 		idx_t index = values.size();
-		for (idx_t v_idx = 0; v_idx < values.size(); v_idx++) {
-			if (values[v_idx]->Equals(*child)) {
-				// duplicate value! refer to the original value
-				index = v_idx;
-				break;
-			}
-		}
-		if (index == values.size()) {
-			values.push_back(std::move(child));
+		auto identifier = std::to_string(index + 1);
+		const auto predicate = [&](const std::pair<const string, unique_ptr<ParsedExpression>> &pair) {
+			return pair.second->Equals(*child.get());
+		};
+		auto result = std::find_if(values.begin(), values.end(), predicate);
+		if (result == values.end()) {
+			// If it doesn't exist yet, add it
+			values[identifier] = std::move(child);
+		} else {
+			identifier = result->first;
 		}
+
 		// replace it with an expression
 		auto parameter = make_uniq<ParameterExpression>();
-		parameter->parameter_nr = index + 1;
+		parameter->identifier = identifier;
 		parameter->alias = alias;
 		child = std::move(parameter);
 		return;