duckdb 0.10.1-dev6.0 → 0.10.1

package/src/duckdb/src/include/duckdb/storage/table/row_group_collection.hpp

@@ -69,8 +69,9 @@ public:
 
 	//! Initialize an append of a variable number of rows. FinalizeAppend must be called after appending is done.
 	void InitializeAppend(TableAppendState &state);
-	//! Initialize an append with a known number of rows. FinalizeAppend should not be called after appending is done.
-	void InitializeAppend(TransactionData transaction, TableAppendState &state, idx_t append_count);
+	//! Initialize an append with a variable number of rows. FinalizeAppend should not be called after appending is
+	//! done.
+	void InitializeAppend(TransactionData transaction, TableAppendState &state);
 	//! Appends to the row group collection. Returns true if a new row group has been created to append to
 	bool Append(DataChunk &chunk, TableAppendState &state);
 	//! FinalizeAppend flushes an append with a variable number of rows.
@@ -119,6 +120,10 @@ public:
 		return *info;
 	}
 
+	idx_t GetAllocationSize() const {
+		return allocation_size;
+	}
+
 private:
 	bool IsEmpty(SegmentLock &) const;
 
@@ -136,6 +141,8 @@ private:
 	shared_ptr<RowGroupSegmentTree> row_groups;
 	//! Table statistics
 	TableStatistics stats;
+	//! Allocation size, only tracked for appends
+	idx_t allocation_size;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/table/scan_state.hpp

