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

package/src/duckdb/src/include/duckdb/common/helper.hpp

@@ -37,6 +37,14 @@ namespace duckdb {
 #define DUCKDB_EXPLICIT_FALLTHROUGH
 #endif
 
+template <class... T>
+struct AlwaysFalse {
+	static constexpr bool value = false;
+};
+
+template<typename T>
+using reference = std::reference_wrapper<T>;
+
 template<class _Tp, bool SAFE = true>
 struct __unique_if
 {
@@ -193,9 +201,6 @@ void AssignSharedPointer(shared_ptr<T> &target, const shared_ptr<T> &source) {
 	}
 }
 
-template<typename T>
-using reference = std::reference_wrapper<T>;
-
 template<typename T>
 using const_reference = std::reference_wrapper<const T>;
 

package/src/duckdb/src/include/duckdb/common/types/value.hpp

@@ -177,7 +177,10 @@ public:
 	template <class T>
 	T GetValue() const;
 	template <class T>
-	static Value CreateValue(T value);
+	static Value CreateValue(T value) {
+		static_assert(AlwaysFalse<T>::value, "No specialization exists for this type");
+		return Value(nullptr);
+	}
 	// Returns the internal value. Unlike GetValue(), this method does not perform casting, and assumes T matches the
 	// type of the value. Only use this if you know what you are doing.
 	template <class T>

package/src/duckdb/src/include/duckdb/execution/index/art/art.hpp

@@ -35,14 +35,16 @@ public:
 	//! Constructs an ART
 	ART(const vector<column_t> &column_ids, TableIOManager &table_io_manager,
 	    const vector<unique_ptr<Expression>> &unbound_expressions, const IndexConstraintType constraint_type,
-	    AttachedDatabase &db, const idx_t block_id = DConstants::INVALID_INDEX,
-	    const idx_t block_offset = DConstants::INVALID_INDEX);
+	    AttachedDatabase &db, const shared_ptr<vector<FixedSizeAllocator>> &allocators_ptr = nullptr,
+	    const idx_t block_id = DConstants::INVALID_INDEX, const idx_t block_offset = DConstants::INVALID_INDEX);
 	~ART() override;
 
 	//! Root of the tree
 	unique_ptr<Node> tree;
 	//! Fixed-size allocators holding the ART nodes
-	vector<unique_ptr<FixedSizeAllocator>> allocators;
+	shared_ptr<vector<FixedSizeAllocator>> allocators;
+	//! True, if the ART owns its data
+	bool owns_data;
 
 public:
 	//! Initialize a single predicate scan on the index with the given expression and column IDs
@@ -102,12 +104,12 @@ public:
 
 	//! Find the node with a matching key, or return nullptr if not found
 	Node Lookup(Node node, const ARTKey &key, idx_t depth);
+	//! Insert a key into the tree
+	bool Insert(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id);
 
 private:
 	//! Insert a row ID into a leaf
 	bool InsertToLeaf(Node &leaf, const row_t &row_id);
-	//! Insert a key into the tree
-	bool Insert(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id);
 	//! Erase a key from the tree (if a leaf has more than one value) or erase the leaf itself
 	void Erase(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id);
 

package/src/duckdb/src/include/duckdb/execution/index/art/leaf.hpp

@@ -49,9 +49,9 @@ public:
 		return *Node::GetAllocator(art, NType::LEAF).Get<Leaf>(ptr);
 	}
 
-	//! Initializes a merge by incrementing the buffer IDs of the leaf
+	//! Initializes a merge by incrementing the buffer IDs of the leaf (chain)
 	static void InitializeMerge(ART &art, Node &node, const ARTFlags &flags);
-	//! Merge leaves and free all copied leaf nodes
+	//! Merge leaves (chains) and free all copied leaf nodes
 	static void Merge(ART &art, Node &l_node, Node &r_node);
 
 	//! Insert a row ID into a leaf
@@ -66,15 +66,15 @@ public:
 	//! Returns whether the leaf contains the row ID
 	static bool ContainsRowId(ART &art, Node &node, const row_t row_id);
 
-	//! Returns the string representation of the leaf, or only traverses and verifies the leaf
+	//! Returns the string representation of the leaf (chain), or only traverses and verifies the leaf (chain)
 	static string VerifyAndToString(ART &art, Node &node);
 
-	//! Serialize the leaf
+	//! Serialize the leaf (chain)
 	static BlockPointer Serialize(ART &art, Node &node, MetaBlockWriter &writer);
