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

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

@@ -63,7 +63,7 @@ public:
 	//! Returns the result names of the prepared statement
 	DUCKDB_API const vector<string> &GetNames();
 	//! Returns the map of parameter index to the expected type of parameter
-	DUCKDB_API vector<LogicalType> GetExpectedParameterTypes() const;
+	DUCKDB_API case_insensitive_map_t<LogicalType> GetExpectedParameterTypes() const;
 
 	//! Create a pending query result of the prepared statement with the given set of arguments
 	template <typename... Args>
@@ -72,6 +72,20 @@ public:
 		return PendingQueryRecursive(values, args...);
 	}
 
+	//! Create a pending query result of the prepared statement with the given set of arguments
+	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,
+	                                                       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,
+	                                           bool allow_stream_result = true);
+
 	//! Execute the prepared statement with the given set of arguments
 	template <typename... Args>
 	unique_ptr<QueryResult> Execute(Args... args) {
@@ -79,11 +93,65 @@ public:
 		return ExecuteRecursive(values, args...);
 	}
 
-	//! Create a pending query result of the prepared statement with the given set of arguments
-	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(vector<Value> &values, bool allow_stream_result = true);
+	template <class PAYLOAD>
+	static string ExcessValuesException(const case_insensitive_map_t<idx_t> &parameters,
+	                                    case_insensitive_map_t<PAYLOAD> &values) {
+		// Too many values
+		set<string> excess_set;
+		for (auto &pair : values) {
+			auto &name = pair.first;
+			if (!parameters.count(name)) {
+				excess_set.insert(name);
+			}
+		}
+		vector<string> excess_values;
+		for (auto &val : excess_set) {
+			excess_values.push_back(val);
+		}
+		return StringUtil::Format("Parameter argument/count mismatch, identifiers of the excess parameters: %s",
+		                          StringUtil::Join(excess_values, ", "));
+	}
 
-	//! Execute the prepared statement with the given set of values
-	DUCKDB_API unique_ptr<QueryResult> Execute(vector<Value> &values, bool allow_stream_result = true);
+	template <class PAYLOAD>
+	static string MissingValuesException(const case_insensitive_map_t<idx_t> &parameters,
+	                                     case_insensitive_map_t<PAYLOAD> &values) {
+		// Missing values
+		set<string> missing_set;
+		for (auto &pair : parameters) {
+			auto &name = pair.first;
+			if (!values.count(name)) {
+				missing_set.insert(name);
+			}
+		}
+		vector<string> missing_values;
+		for (auto &val : missing_set) {
+			missing_values.push_back(val);
+		}
+		return StringUtil::Format("Values were not provided for the following prepared statement parameters: %s",
+		                          StringUtil::Join(missing_values, ", "));
+	}
+
+	template <class PAYLOAD>
+	static void VerifyParameters(case_insensitive_map_t<PAYLOAD> &provided,
+	                             const case_insensitive_map_t<idx_t> &expected) {
+		if (expected.size() == provided.size()) {
+			// Same amount of identifiers, if
+			for (auto &pair : expected) {
+				auto &identifier = pair.first;
+				if (!provided.count(identifier)) {
+					throw InvalidInputException(MissingValuesException(expected, provided));
+				}
+			}
+			return;
+		}
+		// Mismatch in expected and provided parameters/values
+		if (expected.size() > provided.size()) {
+			throw InvalidInputException(MissingValuesException(expected, provided));
+		} else {
+			D_ASSERT(provided.size() > expected.size());
+			throw InvalidInputException(ExcessValuesException(expected, provided));
+		}
+	}
 
 private:
 	unique_ptr<PendingQueryResult> PendingQueryRecursive(vector<Value> &values) {

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

@@ -31,8 +31,6 @@ public:
 	unique_ptr<SQLStatement> unbound_statement;
 	//! The fully prepared physical plan of the prepared statement
 	unique_ptr<PhysicalOperator> plan;
-	//! The map of parameter index to the actual value entry
-	bound_parameter_map_t value_map;
 
 	//! The result names of the transaction
 	vector<string> names;
@@ -45,17 +43,19 @@ public:
 	//! 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;
 
 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, const vector<Value> &values);
