duckdb 0.8.2-dev2399.0 → 0.8.2-dev2669.0

package/src/duckdb/src/main/client_context.cpp

@@ -304,9 +304,9 @@ static bool IsExplainAnalyze(SQLStatement *statement) {
 	return explain.explain_type == ExplainType::EXPLAIN_ANALYZE;
 }
 
-shared_ptr<PreparedStatementData> ClientContext::CreatePreparedStatement(ClientContextLock &lock, const string &query,
-                                                                         unique_ptr<SQLStatement> statement,
-                                                                         vector<Value> *values) {
+shared_ptr<PreparedStatementData>
+ClientContext::CreatePreparedStatement(ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement,
+                                       optional_ptr<case_insensitive_map_t<Value>> values) {
 	StatementType statement_type = statement->type;
 	auto result = make_shared<PreparedStatementData>(statement_type);
 
@@ -315,8 +315,9 @@ shared_ptr<PreparedStatementData> ClientContext::CreatePreparedStatement(ClientC
 	profiler.StartPhase("planner");
 	Planner planner(*this);
 	if (values) {
-		for (auto &value : *values) {
-			planner.parameter_data.emplace_back(value);
+		auto &parameter_values = *values;
+		for (auto &value : parameter_values) {
+			planner.parameter_data.emplace(value);
 		}
 	}
 
@@ -370,7 +371,7 @@ double ClientContext::GetProgress() {
 
 unique_ptr<PendingQueryResult> ClientContext::PendingPreparedStatement(ClientContextLock &lock,
                                                                        shared_ptr<PreparedStatementData> statement_p,
-                                                                       PendingQueryParameters parameters) {
+                                                                       const PendingQueryParameters &parameters) {
 	D_ASSERT(active_query);
 	auto &statement = *statement_p;
 	if (ValidChecker::IsInvalidated(ActiveTransaction()) && statement.properties.requires_valid_transaction) {
@@ -392,7 +393,14 @@ unique_ptr<PendingQueryResult> ClientContext::PendingPreparedStatement(ClientCon
 	}
 
 	// bind the bound values before execution
-	statement.Bind(parameters.parameters ? *parameters.parameters : vector<Value>());
+	case_insensitive_map_t<Value> owned_values;
+	if (parameters.parameters) {
+		auto &params = *parameters.parameters;
+		for (auto &val : params) {
+			owned_values.emplace(val);
+		}
+	}
+	statement.Bind(std::move(owned_values));
 
 	active_query->executor = make_uniq<Executor>(*this);
 	auto &executor = *active_query->executor;
@@ -566,7 +574,7 @@ unique_ptr<PreparedStatement> ClientContext::Prepare(const string &query) {
 
 unique_ptr<PendingQueryResult> ClientContext::PendingQueryPreparedInternal(ClientContextLock &lock, const string &query,
                                                                            shared_ptr<PreparedStatementData> &prepared,
-                                                                           PendingQueryParameters parameters) {
+                                                                           const PendingQueryParameters &parameters) {
 	try {
 		InitialCleanup(lock);
 	} catch (const Exception &ex) {
@@ -579,13 +587,13 @@ unique_ptr<PendingQueryResult> ClientContext::PendingQueryPreparedInternal(Clien
 
 unique_ptr<PendingQueryResult> ClientContext::PendingQuery(const string &query,
                                                            shared_ptr<PreparedStatementData> &prepared,
-                                                           PendingQueryParameters parameters) {
+                                                           const PendingQueryParameters &parameters) {
 	auto lock = LockContext();
 	return PendingQueryPreparedInternal(*lock, query, prepared, parameters);
 }
 
 unique_ptr<QueryResult> ClientContext::Execute(const string &query, shared_ptr<PreparedStatementData> &prepared,
-                                               PendingQueryParameters parameters) {
+                                               const PendingQueryParameters &parameters) {
 	auto lock = LockContext();
 	auto pending = PendingQueryPreparedInternal(*lock, query, prepared, parameters);
 	if (pending->HasError()) {
@@ -595,7 +603,7 @@ unique_ptr<QueryResult> ClientContext::Execute(const string &query, shared_ptr<P
 }
 
 unique_ptr<QueryResult> ClientContext::Execute(const string &query, shared_ptr<PreparedStatementData> &prepared,
-                                               vector<Value> &values, bool allow_stream_result) {
+                                               case_insensitive_map_t<Value> &values, bool allow_stream_result) {
 	PendingQueryParameters parameters;
 	parameters.parameters = &values;
 	parameters.allow_stream_result = allow_stream_result;
@@ -604,10 +612,11 @@ unique_ptr<QueryResult> ClientContext::Execute(const string &query, shared_ptr<P
 
 unique_ptr<PendingQueryResult> ClientContext::PendingStatementInternal(ClientContextLock &lock, const string &query,
                                                                        unique_ptr<SQLStatement> statement,
-                                                                       PendingQueryParameters parameters) {
+                                                                       const PendingQueryParameters &parameters) {
 	// prepare the query for execution
 	auto prepared = CreatePreparedStatement(lock, query, std::move(statement), parameters.parameters);
-	if (prepared->properties.parameter_count > 0 && !parameters.parameters) {
+	idx_t parameter_count = !parameters.parameters ? 0 : parameters.parameters->size();
+	if (prepared->properties.parameter_count > 0 && parameter_count == 0) {
 		string error_message = StringUtil::Format("Expected %lld parameters, but none were supplied",
 		                                          prepared->properties.parameter_count);
 		return make_uniq<PendingQueryResult>(PreservedError(error_message));
@@ -640,7 +649,7 @@ bool ClientContext::IsActiveResult(ClientContextLock &lock, BaseQueryResult *res
 
 unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatementInternal(
     ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement,
-    shared_ptr<PreparedStatementData> &prepared, PendingQueryParameters parameters) {
+    shared_ptr<PreparedStatementData> &prepared, const PendingQueryParameters &parameters) {
 	// check if we are on AutoCommit. In this case we should start a transaction.
 	if (statement && config.AnyVerification()) {
 		// query verification is enabled
@@ -697,7 +706,7 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatemen
 
 unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatement(
     ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement,
-    shared_ptr<PreparedStatementData> &prepared, PendingQueryParameters parameters) {
+    shared_ptr<PreparedStatementData> &prepared, const PendingQueryParameters &parameters) {
 	unique_ptr<PendingQueryResult> result;
 
 	try {
@@ -722,7 +731,7 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatemen
 		if (statement) {
 			result = PendingStatementInternal(lock, query, std::move(statement), parameters);
 		} else {
-			if (prepared->RequireRebind(*this, *parameters.parameters)) {
+			if (prepared->RequireRebind(*this, parameters.parameters)) {
 				// catalog was modified: rebind the statement before execution
 				auto new_prepared =
 				    CreatePreparedStatement(lock, query, prepared->unbound_statement->Copy(), parameters.parameters);
@@ -884,7 +893,8 @@ unique_ptr<PendingQueryResult> ClientContext::PendingQuery(unique_ptr<SQLStateme
 
 unique_ptr<PendingQueryResult> ClientContext::PendingQueryInternal(ClientContextLock &lock,
                                                                    unique_ptr<SQLStatement> statement,
-                                                                   PendingQueryParameters parameters, bool verify) {
+                                                                   const PendingQueryParameters &parameters,
+                                                                   bool verify) {
 	auto query = statement->query;
 	shared_ptr<PreparedStatementData> prepared;
 	if (verify) {

package/src/duckdb/src/main/client_verify.cpp

@@ -7,6 +7,20 @@
 
 namespace duckdb {
 
+static void ThrowIfExceptionIsInternal(StatementVerifier &verifier) {
+	if (!verifier.materialized_result) {
+		return;
+	}
+	auto &result = *verifier.materialized_result;
+	if (!result.HasError()) {
+		return;
+	}
+	auto &error = result.GetErrorObject();
+	if (error.Type() == ExceptionType::INTERNAL) {
+		error.Throw();
+	}
+}
+
 PreservedError ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
                                           unique_ptr<SQLStatement> statement) {
 	D_ASSERT(statement->type == StatementType::SELECT_STATEMENT);
@@ -81,6 +95,9 @@ PreservedError ClientContext::VerifyQuery(ClientContextLock &lock, const string
 		if (!failed) {
 			// PreparedStatementVerifier fails if it runs into a ParameterNotAllowedException, which is OK
 			statement_verifiers.push_back(std::move(prepared_statement_verifier));
+		} else {
+			// If it does fail, let's make sure it's not an internal exception
+			ThrowIfExceptionIsInternal(*prepared_statement_verifier);
 		}
 	} else {
 		if (ValidChecker::IsInvalidated(*db)) {

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

@@ -180,7 +180,8 @@ ExtensionLoadResult ExtensionHelper::LoadExtensionInternal(DuckDB &db, const std
 #endif
 
 #ifdef DUCKDB_EXTENSIONS_TEST_WITH_LOADABLE
-	if (!initial_load && StringUtil::Contains(DUCKDB_EXTENSIONS_TEST_WITH_LOADABLE, extension)) {
+	// Note: weird comma's are on purpose to do easy string contains on a list of extension names
+	if (!initial_load && StringUtil::Contains(DUCKDB_EXTENSIONS_TEST_WITH_LOADABLE, "," + extension + ",")) {
 		Connection con(db);
 		auto result = con.Query((string) "LOAD '" + DUCKDB_EXTENSIONS_BUILD_PATH + "/" + extension + "/" + extension +
 		                        ".duckdb_extension'");

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;
 }

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_array_access.cpp

@@ -27,10 +27,19 @@ unique_ptr<ParsedExpression> Transformer::TransformArrayAccess(duckdb_libpgquery
 			children.push_back(std::move(result));
 			if (index->is_slice) {
 				// slice
-				children.push_back(!index->lidx ? make_uniq<ConstantExpression>(Value())
-				                                : TransformExpression(index->lidx));
-				children.push_back(!index->uidx ? make_uniq<ConstantExpression>(Value())
-				                                : TransformExpression(index->uidx));
+				// if either the lower or upper bound is not specified, we use an empty const list so that we can
+				// handle it in the execution
+				unique_ptr<ParsedExpression> lower =
+				    index->lidx ? TransformExpression(index->lidx)
+				                : make_uniq<ConstantExpression>(Value::LIST(LogicalType::INTEGER, vector<Value>()));
+				children.push_back(std::move(lower));
+				unique_ptr<ParsedExpression> upper =
+				    index->uidx ? TransformExpression(index->uidx)
+				                : make_uniq<ConstantExpression>(Value::LIST(LogicalType::INTEGER, vector<Value>()));
+				children.push_back(std::move(upper));
+				if (index->step) {
+					children.push_back(TransformExpression(index->step));
+				}
 				result = make_uniq<OperatorExpression>(ExpressionType::ARRAY_SLICE, std::move(children));
 			} else {
 				// array access

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) {