-	//! Deserialize the leaf
+	//! Deserialize the leaf (chain)
 	static void Deserialize(ART &art, Node &node, MetaBlockReader &reader);
 
-	//! Vacuum the leaf
+	//! Vacuum the leaf (chain)
 	static void Vacuum(ART &art, Node &node);
 
 private:

package/src/duckdb/src/include/duckdb/execution/index/art/node.hpp

@@ -180,6 +180,12 @@ public:
 		data = 0;
 	}
 
+	//! Adds an idx_t to a buffer ID, the rightmost 32 bits contain the buffer ID
+	inline void AddToBufferID(const idx_t summand) {
+		D_ASSERT(summand < NumericLimits<uint32_t>().Maximum());
+		data += summand;
+	}
+
 	//! Comparison operator
 	inline bool operator==(const Node &node) const {
 		return data == node.data;

package/src/duckdb/src/include/duckdb/execution/index/art/prefix.hpp

@@ -42,10 +42,8 @@ public:
 		return *Node::GetAllocator(art, NType::PREFIX).Get<Prefix>(ptr);
 	}
 
-	//! Initializes a merge by incrementing the buffer ID of the child node(s)
-	inline void InitializeMerge(ART &art, const ARTFlags &flags) {
-		ptr.InitializeMerge(art, flags);
-	}
+	//! Initializes a merge by incrementing the buffer ID of the prefix and its child node(s)
+	static void InitializeMerge(ART &art, Node &node, const ARTFlags &flags);
 
 	//! Appends a byte and a child_prefix to prefix. If there is no prefix, than it pushes the
 	//! byte on top of child_prefix. If there is no child_prefix, then it creates a new
@@ -75,15 +73,13 @@ public:
 	//! Returns the string representation of the node, or only traverses and verifies the node and its subtree
 	static string VerifyAndToString(ART &art, Node &node, const bool only_verify);
 
-	//! Serialize this node
-	BlockPointer Serialize(ART &art, MetaBlockWriter &writer);
-	//! Deserialize this node
-	void Deserialize(MetaBlockReader &reader);
+	//! Serialize this node and all subsequent nodes
+	static BlockPointer Serialize(ART &art, Node &node, MetaBlockWriter &writer);
+	//! Deserialize this node and all subsequent prefix nodes
+	static void Deserialize(ART &art, Node &node, MetaBlockReader &reader);
 
 	//! Vacuum the child of the node
-	inline void Vacuum(ART &art, const ARTFlags &flags) {
-		ptr.Vacuum(art, flags);
-	}
+	static void Vacuum(ART &art, Node &node, const ARTFlags &flags);
 
 private:
 	//! Appends the byte to this prefix node, or creates a subsequent prefix node,
@@ -92,6 +88,8 @@ private:
 	//! Appends the other_prefix and all its subsequent prefix nodes to this prefix node.
 	//! Also frees all copied/appended nodes
 	void Append(ART &art, Node other_prefix);
+	//! Get the total count of bytes in the chain of prefixes, with the node reference pointing to first non-prefix node
+	static idx_t TotalCount(ART &art, reference<Node> &node);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_index.hpp

@@ -27,7 +27,7 @@ public:
 public:
 	PhysicalCreateIndex(LogicalOperator &op, TableCatalogEntry &table, const vector<column_t> &column_ids,
 	                    unique_ptr<CreateIndexInfo> info, vector<unique_ptr<Expression>> unbound_expressions,
-	                    idx_t estimated_cardinality);
+	                    idx_t estimated_cardinality, const bool sorted);
 
 	//! The table to create the index for
 	DuckTableEntry &table;
@@ -37,6 +37,8 @@ public:
 	unique_ptr<CreateIndexInfo> info;
 	//! Unbound expressions to be used in the optimizer
 	vector<unique_ptr<Expression>> unbound_expressions;
+	//! Whether the pipeline sorts the data prior to index creation
+	const bool sorted;
 
 public:
 	//! Source interface, NOP for this operator
@@ -52,6 +54,11 @@ public:
 	//! Sink interface, global sink state
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
 
+	//! Sink for unsorted data: insert iteratively
+	SinkResultType SinkUnsorted(Vector &row_identifiers, OperatorSinkInput &input) const;
+	//! Sink for sorted data: build + merge
+	SinkResultType SinkSorted(Vector &row_identifiers, OperatorSinkInput &input) const;
+
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
 	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,