+	bool RequireRebind(ClientContext &context, optional_ptr<case_insensitive_map_t<Value>> values);
 	//! Bind a set of values to the prepared statement data
-	DUCKDB_API void Bind(vector<Value> values);
+	DUCKDB_API void Bind(case_insensitive_map_t<Value> values);
 	//! Get the expected SQL Type of the bound parameter
-	DUCKDB_API LogicalType GetType(idx_t param_index);
+	DUCKDB_API LogicalType GetType(const string &identifier);
 	//! Try to get the expected SQL Type of the bound parameter
-	DUCKDB_API bool TryGetType(idx_t param_idx, LogicalType &result);
+	DUCKDB_API bool TryGetType(const string &identifier, LogicalType &result);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/operator_expression.hpp

@@ -12,6 +12,7 @@
 #include "duckdb/common/vector.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/parser/qualified_name.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
 
 namespace duckdb {
 //! Represents a built-in operator expression
@@ -86,9 +87,25 @@ public:
 			return "(" + entry.children[0]->ToString() + " IS NOT NULL)";
 		case ExpressionType::ARRAY_EXTRACT:
 			return entry.children[0]->ToString() + "[" + entry.children[1]->ToString() + "]";
-		case ExpressionType::ARRAY_SLICE:
-			return entry.children[0]->ToString() + "[" + entry.children[1]->ToString() + ":" +
-			       entry.children[2]->ToString() + "]";
+		case ExpressionType::ARRAY_SLICE: {
+			string begin = entry.children[1]->ToString();
+			if (begin == "[]") {
+				begin = "";
+			}
+			string end = entry.children[2]->ToString();
+			if (end == "[]") {
+				if (entry.children.size() == 4) {
+					end = "-";
+				} else {
+					end = "";
+				}
+			}
+			if (entry.children.size() == 4) {
+				return entry.children[0]->ToString() + "[" + begin + ":" + end + ":" + entry.children[3]->ToString() +
+				       "]";
+			}
+			return entry.children[0]->ToString() + "[" + begin + ":" + end + "]";
+		}
 		case ExpressionType::STRUCT_EXTRACT: {
 			if (entry.children[1]->type != ExpressionType::VALUE_CONSTANT) {
 				return string();

package/src/duckdb/src/include/duckdb/parser/expression/parameter_expression.hpp

@@ -11,6 +11,22 @@
 #include "duckdb/parser/parsed_expression.hpp"
 
 namespace duckdb {
+
+// Parameters come in three different types:
+// auto-increment:
+//	token: '?'
+//	name: -
+//	number: 0
+// positional:
+//	token: '$<number>'
+//	name: -
+//	number: <number>
+// named:
+//	token: '$<name>'
+//	name: <name>
+//	number: 0
+enum class PreparedParamType : uint8_t { AUTO_INCREMENT, POSITIONAL, NAMED, INVALID };
+
 class ParameterExpression : public ParsedExpression {
 public:
 	static constexpr const ExpressionClass TYPE = ExpressionClass::PARAMETER;
@@ -18,7 +34,7 @@ public:
 public:
 	ParameterExpression();
 
-	idx_t parameter_nr;
+	string identifier;
 
 public:
 	bool IsScalar() const override {

package/src/duckdb/src/include/duckdb/parser/statement/execute_statement.hpp

@@ -22,7 +22,7 @@ public:
 	ExecuteStatement();
 
 	string name;
-	vector<unique_ptr<ParsedExpression>> values;
+	case_insensitive_map_t<unique_ptr<ParsedExpression>> named_values;
 
 protected:
 	ExecuteStatement(const ExecuteStatement &other);

package/src/duckdb/src/include/duckdb/parser/transformer.hpp

@@ -23,6 +23,7 @@
 #include "nodes/parsenodes.hpp"
 #include "nodes/primnodes.hpp"
 #include "pg_definitions.hpp"
+#include "duckdb/parser/expression/parameter_expression.hpp"
 
 namespace duckdb {
 
@@ -67,6 +68,8 @@ private:
 	idx_t prepared_statement_parameter_index = 0;
 	//! Map from named parameter to parameter index;
 	case_insensitive_map_t<idx_t> named_param_map;
+	//! Last parameter type
+	PreparedParamType last_param_type = PreparedParamType::INVALID;
 	//! Holds window expressions defined by name. We need those when transforming the expressions referring to them.
 	unordered_map<string, duckdb_libpgquery::PGWindowDef *> window_clauses;
 	//! The set of pivot entries to create
@@ -82,9 +85,8 @@ private:
 	Transformer &RootTransformer();
 	const Transformer &RootTransformer() const;
 	void SetParamCount(idx_t new_count);
-	void SetNamedParam(const string &name, int32_t index);
-	bool GetNamedParam(const string &name, int32_t &index);
-	bool HasNamedParameters() const;
+	void SetParam(const string &name, idx_t index, PreparedParamType type);
+	bool GetParam(const string &name, idx_t &index, PreparedParamType type);
 
 	void AddPivotEntry(string enum_name, unique_ptr<SelectNode> source, unique_ptr<ParsedExpression> column,
 	                   unique_ptr<QueryNode> subquery);

package/src/duckdb/src/include/duckdb/planner/bound_parameter_map.hpp

@@ -10,11 +10,12 @@
 
 #include "duckdb/common/types.hpp"
 #include "duckdb/common/unordered_map.hpp"
+#include "duckdb/common/case_insensitive_map.hpp"
 
 namespace duckdb {
 
 struct BoundParameterData;
 
-using bound_parameter_map_t = unordered_map<idx_t, shared_ptr<BoundParameterData>>;
+using bound_parameter_map_t = case_insensitive_map_t<shared_ptr<BoundParameterData>>;
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression/bound_parameter_data.hpp

@@ -11,19 +11,32 @@
 #include "duckdb/common/types/value.hpp"
 #include "duckdb/planner/bound_parameter_map.hpp"
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/case_insensitive_map.hpp"
 
 namespace duckdb {
 
 struct BoundParameterData {
+public:
 	BoundParameterData() {
 	}
 	explicit BoundParameterData(Value val) : value(std::move(val)), return_type(value.type()) {
 	}
 
+private:
 	Value value;
+
+public:
 	LogicalType return_type;
 
 public:
+	void SetValue(Value val) {
+		value = std::move(val);
+	}
+
+	const Value &GetValue() const {
+		return value;
+	}
+
 	void Serialize(Serializer &serializer) const {
 		FieldWriter writer(serializer);
 		value.Serialize(writer.GetSerializer());
@@ -45,17 +58,19 @@ public:
 };
 
 struct BoundParameterMap {
-	explicit BoundParameterMap(vector<BoundParameterData> &parameter_data) : parameter_data(parameter_data) {
+	explicit BoundParameterMap(case_insensitive_map_t<BoundParameterData> &parameter_data)
+	    : parameter_data(parameter_data) {
 	}
 
 	bound_parameter_map_t parameters;
-	vector<BoundParameterData> &parameter_data;
+	case_insensitive_map_t<BoundParameterData> &parameter_data;
 
-	LogicalType GetReturnType(idx_t index) {
-		if (index >= parameter_data.size()) {
+	LogicalType GetReturnType(const string &identifier) {
+		auto it = parameter_data.find(identifier);
+		if (it == parameter_data.end()) {
 			return LogicalTypeId::UNKNOWN;
 		}
-		return parameter_data[index].return_type;
+		return it->second.return_type;
 	}
 };
 

package/src/duckdb/src/include/duckdb/planner/expression/bound_parameter_expression.hpp

@@ -18,9 +18,9 @@ public:
 	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_PARAMETER;
 
 public:
-	explicit BoundParameterExpression(idx_t parameter_nr);
+	explicit BoundParameterExpression(const string &identifier);
 
-	idx_t parameter_nr;
+	string identifier;
 	shared_ptr<BoundParameterData> parameter_data;
 
 public:
@@ -47,7 +47,7 @@ public:
 	static unique_ptr<Expression> FormatDeserialize(FormatDeserializer &deserializer);
 
 private:
-	BoundParameterExpression(bound_parameter_map_t &global_parameter_set, idx_t parameter_nr, LogicalType return_type,
+	BoundParameterExpression(bound_parameter_map_t &global_parameter_set, string identifier, LogicalType return_type,
 	                         shared_ptr<BoundParameterData> parameter_data);
 };
 

package/src/duckdb/src/include/duckdb/planner/planner.hpp

@@ -25,21 +25,22 @@ class Planner {
 public:
 	explicit Planner(ClientContext &context);
 
+public:
 	unique_ptr<LogicalOperator> plan;
 	vector<string> names;
 	vector<LogicalType> types;
-	bound_parameter_map_t value_map;
-	vector<BoundParameterData> parameter_data;
+	case_insensitive_map_t<BoundParameterData> parameter_data;
 
 	shared_ptr<Binder> binder;
 	ClientContext &context;
 
 	StatementProperties properties;
+	bound_parameter_map_t value_map;
 
 public:
 	void CreatePlan(unique_ptr<SQLStatement> statement);
 	static void VerifyPlan(ClientContext &context, unique_ptr<LogicalOperator> &op,
-	                       bound_parameter_map_t *map = nullptr);
+	                       optional_ptr<bound_parameter_map_t> map = nullptr);
 
 private:
 	void CreatePlan(SQLStatement &statement);

package/src/duckdb/src/include/duckdb/storage/object_cache.hpp

@@ -48,7 +48,7 @@ public:
 	}
 
 	template <class T, class... Args>
-	shared_ptr<T> GetOrCreate(const string &key, Args &&... args) {
+	shared_ptr<T> GetOrCreate(const string &key, Args &&...args) {
 		lock_guard<mutex> glock(lock);
 
 		auto entry = cache.find(key);

package/src/duckdb/src/include/duckdb/verification/prepared_statement_verifier.hpp

@@ -21,7 +21,7 @@ public:
 	         const std::function<unique_ptr<QueryResult>(const string &, unique_ptr<SQLStatement>)> &run) override;
 
 private:
-	vector<unique_ptr<ParsedExpression>> values;
+	case_insensitive_map_t<unique_ptr<ParsedExpression>> values;
 	unique_ptr<SQLStatement> prepare_statement;
 	unique_ptr<SQLStatement> execute_statement;
 	unique_ptr<SQLStatement> dealloc_statement;

package/src/duckdb/src/include/duckdb.h

@@ -944,6 +944,16 @@ Returns 0 if the query was not successfully prepared.
 */
 DUCKDB_API idx_t duckdb_nparams(duckdb_prepared_statement prepared_statement);
 
+/*!
+Returns the name used to identify the parameter
+The returned string should be freed using `duckdb_free`.
+
+Returns NULL if the index is out of range for the provided prepared statement.
+
+* prepared_statement: The prepared statement for which to get the parameter name from.
+*/
+const char *duckdb_parameter_name(duckdb_prepared_statement prepared_statement, idx_t index);
+
 /*!
 Returns the parameter type for the parameter at the given index.
 
@@ -960,6 +970,12 @@ Clear the params bind to the prepared statement.
 */
 DUCKDB_API duckdb_state duckdb_clear_bindings(duckdb_prepared_statement prepared_statement);
 
+/*!
+Retrieve the index of the parameter for the prepared statement, identified by name
+*/
+DUCKDB_API duckdb_state duckdb_bind_parameter_index(duckdb_prepared_statement prepared_statement, idx_t *param_idx_out,
+                                                    const char *name);
+
 /*!
 Binds a bool value to the prepared statement at the specified index.
 */

package/src/duckdb/src/main/capi/pending-c.cpp

@@ -2,12 +2,17 @@
 #include "duckdb/main/query_result.hpp"
 #include "duckdb/main/pending_query_result.hpp"
 #include "duckdb/common/preserved_error.hpp"
+#include "duckdb/common/case_insensitive_map.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
+using duckdb::case_insensitive_map_t;
 using duckdb::make_uniq;
+using duckdb::optional_ptr;
 using duckdb::PendingExecutionResult;
 using duckdb::PendingQueryResult;
 using duckdb::PendingStatementWrapper;
 using duckdb::PreparedStatementWrapper;
+using duckdb::Value;
 
 duckdb_state duckdb_pending_prepared_internal(duckdb_prepared_statement prepared_statement,
                                               duckdb_pending_result *out_result, bool allow_streaming) {
@@ -17,6 +22,7 @@ duckdb_state duckdb_pending_prepared_internal(duckdb_prepared_statement prepared
 	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
 	auto result = new PendingStatementWrapper();
 	result->allow_streaming = allow_streaming;
+
 	try {
 		result->statement = wrapper->statement->PendingQuery(wrapper->values, allow_streaming);
 	} catch (const duckdb::Exception &ex) {

package/src/duckdb/src/main/capi/prepared-c.cpp

@@ -2,7 +2,10 @@
 #include "duckdb/main/query_result.hpp"
 #include "duckdb/main/prepared_statement_data.hpp"
 #include "duckdb/common/types/decimal.hpp"
+#include "duckdb/common/optional_ptr.hpp"
+#include "duckdb/common/case_insensitive_map.hpp"
 
+using duckdb::case_insensitive_map_t;
 using duckdb::Connection;
 using duckdb::date_t;
 using duckdb::dtime_t;
@@ -10,8 +13,10 @@ using duckdb::ExtractStatementsWrapper;
 using duckdb::hugeint_t;
 using duckdb::LogicalType;
 using duckdb::MaterializedQueryResult;
+using duckdb::optional_ptr;
 using duckdb::PreparedStatementWrapper;
 using duckdb::QueryResultType;
+using duckdb::StringUtil;
 using duckdb::timestamp_t;
 using duckdb::Value;
 
@@ -84,13 +89,42 @@ idx_t duckdb_nparams(duckdb_prepared_statement prepared_statement) {
 	return wrapper->statement->n_param;
 }
 
+static duckdb::string duckdb_parameter_name_internal(duckdb_prepared_statement prepared_statement, idx_t index) {
+	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
+	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
+		return duckdb::string();
+	}
+	if (index > wrapper->statement->n_param) {
+		return duckdb::string();
+	}
+	for (auto &item : wrapper->statement->named_param_map) {
+		auto &identifier = item.first;
+		auto &param_idx = item.second;
+		if (param_idx == index) {
+			// Found the matching parameter
+			return identifier;
+		}
+	}
+	// No parameter was found with this index
+	return duckdb::string();
+}
+
+const char *duckdb_parameter_name(duckdb_prepared_statement prepared_statement, idx_t index) {
+	auto identifier = duckdb_parameter_name_internal(prepared_statement, index);
+	if (identifier == duckdb::string()) {
+		return NULL;
+	}
+	return strdup(identifier.c_str());
+}
+
 duckdb_type duckdb_param_type(duckdb_prepared_statement prepared_statement, idx_t param_idx) {
 	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
 	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
 		return DUCKDB_TYPE_INVALID;
 	}
 	LogicalType param_type;
-	if (!wrapper->statement->data->TryGetType(param_idx, param_type)) {
+	auto identifier = std::to_string(param_idx);
+	if (!wrapper->statement->data->TryGetType(identifier, param_type)) {
 		return DUCKDB_TYPE_INVALID;
 	}
 	return ConvertCPPTypeToC(param_type);
@@ -113,10 +147,23 @@ static duckdb_state duckdb_bind_value(duckdb_prepared_statement prepared_stateme
 	if (param_idx <= 0 || param_idx > wrapper->statement->n_param) {
 		return DuckDBError;
 	}
-	if (param_idx > wrapper->values.size()) {
-		wrapper->values.resize(param_idx);
+	auto identifier = duckdb_parameter_name_internal(prepared_statement, param_idx);
+	wrapper->values[identifier] = val;
+	return DuckDBSuccess;
+}
+
+duckdb_state duckdb_bind_parameter_index(duckdb_prepared_statement prepared_statement, idx_t *param_idx_out,
+                                         const char *name) {
+	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
+	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
+		return DuckDBError;
+	}
+	auto &statement = wrapper->statement;
+	auto entry = statement->named_param_map.find(name);
+	if (entry == statement->named_param_map.end()) {
+		return DuckDBError;
 	}
-	wrapper->values[param_idx - 1] = val;
+	*param_idx_out = entry->second;
 	return DuckDBSuccess;
 }
 
@@ -232,6 +279,7 @@ duckdb_state duckdb_execute_prepared(duckdb_prepared_statement prepared_statemen
 	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
 		return DuckDBError;
 	}
+
 	auto result = wrapper->statement->Execute(wrapper->values, false);
 	return duckdb_translate_result(std::move(result), out_result);
 }