@@ -39,7 +39,7 @@ struct SegmentScanState {
 
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
@@ -55,7 +55,7 @@ struct IndexScanState {
 
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
@@ -84,10 +84,6 @@ struct ColumnScanState {
 	bool initialized = false;
 	//! If this segment has already been checked for skipping purposes
 	bool segment_checked = false;
-	//! The version of the column data that we are scanning.
-	//! This is used to detect if the ColumnData has been changed out from under us during a scan
-	//! If this is the case, we re-initialize the scan
-	idx_t version = 0;
 	//! We initialize one SegmentScanState per segment, however, if scanning a DataChunk requires us to scan over more
 	//! than one Segment, we need to keep the scan states of the previous segments around
 	vector<unique_ptr<SegmentScanState>> previous_states;

package/src/duckdb/src/include/duckdb/storage/table/segment_tree.hpp

@@ -69,6 +69,9 @@ public:
 	}
 	idx_t GetSegmentCount() {
 		auto l = Lock();
+		return GetSegmentCount(l);
+	}
+	idx_t GetSegmentCount(SegmentLock &l) {
 		return nodes.size();
 	}
 	//! Gets a pointer to the nth segment. Negative numbers start from the back.
@@ -207,9 +210,6 @@ public:
 		if (nodes.empty()) {
 			return false;
 		}
-		D_ASSERT(!nodes.empty());
-		D_ASSERT(row_number >= nodes[0].row_start);
-		D_ASSERT(row_number < nodes.back().row_start + nodes.back().node->count);
 		idx_t lower = 0;
 		idx_t upper = nodes.size() - 1;
 		// binary search to find the node

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

@@ -0,0 +1,169 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/temporary_file_manager.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/allocator.hpp"
+#include "duckdb/common/atomic.hpp"
+#include "duckdb/common/file_system.hpp"
+#include "duckdb/common/mutex.hpp"
+#include "duckdb/storage/block_manager.hpp"
+#include "duckdb/storage/buffer/block_handle.hpp"
+#include "duckdb/storage/buffer/buffer_pool.hpp"
+#include "duckdb/storage/buffer_manager.hpp"
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// BlockIndexManager
+//===--------------------------------------------------------------------===//
+
+struct BlockIndexManager {
+public:
+	BlockIndexManager();
+
+public:
+	//! Obtains a new block index from the index manager
+	idx_t GetNewBlockIndex();
+	//! Removes an index from the block manager
+	//! Returns true if the max_index has been altered
+	bool RemoveIndex(idx_t index);
+	idx_t GetMaxIndex();
+	bool HasFreeBlocks();
+
+private:
+	idx_t GetNewBlockIndexInternal();
+
+private:
+	idx_t max_index;
+	set<idx_t> free_indexes;
+	set<idx_t> indexes_in_use;
+};
+
+//===--------------------------------------------------------------------===//
+// TemporaryFileIndex
+//===--------------------------------------------------------------------===//
+
+// FIXME: should be optional_idx
+struct TemporaryFileIndex {
+	explicit TemporaryFileIndex(idx_t file_index = DConstants::INVALID_INDEX,
+	                            idx_t block_index = DConstants::INVALID_INDEX);
+
+	idx_t file_index;
+	idx_t block_index;
+
+public:
+	bool IsValid() const;
+};
+
+//===--------------------------------------------------------------------===//
+// TemporaryFileHandle
+//===--------------------------------------------------------------------===//
+
+class TemporaryFileHandle {
+	constexpr static idx_t MAX_ALLOWED_INDEX_BASE = 4000;
+
+public:
+	TemporaryFileHandle(idx_t temp_file_count, DatabaseInstance &db, const string &temp_directory, idx_t index);
+
+public:
+	struct TemporaryFileLock {
+	public:
+		explicit TemporaryFileLock(mutex &mutex);
+
+	public:
+		lock_guard<mutex> lock;
+	};
+
+public:
+	TemporaryFileIndex TryGetBlockIndex();
+	void WriteTemporaryFile(FileBuffer &buffer, TemporaryFileIndex index);
+	unique_ptr<FileBuffer> ReadTemporaryBuffer(idx_t block_index, unique_ptr<FileBuffer> reusable_buffer);
+	void EraseBlockIndex(block_id_t block_index);
+	bool DeleteIfEmpty();
+	TemporaryFileInformation GetTemporaryFile();
+
+private:
+	void CreateFileIfNotExists(TemporaryFileLock &);
+	void RemoveTempBlockIndex(TemporaryFileLock &, idx_t index);
+	idx_t GetPositionInFile(idx_t index);
+
+private:
+	const idx_t max_allowed_index;
+	DatabaseInstance &db;
+	unique_ptr<FileHandle> handle;
+	idx_t file_index;
+	string path;
+	mutex file_lock;
+	BlockIndexManager index_manager;
+};
+
+class TemporaryFileManager;
+
+//===--------------------------------------------------------------------===//
+// TemporaryDirectoryHandle
+//===--------------------------------------------------------------------===//
+
+class TemporaryDirectoryHandle {
+public:
+	TemporaryDirectoryHandle(DatabaseInstance &db, string path_p);
+	~TemporaryDirectoryHandle();
+
+	TemporaryFileManager &GetTempFile();
+
+private:
+	DatabaseInstance &db;
+	string temp_directory;
+	bool created_directory = false;
+	unique_ptr<TemporaryFileManager> temp_file;
+};
+
+//===--------------------------------------------------------------------===//
+// TemporaryFileManager
+//===--------------------------------------------------------------------===//
+
+class TemporaryFileManager {
+public:
+	TemporaryFileManager(DatabaseInstance &db, const string &temp_directory_p);
+
+public:
+	struct TemporaryManagerLock {
+	public:
+		explicit TemporaryManagerLock(mutex &mutex);
+
+	public:
+		lock_guard<mutex> lock;
+	};
+
+	void WriteTemporaryBuffer(block_id_t block_id, FileBuffer &buffer);
+	bool HasTemporaryBuffer(block_id_t block_id);
+	unique_ptr<FileBuffer> ReadTemporaryBuffer(block_id_t id, unique_ptr<FileBuffer> reusable_buffer);
+	void DeleteTemporaryBuffer(block_id_t id);
+	vector<TemporaryFileInformation> GetTemporaryFiles();
+
+private:
+	void EraseUsedBlock(TemporaryManagerLock &lock, block_id_t id, TemporaryFileHandle *handle,
+	                    TemporaryFileIndex index);
+	TemporaryFileHandle *GetFileHandle(TemporaryManagerLock &, idx_t index);
+	TemporaryFileIndex GetTempBlockIndex(TemporaryManagerLock &, block_id_t id);
+	void EraseFileHandle(TemporaryManagerLock &, idx_t file_index);
+
+private:
+	DatabaseInstance &db;
+	mutex manager_lock;
+	//! The temporary directory
+	string temp_directory;
+	//! The set of active temporary file handles
+	unordered_map<idx_t, unique_ptr<TemporaryFileHandle>> files;
+	//! map of block_id -> temporary file position
+	unordered_map<block_id_t, TemporaryFileIndex> used_blocks;
+	//! Manager of in-use temporary file indexes
+	BlockIndexManager index_manager;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/transaction/duck_transaction_manager.hpp

@@ -45,8 +45,14 @@ public:
 		return true;
 	}
 
+protected:
+	struct CheckpointDecision {
+		bool can_checkpoint;
+		string reason;
+	};
+
 private:
-	bool CanCheckpoint(optional_ptr<DuckTransaction> current = nullptr);
+	CheckpointDecision CanCheckpoint(optional_ptr<DuckTransaction> current = nullptr);
 	//! Remove the given transaction from the list of active transactions
 	void RemoveTransaction(DuckTransaction &transaction) noexcept;
 
@@ -69,6 +75,10 @@ private:
 	mutex transaction_lock;
 
 	bool thread_is_checkpointing;
+
+protected:
+	virtual void OnCommitCheckpointDecision(const CheckpointDecision &decision, DuckTransaction &transaction) {
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/transaction/meta_transaction.hpp

@@ -41,7 +41,7 @@ public:
 
 public:
 	DUCKDB_API static MetaTransaction &Get(ClientContext &context);
-	timestamp_t GetCurrentTransactionStartTimestamp() {
+	timestamp_t GetCurrentTransactionStartTimestamp() const {
 		return start_timestamp;
 	}
 
@@ -58,8 +58,13 @@ public:
 	optional_ptr<AttachedDatabase> ModifiedDatabase() {
 		return modified_database;
 	}
+	const vector<reference<AttachedDatabase>> &OpenedTransactions() const {
+		return all_transactions;
+	}
 
 private:
+	//! Lock to prevent all_transactions and transactions from getting out of sync
+	mutex lock;
 	//! The set of active transactions for each database
 	reference_map_t<AttachedDatabase, reference<Transaction>> transactions;
 	//! The set of transactions in order of when they were started

package/src/duckdb/src/include/duckdb/transaction/transaction.hpp

@@ -61,7 +61,7 @@ public:
 public:
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>

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

@@ -64,74 +64,77 @@ extern "C" {
 //===--------------------------------------------------------------------===//
 // Enums
 //===--------------------------------------------------------------------===//
-
+// WARNING: the numbers of these enums should not be changed, as changing the numbers breaks ABI compatibility
+// Always add enums at the END of the enum
 //! An enum over DuckDB's internal types.
 typedef enum DUCKDB_TYPE {
 	DUCKDB_TYPE_INVALID = 0,
 	// bool
-	DUCKDB_TYPE_BOOLEAN,
+	DUCKDB_TYPE_BOOLEAN = 1,
 	// int8_t
-	DUCKDB_TYPE_TINYINT,
+	DUCKDB_TYPE_TINYINT = 2,
 	// int16_t
-	DUCKDB_TYPE_SMALLINT,
+	DUCKDB_TYPE_SMALLINT = 3,
 	// int32_t
-	DUCKDB_TYPE_INTEGER,
+	DUCKDB_TYPE_INTEGER = 4,
 	// int64_t
-	DUCKDB_TYPE_BIGINT,
+	DUCKDB_TYPE_BIGINT = 5,
 	// uint8_t
-	DUCKDB_TYPE_UTINYINT,
+	DUCKDB_TYPE_UTINYINT = 6,
 	// uint16_t
-	DUCKDB_TYPE_USMALLINT,
+	DUCKDB_TYPE_USMALLINT = 7,
 	// uint32_t
-	DUCKDB_TYPE_UINTEGER,
+	DUCKDB_TYPE_UINTEGER = 8,
 	// uint64_t
-	DUCKDB_TYPE_UBIGINT,
+	DUCKDB_TYPE_UBIGINT = 9,
 	// float
-	DUCKDB_TYPE_FLOAT,
+	DUCKDB_TYPE_FLOAT = 10,
 	// double
-	DUCKDB_TYPE_DOUBLE,
+	DUCKDB_TYPE_DOUBLE = 11,
 	// duckdb_timestamp, in microseconds
-	DUCKDB_TYPE_TIMESTAMP,
+	DUCKDB_TYPE_TIMESTAMP = 12,
 	// duckdb_date
-	DUCKDB_TYPE_DATE,
+	DUCKDB_TYPE_DATE = 13,
 	// duckdb_time
-	DUCKDB_TYPE_TIME,
+	DUCKDB_TYPE_TIME = 14,
 	// duckdb_interval
-	DUCKDB_TYPE_INTERVAL,
+	DUCKDB_TYPE_INTERVAL = 15,
 	// duckdb_hugeint
-	DUCKDB_TYPE_HUGEINT,
+	DUCKDB_TYPE_HUGEINT = 16,
 	// duckdb_uhugeint
-	DUCKDB_TYPE_UHUGEINT,
+	DUCKDB_TYPE_UHUGEINT = 32,
 	// const char*
-	DUCKDB_TYPE_VARCHAR,
+	DUCKDB_TYPE_VARCHAR = 17,
 	// duckdb_blob
-	DUCKDB_TYPE_BLOB,
+	DUCKDB_TYPE_BLOB = 18,
 	// decimal
-	DUCKDB_TYPE_DECIMAL,
+	DUCKDB_TYPE_DECIMAL = 19,
 	// duckdb_timestamp, in seconds
-	DUCKDB_TYPE_TIMESTAMP_S,
+	DUCKDB_TYPE_TIMESTAMP_S = 20,
 	// duckdb_timestamp, in milliseconds
-	DUCKDB_TYPE_TIMESTAMP_MS,
+	DUCKDB_TYPE_TIMESTAMP_MS = 21,
 	// duckdb_timestamp, in nanoseconds
-	DUCKDB_TYPE_TIMESTAMP_NS,
+	DUCKDB_TYPE_TIMESTAMP_NS = 22,
 	// enum type, only useful as logical type
-	DUCKDB_TYPE_ENUM,
+	DUCKDB_TYPE_ENUM = 23,
 	// list type, only useful as logical type
-	DUCKDB_TYPE_LIST,
+	DUCKDB_TYPE_LIST = 24,
 	// struct type, only useful as logical type
-	DUCKDB_TYPE_STRUCT,
+	DUCKDB_TYPE_STRUCT = 25,
 	// map type, only useful as logical type
-	DUCKDB_TYPE_MAP,
+	DUCKDB_TYPE_MAP = 26,
+	// duckdb_array, only useful as logical type
+	DUCKDB_TYPE_ARRAY = 33,
 	// duckdb_hugeint
-	DUCKDB_TYPE_UUID,
+	DUCKDB_TYPE_UUID = 27,
 	// union type, only useful as logical type
-	DUCKDB_TYPE_UNION,
+	DUCKDB_TYPE_UNION = 28,
 	// duckdb_bit
-	DUCKDB_TYPE_BIT,
+	DUCKDB_TYPE_BIT = 29,
 	// duckdb_time_tz
-	DUCKDB_TYPE_TIME_TZ,
+	DUCKDB_TYPE_TIME_TZ = 30,
 	// duckdb_timestamp
-	DUCKDB_TYPE_TIMESTAMP_TZ,
+	DUCKDB_TYPE_TIMESTAMP_TZ = 31,
 } duckdb_type;
 //! An enum over the returned state of different functions.
 typedef enum { DuckDBSuccess = 0, DuckDBError = 1 } duckdb_state;
@@ -144,41 +147,41 @@ typedef enum {
 } duckdb_pending_state;
 //! An enum over DuckDB's different result types.
 typedef enum {
-	DUCKDB_RESULT_TYPE_INVALID,
-	DUCKDB_RESULT_TYPE_CHANGED_ROWS,
-	DUCKDB_RESULT_TYPE_NOTHING,
-	DUCKDB_RESULT_TYPE_QUERY_RESULT,
+	DUCKDB_RESULT_TYPE_INVALID = 0,
+	DUCKDB_RESULT_TYPE_CHANGED_ROWS = 1,
+	DUCKDB_RESULT_TYPE_NOTHING = 2,
+	DUCKDB_RESULT_TYPE_QUERY_RESULT = 3,
 } duckdb_result_type;
 //! An enum over DuckDB's different statement types.
 typedef enum {
-	DUCKDB_STATEMENT_TYPE_INVALID,
-	DUCKDB_STATEMENT_TYPE_SELECT,
-	DUCKDB_STATEMENT_TYPE_INSERT,
-	DUCKDB_STATEMENT_TYPE_UPDATE,
-	DUCKDB_STATEMENT_TYPE_EXPLAIN,
-	DUCKDB_STATEMENT_TYPE_DELETE,
-	DUCKDB_STATEMENT_TYPE_PREPARE,
-	DUCKDB_STATEMENT_TYPE_CREATE,
-	DUCKDB_STATEMENT_TYPE_EXECUTE,
-	DUCKDB_STATEMENT_TYPE_ALTER,
-	DUCKDB_STATEMENT_TYPE_TRANSACTION,
-	DUCKDB_STATEMENT_TYPE_COPY,
-	DUCKDB_STATEMENT_TYPE_ANALYZE,
-	DUCKDB_STATEMENT_TYPE_VARIABLE_SET,
-	DUCKDB_STATEMENT_TYPE_CREATE_FUNC,
-	DUCKDB_STATEMENT_TYPE_DROP,
-	DUCKDB_STATEMENT_TYPE_EXPORT,
-	DUCKDB_STATEMENT_TYPE_PRAGMA,
-	DUCKDB_STATEMENT_TYPE_VACUUM,
-	DUCKDB_STATEMENT_TYPE_CALL,
-	DUCKDB_STATEMENT_TYPE_SET,
-	DUCKDB_STATEMENT_TYPE_LOAD,
-	DUCKDB_STATEMENT_TYPE_RELATION,
-	DUCKDB_STATEMENT_TYPE_EXTENSION,
-	DUCKDB_STATEMENT_TYPE_LOGICAL_PLAN,
-	DUCKDB_STATEMENT_TYPE_ATTACH,
-	DUCKDB_STATEMENT_TYPE_DETACH,
-	DUCKDB_STATEMENT_TYPE_MULTI,
+	DUCKDB_STATEMENT_TYPE_INVALID = 0,
+	DUCKDB_STATEMENT_TYPE_SELECT = 1,
+	DUCKDB_STATEMENT_TYPE_INSERT = 2,
+	DUCKDB_STATEMENT_TYPE_UPDATE = 3,
+	DUCKDB_STATEMENT_TYPE_EXPLAIN = 4,
+	DUCKDB_STATEMENT_TYPE_DELETE = 5,
+	DUCKDB_STATEMENT_TYPE_PREPARE = 6,
+	DUCKDB_STATEMENT_TYPE_CREATE = 7,
+	DUCKDB_STATEMENT_TYPE_EXECUTE = 8,
+	DUCKDB_STATEMENT_TYPE_ALTER = 9,
+	DUCKDB_STATEMENT_TYPE_TRANSACTION = 10,
+	DUCKDB_STATEMENT_TYPE_COPY = 11,
+	DUCKDB_STATEMENT_TYPE_ANALYZE = 12,
+	DUCKDB_STATEMENT_TYPE_VARIABLE_SET = 13,
+	DUCKDB_STATEMENT_TYPE_CREATE_FUNC = 14,
+	DUCKDB_STATEMENT_TYPE_DROP = 15,
+	DUCKDB_STATEMENT_TYPE_EXPORT = 16,
+	DUCKDB_STATEMENT_TYPE_PRAGMA = 17,
+	DUCKDB_STATEMENT_TYPE_VACUUM = 18,
+	DUCKDB_STATEMENT_TYPE_CALL = 19,
+	DUCKDB_STATEMENT_TYPE_SET = 20,
+	DUCKDB_STATEMENT_TYPE_LOAD = 21,
+	DUCKDB_STATEMENT_TYPE_RELATION = 22,
+	DUCKDB_STATEMENT_TYPE_EXTENSION = 23,
+	DUCKDB_STATEMENT_TYPE_LOGICAL_PLAN = 24,
+	DUCKDB_STATEMENT_TYPE_ATTACH = 25,
+	DUCKDB_STATEMENT_TYPE_DETACH = 26,
+	DUCKDB_STATEMENT_TYPE_MULTI = 27,
 } duckdb_statement_type;
 
 //===--------------------------------------------------------------------===//
@@ -227,7 +230,7 @@ typedef struct {
 	uint64_t bits;
 } duckdb_time_tz;
 typedef struct {
-	duckdb_time time;
+	duckdb_time_struct time;
 	int32_t offset;
 } duckdb_time_tz_struct;
 
@@ -1625,6 +1628,16 @@ Creates a list value from a type and an array of values of length `value_count`
 */
 DUCKDB_API duckdb_value duckdb_create_list_value(duckdb_logical_type type, duckdb_value *values, idx_t value_count);
 
+/*!
+Creates a array value from a type and an array of values of length `value_count`
+
+* type: The type of the array
+* values: The values for the array
+* value_count: The number of values in the array
+* returns: The value. This must be destroyed with `duckdb_destroy_value`.
+*/
+DUCKDB_API duckdb_value duckdb_create_array_value(duckdb_logical_type type, duckdb_value *values, idx_t value_count);
+
 /*!
 Obtains a string representation of the given value.
 The result must be destroyed with `duckdb_free`.
@@ -1675,6 +1688,16 @@ The resulting type should be destroyed with `duckdb_destroy_logical_type`.
 */
 DUCKDB_API duckdb_logical_type duckdb_create_list_type(duckdb_logical_type type);
 
+/*!
+Creates a array type from its child type.
+The resulting type should be destroyed with `duckdb_destroy_logical_type`.
+
+* type: The child type of array type to create.
+* array_size: The number of elements in the array.
+* returns: The logical type.
+*/
+DUCKDB_API duckdb_logical_type duckdb_create_array_type(duckdb_logical_type type, idx_t array_size);
+
 /*!
 Creates a map type from its key type and value type.
 The resulting type should be destroyed with `duckdb_destroy_logical_type`.
@@ -1797,6 +1820,24 @@ The result must be freed with `duckdb_destroy_logical_type`.
 */
 DUCKDB_API duckdb_logical_type duckdb_list_type_child_type(duckdb_logical_type type);
 
+/*!
+Retrieves the child type of the given array type.
+
+The result must be freed with `duckdb_destroy_logical_type`.
+
+* type: The logical type object
+* returns: The child type of the array type. Must be destroyed with `duckdb_destroy_logical_type`.
+*/
+DUCKDB_API duckdb_logical_type duckdb_array_type_child_type(duckdb_logical_type type);
+
+/*!
+Retrieves the array size of the given array type.
+
+* type: The logical type object
+* returns: The fixed number of elements the values of this array type can store.
+*/
+DUCKDB_API idx_t duckdb_array_type_array_size(duckdb_logical_type type);
+
 /*!
 Retrieves the key type of the given map type.
 
@@ -2015,7 +2056,7 @@ Assigns a string element in the vector at the specified location.
 DUCKDB_API void duckdb_vector_assign_string_element(duckdb_vector vector, idx_t index, const char *str);
 
 /*!
-Assigns a string element in the vector at the specified location.
+Assigns a string element in the vector at the specified location. You may also use this function to assign BLOBs.
 
 * vector: The vector to alter
 * index: The row position in the vector to assign the string to
@@ -2072,6 +2113,17 @@ The resulting vector is valid as long as the parent vector is valid.
 */
 DUCKDB_API duckdb_vector duckdb_struct_vector_get_child(duckdb_vector vector, idx_t index);
 
+/*!
+Retrieves the child vector of a array vector.
+
+The resulting vector is valid as long as the parent vector is valid.
+The resulting vector has the size of the parent vector multiplied by the array size.
+
+* vector: The vector
+* returns: The child vector
+*/
+DUCKDB_API duckdb_vector duckdb_array_vector_get_child(duckdb_vector vector);
+
 //===--------------------------------------------------------------------===//
 // Validity Mask Functions
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/main/appender.cpp

@@ -102,7 +102,8 @@ void BaseAppender::AppendDecimalValueInternal(Vector &col, SRC input) {
 		D_ASSERT(type.id() == LogicalTypeId::DECIMAL);
 		auto width = DecimalType::GetWidth(type);
 		auto scale = DecimalType::GetScale(type);
-		TryCastToDecimal::Operation<SRC, DST>(input, FlatVector::GetData<DST>(col)[chunk.size()], nullptr, width,
+		CastParameters parameters;
+		TryCastToDecimal::Operation<SRC, DST>(input, FlatVector::GetData<DST>(col)[chunk.size()], parameters, width,
 		                                      scale);
 		return;
 	}