package/src/duckdb/src/include/duckdb/function/table/arrow/arrow_duck_schema.hpp

@@ -0,0 +1,99 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/function/table/arrow_duck_schema.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/types.hpp"
+#include "duckdb/common/unordered_map.hpp"
+#include "duckdb/common/vector.hpp"
+#include "duckdb/common/unique_ptr.hpp"
+
+namespace duckdb {
+//===--------------------------------------------------------------------===//
+// Arrow Variable Size Types
+//===--------------------------------------------------------------------===//
+enum class ArrowVariableSizeType : uint8_t { FIXED_SIZE = 0, NORMAL = 1, SUPER_SIZE = 2 };
+
+//===--------------------------------------------------------------------===//
+// Arrow Time/Date Types
+//===--------------------------------------------------------------------===//
+enum class ArrowDateTimeType : uint8_t {
+	MILLISECONDS = 0,
+	MICROSECONDS = 1,
+	NANOSECONDS = 2,
+	SECONDS = 3,
+	DAYS = 4,
+	MONTHS = 5,
+	MONTH_DAY_NANO = 6
+};
+
+class ArrowType {
+public:
+	//! From a DuckDB type
+	ArrowType(LogicalType type_p)
+	    : type(std::move(type_p)), size_type(ArrowVariableSizeType::NORMAL),
+	      date_time_precision(ArrowDateTimeType::DAYS) {};
+
+	//! From a DuckDB type + fixed_size
+	ArrowType(LogicalType type_p, idx_t fixed_size_p)
+	    : type(std::move(type_p)), size_type(ArrowVariableSizeType::FIXED_SIZE),
+	      date_time_precision(ArrowDateTimeType::DAYS), fixed_size(fixed_size_p) {};
+
+	//! From a DuckDB type + variable size type
+	ArrowType(LogicalType type_p, ArrowVariableSizeType size_type_p)
+	    : type(std::move(type_p)), size_type(size_type_p), date_time_precision(ArrowDateTimeType::DAYS) {};
+
+	//! From a DuckDB type + datetime type
+	ArrowType(LogicalType type_p, ArrowDateTimeType date_time_precision_p)
+	    : type(std::move(type_p)), size_type(ArrowVariableSizeType::NORMAL),
+	      date_time_precision(date_time_precision_p) {};
+
+	void AddChild(unique_ptr<ArrowType> child);
+
+	void AssignChildren(vector<unique_ptr<ArrowType>> children);
+
+	const LogicalType &GetDuckType() const;
+
+	ArrowVariableSizeType GetSizeType() const;
+
+	idx_t FixedSize() const;
+
+	void SetDictionary(unique_ptr<ArrowType> dictionary);
+
+	ArrowDateTimeType GetDateTimeType() const;
+
+	const ArrowType &GetDictionary() const;
+
+	const ArrowType &operator[](idx_t index) const;
+
+private:
+	LogicalType type;
+	//! If we have a nested type, their children's type.
+	vector<unique_ptr<ArrowType>> children;
+	//! If its a variable size type (e.g., strings, blobs, lists) holds which type it is
+	ArrowVariableSizeType size_type;
+	//! If this is a date/time holds its precision
+	ArrowDateTimeType date_time_precision;
+	//! Only for size types with fixed size
+	idx_t fixed_size = 0;
+	//! Hold the optional type if the array is a dictionary
+	unique_ptr<ArrowType> dictionary_type;
+};
+
+using arrow_column_map_t = unordered_map<idx_t, unique_ptr<ArrowType>>;
+
+struct ArrowTableType {
+public:
+	void AddColumn(idx_t index, unique_ptr<ArrowType> type);
+	const arrow_column_map_t &GetColumns() const;
+
+private:
+	arrow_column_map_t arrow_convert_data;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/function/table/arrow.hpp

@@ -16,25 +16,9 @@
 #include "duckdb/common/thread.hpp"
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/function/built_in_functions.hpp"
+#include "duckdb/function/table/arrow/arrow_duck_schema.hpp"
 
 namespace duckdb {
-//===--------------------------------------------------------------------===//
-// Arrow Variable Size Types
-//===--------------------------------------------------------------------===//
-enum class ArrowVariableSizeType : uint8_t { FIXED_SIZE = 0, NORMAL = 1, SUPER_SIZE = 2 };
-
-//===--------------------------------------------------------------------===//
-// Arrow Time/Date Types
-//===--------------------------------------------------------------------===//
-enum class ArrowDateTimeType : uint8_t {
-	MILLISECONDS = 0,
-	MICROSECONDS = 1,
-	NANOSECONDS = 2,
-	SECONDS = 3,
-	DAYS = 4,
-	MONTHS = 5,
-	MONTH_DAY_NANO = 6
-};
 
 struct ArrowInterval {
 	int32_t months;
@@ -46,18 +30,6 @@ struct ArrowInterval {
 	}
 };
 
-struct ArrowConvertData {
-	ArrowConvertData(LogicalType type) : dictionary_type(type) {};
-	ArrowConvertData() {};
-
-	//! Hold type of dictionary
-	LogicalType dictionary_type;
-	//! If its a variable size type (e.g., strings, blobs, lists) holds which type it is
-	vector<pair<ArrowVariableSizeType, idx_t>> variable_sz_type;
-	//! If this is a date/time holds its precision
-	vector<ArrowDateTimeType> date_time_precision;
-};
-
 struct ArrowProjectedColumns {
 	unordered_map<idx_t, string> projection_map;
 	vector<string> columns;
@@ -73,11 +45,10 @@ typedef unique_ptr<ArrowArrayStreamWrapper> (*stream_factory_produce_t)(uintptr_
 typedef void (*stream_factory_get_schema_t)(uintptr_t stream_factory_ptr, ArrowSchemaWrapper &schema);
 
 struct ArrowScanFunctionData : public PyTableFunctionData {
+public:
 	ArrowScanFunctionData(stream_factory_produce_t scanner_producer_p, uintptr_t stream_factory_ptr_p)
 	    : lines_read(0), stream_factory_ptr(stream_factory_ptr_p), scanner_producer(scanner_producer_p) {
 	}
-	//! This holds the original list type (col_idx, [ArrowListType,size])
-	unordered_map<idx_t, unique_ptr<ArrowConvertData>> arrow_convert_data;
 	vector<LogicalType> all_types;
 	atomic<idx_t> lines_read;
 	ArrowSchemaWrapper schema_root;
@@ -86,6 +57,8 @@ struct ArrowScanFunctionData : public PyTableFunctionData {
 	uintptr_t stream_factory_ptr;
 	//! Pointer to the scanner factory produce
 	stream_factory_produce_t scanner_producer;
+	//! Arrow table data
+	ArrowTableType arrow_table;
 };
 
 struct ArrowScanLocalState : public LocalTableFunctionState {
@@ -132,8 +105,7 @@ public:
 	static unique_ptr<FunctionData> ArrowScanBind(ClientContext &context, TableFunctionBindInput &input,
 	                                              vector<LogicalType> &return_types, vector<string> &names);
 	//! Actual conversion from Arrow to DuckDB
-	static void ArrowToDuckDB(ArrowScanLocalState &scan_state,
-	                          std::unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data,
+	static void ArrowToDuckDB(ArrowScanLocalState &scan_state, const arrow_column_map_t &arrow_convert_data,
 	                          DataChunk &output, idx_t start, bool arrow_scan_is_projected = true);
 
 	//! Get next scan state
@@ -172,9 +144,7 @@ protected:
 	//! Renames repeated columns and case sensitive columns
 	static void RenameArrowColumns(vector<string> &names);
 	//! Helper function to get the DuckDB logical type
-	static LogicalType GetArrowLogicalType(ArrowSchema &schema,
-	                                       std::unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data,
-	                                       idx_t col_idx);
+	static unique_ptr<ArrowType> GetArrowLogicalType(ArrowSchema &schema);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/main/capi/capi_internal.hpp

@@ -13,6 +13,7 @@
 #include "duckdb/common/types.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/main/appender.hpp"
+#include "duckdb/common/case_insensitive_map.hpp"
 
 #include <cstring>
 #include <cassert>
@@ -30,8 +31,9 @@ struct DatabaseData {
 };
 
 struct PreparedStatementWrapper {
+	//! Map of name -> values
+	case_insensitive_map_t<Value> values;
 	unique_ptr<PreparedStatement> statement;
-	vector<Value> values;
 };
 
 struct ExtractStatementsWrapper {

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

@@ -47,7 +47,7 @@ struct ClientData;
 
 struct PendingQueryParameters {
 	//! Prepared statement parameters (if any)
-	vector<Value> *parameters = nullptr;
+	optional_ptr<case_insensitive_map_t<Value>> parameters;
 	//! Whether or not a stream result should be allowed
 	bool allow_stream_result = false;
 };
@@ -135,16 +135,17 @@ public:
 	//! Create a pending query result from a prepared statement with the given name and set of parameters
 	//! It is possible that the prepared statement will be re-bound. This will generally happen if the catalog is
 	//! modified in between the prepared statement being bound and the prepared statement being run.
-	DUCKDB_API unique_ptr<PendingQueryResult>
-	PendingQuery(const string &query, shared_ptr<PreparedStatementData> &prepared, PendingQueryParameters parameters);
+	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(const string &query,
+	                                                       shared_ptr<PreparedStatementData> &prepared,
+	                                                       const PendingQueryParameters &parameters);
 
 	//! Execute a prepared statement with the given name and set of parameters
 	//! It is possible that the prepared statement will be re-bound. This will generally happen if the catalog is
 	//! modified in between the prepared statement being bound and the prepared statement being run.
 	DUCKDB_API unique_ptr<QueryResult> Execute(const string &query, shared_ptr<PreparedStatementData> &prepared,
-	                                           vector<Value> &values, bool allow_stream_result = true);
+	                                           case_insensitive_map_t<Value> &values, bool allow_stream_result = true);
 	DUCKDB_API unique_ptr<QueryResult> Execute(const string &query, shared_ptr<PreparedStatementData> &prepared,
-	                                           PendingQueryParameters parameters);
+	                                           const PendingQueryParameters &parameters);
 
 	//! Gets current percentage of the query's progress, returns 0 in case the progress bar is disabled.
 	DUCKDB_API double GetProgress();
@@ -198,7 +199,7 @@ private:
 	                     PreservedError &error);
 	//! Issues a query to the database and returns a Pending Query Result
 	unique_ptr<PendingQueryResult> PendingQueryInternal(ClientContextLock &lock, unique_ptr<SQLStatement> statement,
-	                                                    PendingQueryParameters parameters, bool verify = true);
+	                                                    const PendingQueryParameters &parameters, bool verify = true);
 	unique_ptr<QueryResult> ExecutePendingQueryInternal(ClientContextLock &lock, PendingQueryResult &query);
 
 	//! Parse statements from a query
@@ -214,18 +215,18 @@ private:
 	unique_ptr<PendingQueryResult> PendingStatementOrPreparedStatement(ClientContextLock &lock, const string &query,
 	                                                                   unique_ptr<SQLStatement> statement,
 	                                                                   shared_ptr<PreparedStatementData> &prepared,
-	                                                                   PendingQueryParameters parameters);
+	                                                                   const PendingQueryParameters &parameters);
 	unique_ptr<PendingQueryResult> PendingPreparedStatement(ClientContextLock &lock,
 	                                                        shared_ptr<PreparedStatementData> statement_p,
-	                                                        PendingQueryParameters parameters);
+	                                                        const PendingQueryParameters &parameters);
 
 	//! Internally prepare a SQL statement. Caller must hold the context_lock.
-	shared_ptr<PreparedStatementData> CreatePreparedStatement(ClientContextLock &lock, const string &query,
-	                                                          unique_ptr<SQLStatement> statement,
-	                                                          vector<Value> *values = nullptr);
+	shared_ptr<PreparedStatementData>
+	CreatePreparedStatement(ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement,
+	                        optional_ptr<case_insensitive_map_t<Value>> values = nullptr);
 	unique_ptr<PendingQueryResult> PendingStatementInternal(ClientContextLock &lock, const string &query,
 	                                                        unique_ptr<SQLStatement> statement,
-	                                                        PendingQueryParameters parameters);
+	                                                        const PendingQueryParameters &parameters);
 	unique_ptr<QueryResult> RunStatementInternal(ClientContextLock &lock, const string &query,
 	                                             unique_ptr<SQLStatement> statement, bool allow_stream_result,
 	                                             bool verify = true);
@@ -245,11 +246,11 @@ private:
 
 	unique_ptr<PendingQueryResult> PendingStatementOrPreparedStatementInternal(
 	    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> PendingQueryPreparedInternal(ClientContextLock &lock, const string &query,
 	                                                            shared_ptr<PreparedStatementData> &prepared,
-	                                                            PendingQueryParameters parameters);
+	                                                            const PendingQueryParameters &parameters);
 
 	unique_ptr<PendingQueryResult> PendingQueryInternal(ClientContextLock &, const shared_ptr<Relation> &relation,
 	                                                    bool allow_stream_result);

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/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);