duckdb 0.9.3-dev0.0 → 0.9.3-dev12.0

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

@@ -9,7 +9,7 @@
 
 #pragma once
 
-// duplicate of duckdb/main/winapi.hpp
+//! duplicate of duckdb/main/winapi.hpp
 #ifndef DUCKDB_API
 #ifdef _WIN32
 #if defined(DUCKDB_BUILD_LIBRARY) && !defined(DUCKDB_BUILD_LOADABLE_EXTENSION)
@@ -22,7 +22,7 @@
 #endif
 #endif
 
-// duplicate of duckdb/main/winapi.hpp
+//! duplicate of duckdb/main/winapi.hpp
 #ifndef DUCKDB_EXTENSION_API
 #ifdef _WIN32
 #ifdef DUCKDB_BUILD_LOADABLE_EXTENSION
@@ -35,10 +35,10 @@
 #endif
 #endif
 
-// API versions
-// if no explicit API version is defined, the latest API version is used
-// Note that using older API versions (i.e. not using DUCKDB_API_LATEST) is deprecated.
-// These will not be supported long-term, and will be removed in future versions.
+//! API versions
+//! If no explicit API version is defined, the latest API version is used.
+//! Note that using older API versions (i.e. not using DUCKDB_API_LATEST) is deprecated.
+//! These will not be supported long-term, and will be removed in future versions.
 #ifndef DUCKDB_API_0_3_1
 #define DUCKDB_API_0_3_1 1
 #endif
@@ -55,17 +55,17 @@
 
 #include <stdbool.h>
 #include <stdint.h>
-#include <stdlib.h>
+#include <stddef.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 //===--------------------------------------------------------------------===//
-// Type Information
+// Enums
 //===--------------------------------------------------------------------===//
-typedef uint64_t idx_t;
 
+//! An enum over DuckDB's internal types.
 typedef enum DUCKDB_TYPE {
 	DUCKDB_TYPE_INVALID = 0,
 	// bool
@@ -100,6 +100,8 @@ typedef enum DUCKDB_TYPE {
 	DUCKDB_TYPE_INTERVAL,
 	// duckdb_hugeint
 	DUCKDB_TYPE_HUGEINT,
+	// duckdb_uhugeint
+	DUCKDB_TYPE_UHUGEINT,
 	// const char*
 	DUCKDB_TYPE_VARCHAR,
 	// duckdb_blob
@@ -126,14 +128,82 @@ typedef enum DUCKDB_TYPE {
 	DUCKDB_TYPE_UNION,
 	// duckdb_bit
 	DUCKDB_TYPE_BIT,
+	// duckdb_time_tz
+	DUCKDB_TYPE_TIME_TZ,
+	// duckdb_timestamp
+	DUCKDB_TYPE_TIMESTAMP_TZ,
 } duckdb_type;
+//! An enum over the returned state of different functions.
+typedef enum { DuckDBSuccess = 0, DuckDBError = 1 } duckdb_state;
+//! An enum over the pending state of a pending query result.
+typedef enum {
+	DUCKDB_PENDING_RESULT_READY = 0,
+	DUCKDB_PENDING_RESULT_NOT_READY = 1,
+	DUCKDB_PENDING_ERROR = 2,
+	DUCKDB_PENDING_NO_TASKS_AVAILABLE = 3
+} 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;
+//! 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;
+
+//===--------------------------------------------------------------------===//
+// General type definitions
+//===--------------------------------------------------------------------===//
+
+//! DuckDB's index type.
+typedef uint64_t idx_t;
+
+//! The callback that will be called to destroy data, e.g.,
+//! bind data (if any), init data (if any), extra data for replacement scans (if any)
+typedef void (*duckdb_delete_callback_t)(void *data);
+
+//! Used for threading, contains a task state. Must be destroyed with `duckdb_destroy_state`.
+typedef void *duckdb_task_state;
+
+//===--------------------------------------------------------------------===//
+// Types (no explicit freeing)
+//===--------------------------------------------------------------------===//
 
 //! Days are stored as days since 1970-01-01
 //! Use the duckdb_from_date/duckdb_to_date function to extract individual information
 typedef struct {
 	int32_t days;
 } duckdb_date;
-
 typedef struct {
 	int32_t year;
 	int8_t month;
@@ -145,7 +215,6 @@ typedef struct {
 typedef struct {
 	int64_t micros;
 } duckdb_time;
-
 typedef struct {
 	int8_t hour;
 	int8_t min;
@@ -153,46 +222,60 @@ typedef struct {
 	int32_t micros;
 } duckdb_time_struct;
 
+//! TIME_TZ is stored as 40 bits for int64_t micros, and 24 bits for int32_t offset
+typedef struct {
+	uint64_t bits;
+} duckdb_time_tz;
+typedef struct {
+	duckdb_time time;
+	int32_t offset;
+} duckdb_time_tz_struct;
+
 //! Timestamps are stored as microseconds since 1970-01-01
 //! Use the duckdb_from_timestamp/duckdb_to_timestamp function to extract individual information
 typedef struct {
 	int64_t micros;
 } duckdb_timestamp;
-
 typedef struct {
 	duckdb_date_struct date;
 	duckdb_time_struct time;
 } duckdb_timestamp_struct;
-
 typedef struct {
 	int32_t months;
 	int32_t days;
 	int64_t micros;
 } duckdb_interval;
 
-//! Hugeints are composed in a (lower, upper) component
+//! Hugeints are composed of a (lower, upper) component
 //! The value of the hugeint is upper * 2^64 + lower
 //! For easy usage, the functions duckdb_hugeint_to_double/duckdb_double_to_hugeint are recommended
 typedef struct {
 	uint64_t lower;
 	int64_t upper;
 } duckdb_hugeint;
+typedef struct {
+	uint64_t lower;
+	uint64_t upper;
+} duckdb_uhugeint;
 
+//! Decimals are composed of a width and a scale, and are stored in a hugeint
 typedef struct {
 	uint8_t width;
 	uint8_t scale;
-
 	duckdb_hugeint value;
 } duckdb_decimal;
 
+//! A type holding information about the query execution progress
 typedef struct {
-	char *data;
-	idx_t size;
-} duckdb_string;
-
-/*
-    The internal data representation of a VARCHAR/BLOB column
-*/
+	double percentage;
+	uint64_t rows_processed;
+	uint64_t total_rows_to_process;
+} duckdb_query_progress_type;
+
+//! The internal representation of a VARCHAR (string_t). If the VARCHAR does not
+//! exceed 12 characters, then we inline it. Otherwise, we inline a prefix for faster
+//! string comparisons and store a pointer to the remaining characters. This is a non-
+//! owning structure, i.e., it does not have to be freed.
 typedef struct {
 	union {
 		struct {
@@ -207,16 +290,18 @@ typedef struct {
 	} value;
 } duckdb_string_t;
 
-typedef struct {
-	void *data;
-	idx_t size;
-} duckdb_blob;
-
+//! The internal representation of a list metadata entry contains the list's offset in
+//! the child vector, and its length. The parent vector holds these metadata entries,
+//! whereas the child vector holds the data
 typedef struct {
 	uint64_t offset;
 	uint64_t length;
 } duckdb_list_entry;
 
+//! A column consists of a pointer to its internal data. Don't operate on this type directly.
+//! Instead, use functions such as duckdb_column_data, duckdb_nullmask_data,
+//! duckdb_column_type, and duckdb_column_name, which take the result and the column index
+//! as their parameters
 typedef struct {
 #if DUCKDB_API_VERSION < DUCKDB_API_0_3_2
 	void *data;
@@ -236,6 +321,32 @@ typedef struct {
 	void *internal_data;
 } duckdb_column;
 
+//! A vector to a specified column in a data chunk. Lives as long as the
+//! data chunk lives, i.e., must not be destroyed.
+typedef struct _duckdb_vector {
+	void *__vctr;
+} * duckdb_vector;
+
+//===--------------------------------------------------------------------===//
+// Types (explicit freeing/destroying)
+//===--------------------------------------------------------------------===//
+
+//! Strings are composed of a char pointer and a size. You must free string.data
+//! with `duckdb_free`.
+typedef struct {
+	char *data;
+	idx_t size;
+} duckdb_string;
+
+//! BLOBs are composed of a byte pointer and a size. You must free blob.data
+//! with `duckdb_free`.
+typedef struct {
+	void *data;
+	idx_t size;
+} duckdb_blob;
+
+//! A query result consists of a pointer to its internal data.
+//! Must be freed with 'duckdb_destroy_result'.
 typedef struct {
 #if DUCKDB_API_VERSION < DUCKDB_API_0_3_2
 	idx_t column_count;
@@ -250,7 +361,7 @@ typedef struct {
 	idx_t __deprecated_row_count;
 	// deprecated, use duckdb_rows_changed
 	idx_t __deprecated_rows_changed;
-	// deprecated, use duckdb_column_ family of functions
+	// deprecated, use duckdb_column_*-family of functions
 	duckdb_column *__deprecated_columns;
 	// deprecated, use duckdb_result_error
 	char *__deprecated_error_message;
@@ -258,59 +369,125 @@ typedef struct {
 	void *internal_data;
 } duckdb_result;
 
+//! A database object. Should be closed with `duckdb_close`.
 typedef struct _duckdb_database {
 	void *__db;
 } * duckdb_database;
+
+//! A connection to a duckdb database. Must be closed with `duckdb_disconnect`.
 typedef struct _duckdb_connection {
 	void *__conn;
 } * duckdb_connection;
+
+//! A prepared statement is a parameterized query that allows you to bind parameters to it.
+//! Must be destroyed with `duckdb_destroy_prepare`.
 typedef struct _duckdb_prepared_statement {
 	void *__prep;
 } * duckdb_prepared_statement;
+
+//! Extracted statements. Must be destroyed with `duckdb_destroy_extracted`.
 typedef struct _duckdb_extracted_statements {
 	void *__extrac;
 } * duckdb_extracted_statements;
+
+//! The pending result represents an intermediate structure for a query that is not yet fully executed.
+//! Must be destroyed with `duckdb_destroy_pending`.
 typedef struct _duckdb_pending_result {
 	void *__pend;
 } * duckdb_pending_result;
+
+//! The appender enables fast data loading into DuckDB.
+//! Must be destroyed with `duckdb_appender_destroy`.
 typedef struct _duckdb_appender {
 	void *__appn;
 } * duckdb_appender;
-typedef struct _duckdb_arrow {
-	void *__arrw;
-} * duckdb_arrow;
-typedef struct _duckdb_arrow_stream {
-	void *__arrwstr;
-} * duckdb_arrow_stream;
+
+//! Can be used to provide start-up options for the DuckDB instance.
+//! Must be destroyed with `duckdb_destroy_config`.
 typedef struct _duckdb_config {
 	void *__cnfg;
 } * duckdb_config;
-typedef struct _duckdb_arrow_schema {
-	void *__arrs;
-} * duckdb_arrow_schema;
-typedef struct _duckdb_arrow_array {
-	void *__arra;
-} * duckdb_arrow_array;
+
+//! Holds an internal logical type.
+//! Must be destroyed with `duckdb_destroy_logical_type`.
 typedef struct _duckdb_logical_type {
 	void *__lglt;
 } * duckdb_logical_type;
+
+//! Contains a data chunk from a duckdb_result.
+//! Must be destroyed with `duckdb_destroy_data_chunk`.
 typedef struct _duckdb_data_chunk {
 	void *__dtck;
 } * duckdb_data_chunk;
-typedef struct _duckdb_vector {
-	void *__vctr;
-} * duckdb_vector;
+
+//! Holds a DuckDB value, which wraps a type.
+//! Must be destroyed with `duckdb_destroy_value`.
 typedef struct _duckdb_value {
 	void *__val;
 } * duckdb_value;
 
-typedef enum { DuckDBSuccess = 0, DuckDBError = 1 } duckdb_state;
-typedef enum {
-	DUCKDB_PENDING_RESULT_READY = 0,
-	DUCKDB_PENDING_RESULT_NOT_READY = 1,
-	DUCKDB_PENDING_ERROR = 2,
-	DUCKDB_PENDING_NO_TASKS_AVAILABLE = 3
-} duckdb_pending_state;
+//===--------------------------------------------------------------------===//
+// Table function types
+//===--------------------------------------------------------------------===//
+
+//! A table function. Must be destroyed with `duckdb_destroy_table_function`.
+typedef void *duckdb_table_function;
+
+//! The bind info of the function. When setting this info, it is necessary to pass a destroy-callback function.
+typedef void *duckdb_bind_info;
+
+//! Additional function init info. When setting this info, it is necessary to pass a destroy-callback function.
+typedef void *duckdb_init_info;
+
+//! Additional function info. When setting this info, it is necessary to pass a destroy-callback function.
+typedef void *duckdb_function_info;
+
+//! The bind function of the table function.
+typedef void (*duckdb_table_function_bind_t)(duckdb_bind_info info);
+
+//! The (possibly thread-local) init function of the table function.
+typedef void (*duckdb_table_function_init_t)(duckdb_init_info info);
+
+//! The main function of the table function.
+typedef void (*duckdb_table_function_t)(duckdb_function_info info, duckdb_data_chunk output);
+
+//===--------------------------------------------------------------------===//
+// Replacement scan types
+//===--------------------------------------------------------------------===//
+
+//! Additional replacement scan info. When setting this info, it is necessary to pass a destroy-callback function.
+typedef void *duckdb_replacement_scan_info;
+
+//! A replacement scan function that can be added to a database.
+typedef void (*duckdb_replacement_callback_t)(duckdb_replacement_scan_info info, const char *table_name, void *data);
+
+//===--------------------------------------------------------------------===//
+// Arrow-related types
+//===--------------------------------------------------------------------===//
+
+//! Holds an arrow query result. Must be destroyed with `duckdb_destroy_arrow`.
+typedef struct _duckdb_arrow {
+	void *__arrw;
+} * duckdb_arrow;
+
+//! Holds an arrow array stream. Must be destroyed with `duckdb_destroy_arrow_stream`.
+typedef struct _duckdb_arrow_stream {
+	void *__arrwstr;
+} * duckdb_arrow_stream;
+
+//! Holds an arrow schema. Remember to release the respective ArrowSchema object.
+typedef struct _duckdb_arrow_schema {
+	void *__arrs;
+} * duckdb_arrow_schema;
+
+//! Holds an arrow array. Remember to release the respective ArrowArray object.
+typedef struct _duckdb_arrow_array {
+	void *__arra;
+} * duckdb_arrow_array;
+
+//===--------------------------------------------------------------------===//
+// Functions
+//===--------------------------------------------------------------------===//
 
 //===--------------------------------------------------------------------===//
 // Open/Connect
@@ -319,7 +496,7 @@ typedef enum {
 /*!
 Creates a new database or opens an existing database file stored at the given path.
 If no path is given a new in-memory database is created instead.
-The instantiated database should be closed with 'duckdb_close'
+The instantiated database should be closed with 'duckdb_close'.
 
 * path: Path to the database file on disk, or `nullptr` or `:memory:` to open an in-memory database.
 * out_database: The result database object.
@@ -329,6 +506,7 @@ DUCKDB_API duckdb_state duckdb_open(const char *path, duckdb_database *out_datab
 
 /*!
 Extended version of duckdb_open. Creates a new database or opens an existing database file stored at the given path.
+The instantiated database should be closed with 'duckdb_close'.
 
 * path: Path to the database file on disk, or `nullptr` or `:memory:` to open an in-memory database.
 * out_database: The result database object.
@@ -342,9 +520,9 @@ DUCKDB_API duckdb_state duckdb_open_ext(const char *path, duckdb_database *out_d
 
 /*!
 Closes the specified database and de-allocates all memory allocated for that database.
-This should be called after you are done with any database allocated through `duckdb_open`.
+This should be called after you are done with any database allocated through `duckdb_open` or `duckdb_open_ext`.
 Note that failing to call `duckdb_close` (in case of e.g. a program crash) will not cause data corruption.
-Still it is recommended to always correctly close a database object after you are done with it.
+Still, it is recommended to always correctly close a database object after you are done with it.
 
 * database: The database object to shut down.
 */
@@ -353,7 +531,7 @@ DUCKDB_API void duckdb_close(duckdb_database *database);
 /*!
 Opens a connection to a database. Connections are required to query the database, and store transactional state
 associated with the connection.
-The instantiated connection should be closed using 'duckdb_disconnect'
+The instantiated connection should be closed using 'duckdb_disconnect'.
 
 * database: The database file to connect to.
 * out_connection: The result connection object.
@@ -364,7 +542,7 @@ DUCKDB_API duckdb_state duckdb_connect(duckdb_database database, duckdb_connecti
 /*!
 Interrupt running query
 
-* connection: The connection to interruot
+* connection: The connection to interrupt
 */
 DUCKDB_API void duckdb_interrupt(duckdb_connection connection);
 
@@ -374,7 +552,7 @@ Get progress of the running query
 * connection: The working connection
 * returns: -1 if no progress or a percentage of the progress
 */
-DUCKDB_API double duckdb_query_progress(duckdb_connection connection);
+DUCKDB_API duckdb_query_progress_type duckdb_query_progress(duckdb_connection connection);
 
 /*!
 Closes the specified connection and de-allocates all memory allocated for that connection.
@@ -393,9 +571,11 @@ DUCKDB_API const char *duckdb_library_version();
 //===--------------------------------------------------------------------===//
 // Configuration
 //===--------------------------------------------------------------------===//
+
 /*!
 Initializes an empty configuration object that can be used to provide start-up options for the DuckDB instance
 through `duckdb_open_ext`.
+The duckdb_config must be destroyed using 'duckdb_destroy_config'
 
 This will always succeed unless there is a malloc failure.
 
@@ -442,7 +622,7 @@ This can fail if either the name is invalid, or if the value provided for the op
 DUCKDB_API duckdb_state duckdb_set_config(duckdb_config config, const char *name, const char *option);
 
 /*!
-Destroys the specified configuration option and de-allocates all memory allocated for the object.
+Destroys the specified configuration object and de-allocates all memory allocated for the object.
 
 * config: The configuration object to destroy.
 */
@@ -451,6 +631,7 @@ DUCKDB_API void duckdb_destroy_config(duckdb_config *config);
 //===--------------------------------------------------------------------===//
 // Query Execution
 //===--------------------------------------------------------------------===//
+
 /*!
 Executes a SQL query within a connection and stores the full (materialized) result in the out_result pointer.
 If the query fails to execute, DuckDBError is returned and the error message can be retrieved by calling
@@ -474,7 +655,7 @@ Closes the result and de-allocates all memory allocated for that connection.
 DUCKDB_API void duckdb_destroy_result(duckdb_result *result);
 
 /*!
-Returns the column name of the specified column. The result should not need be freed; the column names will
+Returns the column name of the specified column. The result should not need to be freed; the column names will
 automatically be destroyed when the result is destroyed.
 
 Returns `NULL` if the column is out of range.
@@ -496,6 +677,14 @@ Returns `DUCKDB_TYPE_INVALID` if the column is out of range.
 */
 DUCKDB_API duckdb_type duckdb_column_type(duckdb_result *result, idx_t col);
 
+/*!
+Returns the statement type of the statement that was executed
+
+* result: The result object to fetch the statement type from.
+ * returns: duckdb_statement_type value or DUCKDB_STATEMENT_TYPE_INVALID
+ */
+DUCKDB_API duckdb_statement_type duckdb_result_statement_type(duckdb_result result);
+
 /*!
 Returns the logical column type of the specified column.
 
@@ -518,7 +707,7 @@ Returns the number of columns present in a the result object.
 DUCKDB_API idx_t duckdb_column_count(duckdb_result *result);
 
 /*!
-Returns the number of rows present in a the result object.
+Returns the number of rows present in the result object.
 
 * result: The result object.
 * returns: The number of rows present in the result object.
@@ -627,7 +816,18 @@ Returns the number of data chunks present in the result.
 */
 DUCKDB_API idx_t duckdb_result_chunk_count(duckdb_result result);
 
+/*!
+Returns the return_type of the given result, or DUCKDB_RETURN_TYPE_INVALID on error
+
+* result: The result object
+* returns: The return_type
+ */
+DUCKDB_API duckdb_result_type duckdb_result_return_type(duckdb_result result);
+
+//===--------------------------------------------------------------------===//
 // Safe fetch functions
+//===--------------------------------------------------------------------===//
+
 // These functions will perform conversions if necessary.
 // On failure (e.g. if conversion cannot be performed or if the value is NULL) a default value is returned.
 // Note that these functions are slow since they perform bounds checking and conversion
@@ -663,6 +863,11 @@ DUCKDB_API int64_t duckdb_value_int64(duckdb_result *result, idx_t col, idx_t ro
  */
 DUCKDB_API duckdb_hugeint duckdb_value_hugeint(duckdb_result *result, idx_t col, idx_t row);
 
+/*!
+ * returns: The duckdb_uhugeint value at the specified location, or 0 if the value cannot be converted.
+ */
+DUCKDB_API duckdb_uhugeint duckdb_value_uhugeint(duckdb_result *result, idx_t col, idx_t row);
+
 /*!
  * returns: The duckdb_decimal value at the specified location, or 0 if the value cannot be converted.
  */
@@ -725,10 +930,10 @@ converted. The result must be freed with `duckdb_free`.
 */
 DUCKDB_API char *duckdb_value_varchar(duckdb_result *result, idx_t col, idx_t row);
 
-/*!s
-* returns: The string value at the specified location.
-The result must be freed with `duckdb_free`.
-*/
+/*!
+ * returns: The string value at the specified location.
+ * The resulting field "string.data" must be freed with `duckdb_free.`
+ */
 DUCKDB_API duckdb_string duckdb_value_string(duckdb_result *result, idx_t col, idx_t row);
 
 /*!
@@ -753,7 +958,7 @@ DUCKDB_API duckdb_string duckdb_value_string_internal(duckdb_result *result, idx
 
 /*!
 * returns: The duckdb_blob value at the specified location. Returns a blob with blob.data set to nullptr if the
-value cannot be converted. The resulting "blob.data" must be freed with `duckdb_free.`
+value cannot be converted. The resulting field "blob.data" must be freed with `duckdb_free.`
 */
 DUCKDB_API duckdb_blob duckdb_value_blob(duckdb_result *result, idx_t col, idx_t row);
 
@@ -765,6 +970,7 @@ DUCKDB_API bool duckdb_value_is_null(duckdb_result *result, idx_t col, idx_t row
 //===--------------------------------------------------------------------===//
 // Helpers
 //===--------------------------------------------------------------------===//
+
 /*!
 Allocate `size` bytes of memory using the duckdb internal malloc function. Any memory allocated in this manner
 should be freed using `duckdb_free`.
@@ -775,7 +981,8 @@ should be freed using `duckdb_free`.
 DUCKDB_API void *duckdb_malloc(size_t size);
 
 /*!
-Free a value returned from `duckdb_malloc`, `duckdb_value_varchar` or `duckdb_value_blob`.
+Free a value returned from `duckdb_malloc`, `duckdb_value_varchar`, `duckdb_value_blob`, or
+`duckdb_value_string`.
 
 * ptr: The memory region to de-allocate.
 */
@@ -799,6 +1006,7 @@ DUCKDB_API bool duckdb_string_is_inlined(duckdb_string_t string);
 //===--------------------------------------------------------------------===//
 // Date/Time/Timestamp Helpers
 //===--------------------------------------------------------------------===//
+
 /*!
 Decompose a `duckdb_date` object into year, month and date (stored as `duckdb_date_struct`).
 
@@ -815,6 +1023,14 @@ Re-compose a `duckdb_date` from year, month and date (`duckdb_date_struct`).
 */
 DUCKDB_API duckdb_date duckdb_to_date(duckdb_date_struct date);
 
+/*!
+Test a `duckdb_date` to see if it is a finite value.
+
+* date: The date object, as obtained from a `DUCKDB_TYPE_DATE` column.
+* returns: True if the date is finite, false if it is ±infinity.
+*/
+DUCKDB_API bool duckdb_is_finite_date(duckdb_date date);
+
 /*!
 Decompose a `duckdb_time` object into hour, minute, second and microsecond (stored as `duckdb_time_struct`).
 
@@ -823,6 +1039,26 @@ Decompose a `duckdb_time` object into hour, minute, second and microsecond (stor
 */
 DUCKDB_API duckdb_time_struct duckdb_from_time(duckdb_time time);
 
+/*!
+Create a `duckdb_time_tz` object from micros and a timezone offset.
+
+* micros: The microsecond component of the time.
+* offset: The timezone offset component of the time.
+* returns: The `duckdb_time_tz` element.
+*/
+DUCKDB_API duckdb_time_tz duckdb_create_time_tz(int64_t micros, int32_t offset);
+
+/*!
+Decompose a TIME_TZ objects into micros and a timezone offset.
+
+Use `duckdb_from_time` to further decompose the micros into hour, minute, second and microsecond.
+
+* micros: The time object, as obtained from a `DUCKDB_TYPE_TIME_TZ` column.
+* out_micros: The microsecond component of the time.
+* out_offset: The timezone offset component of the time.
+*/
+DUCKDB_API duckdb_time_tz_struct duckdb_from_time_tz(duckdb_time_tz micros);
+
 /*!
 Re-compose a `duckdb_time` from hour, minute, second and microsecond (`duckdb_time_struct`).
 
@@ -847,9 +1083,18 @@ Re-compose a `duckdb_timestamp` from a duckdb_timestamp_struct.
 */
 DUCKDB_API duckdb_timestamp duckdb_to_timestamp(duckdb_timestamp_struct ts);
 
+/*!
+Test a `duckdb_timestamp` to see if it is a finite value.
+
+* ts: The timestamp object, as obtained from a `DUCKDB_TYPE_TIMESTAMP` column.
+* returns: True if the timestamp is finite, false if it is ±infinity.
+*/
+DUCKDB_API bool duckdb_is_finite_timestamp(duckdb_timestamp ts);
+
 //===--------------------------------------------------------------------===//
 // Hugeint Helpers
 //===--------------------------------------------------------------------===//
+
 /*!
 Converts a duckdb_hugeint object (as obtained from a `DUCKDB_TYPE_HUGEINT` column) into a double.
 
@@ -868,6 +1113,32 @@ If the conversion fails because the double value is too big the result will be 0
 */
 DUCKDB_API duckdb_hugeint duckdb_double_to_hugeint(double val);
 
+//===--------------------------------------------------------------------===//
+// Unsigned Hugeint Helpers
+//===--------------------------------------------------------------------===//
+
+/*!
+Converts a duckdb_uhugeint object (as obtained from a `DUCKDB_TYPE_UHUGEINT` column) into a double.
+
+* val: The uhugeint value.
+* returns: The converted `double` element.
+*/
+DUCKDB_API double duckdb_uhugeint_to_double(duckdb_uhugeint val);
+
+/*!
+Converts a double value to a duckdb_uhugeint object.
+
+If the conversion fails because the double value is too big the result will be 0.
+
+* val: The double value.
+* returns: The converted `duckdb_uhugeint` element.
+*/
+DUCKDB_API duckdb_uhugeint duckdb_double_to_uhugeint(double val);
+
+//===--------------------------------------------------------------------===//
+// Decimal Helpers
+//===--------------------------------------------------------------------===//
+
 /*!
 Converts a double value to a duckdb_decimal object.
 
@@ -878,9 +1149,6 @@ If the conversion fails because the double value is too big, or the width/scale
 */
 DUCKDB_API duckdb_decimal duckdb_double_to_decimal(double val, uint8_t width, uint8_t scale);
 
-//===--------------------------------------------------------------------===//
-// Decimal Helpers
-//===--------------------------------------------------------------------===//
 /*!
 Converts a duckdb_decimal object (as obtained from a `DUCKDB_TYPE_DECIMAL` column) into a double.
 
@@ -892,6 +1160,7 @@ DUCKDB_API double duckdb_decimal_to_double(duckdb_decimal val);
 //===--------------------------------------------------------------------===//
 // Prepared Statements
 //===--------------------------------------------------------------------===//
+
 // A prepared statement is a parameterized query that allows you to bind parameters to it.
 // * This is useful to easily supply parameters to functions and avoid SQL injection attacks.
 // * This is useful to speed up queries that you will execute several times with different parameters.
@@ -971,6 +1240,18 @@ Clear the params bind to the prepared statement.
 */
 DUCKDB_API duckdb_state duckdb_clear_bindings(duckdb_prepared_statement prepared_statement);
 
+/*!
+Returns the statement type of the statement to be executed
+
+ * statement: The prepared statement.
+ * returns: duckdb_statement_type value or DUCKDB_STATEMENT_TYPE_INVALID
+ */
+DUCKDB_API duckdb_statement_type duckdb_prepared_statement_type(duckdb_prepared_statement statement);
+
+//===--------------------------------------------------------------------===//
+// Bind Values to Prepared Statements
+//===--------------------------------------------------------------------===//
+
 /*!
 Binds a value to the prepared statement at the specified index.
 */
@@ -1014,6 +1295,11 @@ Binds a duckdb_hugeint value to the prepared statement at the specified index.
 DUCKDB_API duckdb_state duckdb_bind_hugeint(duckdb_prepared_statement prepared_statement, idx_t param_idx,
                                             duckdb_hugeint val);
 /*!
+Binds an duckdb_uhugeint value to the prepared statement at the specified index.
+*/
+DUCKDB_API duckdb_state duckdb_bind_uhugeint(duckdb_prepared_statement prepared_statement, idx_t param_idx,
+                                             duckdb_uhugeint val);
+/*!
 Binds a duckdb_decimal value to the prepared statement at the specified index.
 */
 DUCKDB_API duckdb_state duckdb_bind_decimal(duckdb_prepared_statement prepared_statement, idx_t param_idx,
@@ -1096,12 +1382,18 @@ Binds a NULL value to the prepared statement at the specified index.
 */
 DUCKDB_API duckdb_state duckdb_bind_null(duckdb_prepared_statement prepared_statement, idx_t param_idx);
 
+//===--------------------------------------------------------------------===//
+// Execute Prepared Statements
+//===--------------------------------------------------------------------===//
+
 /*!
 Executes the prepared statement with the given bound parameters, and returns a materialized query result.
 
 This method can be called multiple times for each prepared statement, and the parameters can be modified
 between calls to this function.
 
+Note that the result must be freed with `duckdb_destroy_result`.
+
 * prepared_statement: The prepared statement to execute.
 * out_result: The query result.
 * returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
@@ -1110,50 +1402,34 @@ DUCKDB_API duckdb_state duckdb_execute_prepared(duckdb_prepared_statement prepar
                                                 duckdb_result *out_result);
 
 /*!
-Executes the prepared statement with the given bound parameters, and returns an arrow query result.
-
-* prepared_statement: The prepared statement to execute.
-* out_result: The query result.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_execute_prepared_arrow(duckdb_prepared_statement prepared_statement,
-                                                      duckdb_arrow *out_result);
-
-/*!
-Scans the Arrow stream and creates a view with the given name.
+Executes the prepared statement with the given bound parameters, and returns an optionally-streaming query result.
+To determine if the resulting query was in fact streamed, use `duckdb_result_is_streaming`
 
-* connection: The connection on which to execute the scan.
-* table_name: Name of the temporary view to create.
-* arrow: Arrow stream wrapper.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_arrow_scan(duckdb_connection connection, const char *table_name,
-                                          duckdb_arrow_stream arrow);
+This method can be called multiple times for each prepared statement, and the parameters can be modified
+between calls to this function.
 
-/*!
-Scans the Arrow array and creates a view with the given name.
+Note that the result must be freed with `duckdb_destroy_result`.
 
-* connection: The connection on which to execute the scan.
-* table_name: Name of the temporary view to create.
-* arrow_schema: Arrow schema wrapper.
-* arrow_array: Arrow array wrapper.
-* out_stream: Output array stream that wraps around the passed schema, for releasing/deleting once done.
+* prepared_statement: The prepared statement to execute.
+* out_result: The query result.
 * returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
-DUCKDB_API duckdb_state duckdb_arrow_array_scan(duckdb_connection connection, const char *table_name,
-                                                duckdb_arrow_schema arrow_schema, duckdb_arrow_array arrow_array,
-                                                duckdb_arrow_stream *out_stream);
+DUCKDB_API duckdb_state duckdb_execute_prepared_streaming(duckdb_prepared_statement prepared_statement,
+                                                          duckdb_result *out_result);
 
 //===--------------------------------------------------------------------===//
 // Extract Statements
 //===--------------------------------------------------------------------===//
+
 // A query string can be extracted into multiple SQL statements. Each statement can be prepared and executed separately.
 
 /*!
 Extract all statements from a query.
 Note that after calling `duckdb_extract_statements`, the extracted statements should always be destroyed using
 `duckdb_destroy_extracted`, even if no statements were extracted.
+
 If the extract fails, `duckdb_extract_statements_error` can be called to obtain the reason why the extract failed.
+
 * connection: The connection object
 * query: The SQL query to extract
 * out_extracted_statements: The resulting extracted statements object
@@ -1166,7 +1442,9 @@ DUCKDB_API idx_t duckdb_extract_statements(duckdb_connection connection, const c
 Prepare an extracted statement.
 Note that after calling `duckdb_prepare_extracted_statement`, the prepared statement should always be destroyed using
 `duckdb_destroy_prepare`, even if the prepare fails.
+
 If the prepare fails, `duckdb_prepare_error` can be called to obtain the reason why the prepare failed.
+
 * connection: The connection object
 * extracted_statements: The extracted statements object
 * index: The index of the extracted statement to prepare
@@ -1180,6 +1458,7 @@ DUCKDB_API duckdb_state duckdb_prepare_extracted_statement(duckdb_connection con
 /*!
 Returns the error message contained within the extracted statements.
 The result of this function must not be freed. It will be cleaned up when `duckdb_destroy_extracted` is called.
+
 * result: The extracted statements to fetch the error from.
 * returns: The error of the extracted statements.
 */
@@ -1194,6 +1473,7 @@ DUCKDB_API void duckdb_destroy_extracted(duckdb_extracted_statements *extracted_
 //===--------------------------------------------------------------------===//
 // Pending Result Interface
 //===--------------------------------------------------------------------===//
+
 /*!
 Executes the prepared statement with the given bound parameters, and returns a pending result.
 The pending result represents an intermediate structure for a query that is not yet fully executed.
@@ -1250,17 +1530,31 @@ If this returns DUCKDB_PENDING_ERROR, an error occurred during execution.
 
 The error message can be obtained by calling duckdb_pending_error on the pending_result.
 
-* pending_result: The pending result to execute a task within..
+* pending_result: The pending result to execute a task within.
 * returns: The state of the pending result after the execution.
 */
 DUCKDB_API duckdb_pending_state duckdb_pending_execute_task(duckdb_pending_result pending_result);
 
+/*!
+If this returns DUCKDB_PENDING_RESULT_READY, the duckdb_execute_pending function can be called to obtain the result.
+If this returns DUCKDB_PENDING_RESULT_NOT_READY, the duckdb_pending_execute_check_state function should be called again.
+If this returns DUCKDB_PENDING_ERROR, an error occurred during execution.
+
+The error message can be obtained by calling duckdb_pending_error on the pending_result.
+
+* pending_result: The pending result.
+* returns: The state of the pending result.
+*/
+DUCKDB_API duckdb_pending_state duckdb_pending_execute_check_state(duckdb_pending_result pending_result);
+
 /*!
 Fully execute a pending query result, returning the final query result.
 
 If duckdb_pending_execute_task has been called until DUCKDB_PENDING_RESULT_READY was returned, this will return fast.
 Otherwise, all remaining tasks must be executed first.
 
+Note that the result must be freed with `duckdb_destroy_result`.
+
 * pending_result: The pending result to execute.
 * out_result: The result object.
 * returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
@@ -1279,6 +1573,7 @@ DUCKDB_API bool duckdb_pending_execution_is_finished(duckdb_pending_state pendin
 //===--------------------------------------------------------------------===//
 // Value Interface
 //===--------------------------------------------------------------------===//
+
 /*!
 Destroys the value and de-allocates all memory allocated for that type.
 
@@ -1311,6 +1606,25 @@ Creates a value from an int64
 */
 DUCKDB_API duckdb_value duckdb_create_int64(int64_t val);
 
+/*!
+Creates a struct value from a type and an array of values
+
+* type: The type of the struct
+* values: The values for the struct fields
+* returns: The value. This must be destroyed with `duckdb_destroy_value`.
+*/
+DUCKDB_API duckdb_value duckdb_create_struct_value(duckdb_logical_type type, duckdb_value *values);
+
+/*!
+Creates a list value from a type and an array of values of length `value_count`
+
+* type: The type of the list
+* values: The values for the list
+* value_count: The number of values in the list
+* returns: The value. This must be destroyed with `duckdb_destroy_value`.
+*/
+DUCKDB_API duckdb_value duckdb_create_list_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`.
@@ -1343,6 +1657,15 @@ This should not be used with `DUCKDB_TYPE_DECIMAL`.
 */
 DUCKDB_API duckdb_logical_type duckdb_create_logical_type(duckdb_type type);
 
+/*!
+Returns the alias of a duckdb_logical_type, if one is set, else `NULL`.
+The result must be destroyed with `duckdb_free`.
+
+* type: The logical type to return the alias of
+* returns: The alias or `NULL`
+ */
+DUCKDB_API char *duckdb_logical_type_get_alias(duckdb_logical_type type);
+
 /*!
 Creates a list type from its child type.
 The resulting type should be destroyed with `duckdb_destroy_logical_type`.
@@ -1362,14 +1685,14 @@ The resulting type should be destroyed with `duckdb_destroy_logical_type`.
 DUCKDB_API duckdb_logical_type duckdb_create_map_type(duckdb_logical_type key_type, duckdb_logical_type value_type);
 
 /*!
-Creates a UNION type from the passed types array
+Creates a UNION type from the passed types array.
 The resulting type should be destroyed with `duckdb_destroy_logical_type`.
 
 * types: The array of types that the union should consist of.
 * type_amount: The size of the types array.
 * returns: The logical type.
 */
-DUCKDB_API duckdb_logical_type duckdb_create_union_type(duckdb_logical_type member_types, const char **member_names,
+DUCKDB_API duckdb_logical_type duckdb_create_union_type(duckdb_logical_type *member_types, const char **member_names,
                                                         idx_t member_count);
 
 /*!
@@ -1385,7 +1708,18 @@ DUCKDB_API duckdb_logical_type duckdb_create_struct_type(duckdb_logical_type *me
                                                          idx_t member_count);
 
 /*!
-Creates a `duckdb_logical_type` of type decimal with the specified width and scale
+Creates an ENUM type from the passed member name array.
+The resulting type should be destroyed with `duckdb_destroy_logical_type`.
+
+* enum_name: The name of the enum.
+* member_names: The array of names that the enum should consist of.
+* member_count: The number of elements that were specified in the array.
+* returns: The logical type.
+*/
+DUCKDB_API duckdb_logical_type duckdb_create_enum_type(const char **member_names, idx_t member_count);
+
+/*!
+Creates a `duckdb_logical_type` of type decimal with the specified width and scale.
 The resulting type should be destroyed with `duckdb_destroy_logical_type`.
 
 * width: The width of the decimal type
@@ -1395,7 +1729,7 @@ The resulting type should be destroyed with `duckdb_destroy_logical_type`.
 DUCKDB_API duckdb_logical_type duckdb_create_decimal_type(uint8_t width, uint8_t scale);
 
 /*!
-Retrieves the type class of a `duckdb_logical_type`.
+Retrieves the enum type class of a `duckdb_logical_type`.
 
 * type: The logical type object
 * returns: The type id
@@ -1435,7 +1769,7 @@ Retrieves the internal storage type of an enum type.
 DUCKDB_API duckdb_type duckdb_enum_internal_type(duckdb_logical_type type);
 
 /*!
-Retrieves the dictionary size of the enum type
+Retrieves the dictionary size of the enum type.
 
 * type: The logical type object
 * returns: The dictionary size of the enum type
@@ -1445,7 +1779,7 @@ DUCKDB_API uint32_t duckdb_enum_dictionary_size(duckdb_logical_type type);
 /*!
 Retrieves the dictionary value at the specified position from the enum.
 
-The result must be freed with `duckdb_free`
+The result must be freed with `duckdb_free`.
 
 * type: The logical type object
 * index: The index in the dictionary
@@ -1456,7 +1790,7 @@ DUCKDB_API char *duckdb_enum_dictionary_value(duckdb_logical_type type, idx_t in
 /*!
 Retrieves the child type of the given list type.
 
-The result must be freed with `duckdb_destroy_logical_type`
+The result must be freed with `duckdb_destroy_logical_type`.
 
 * type: The logical type object
 * returns: The child type of the list type. Must be destroyed with `duckdb_destroy_logical_type`.
@@ -1466,7 +1800,7 @@ DUCKDB_API duckdb_logical_type duckdb_list_type_child_type(duckdb_logical_type t
 /*!
 Retrieves the key type of the given map type.
 
-The result must be freed with `duckdb_destroy_logical_type`
+The result must be freed with `duckdb_destroy_logical_type`.
 
 * type: The logical type object
 * returns: The key type of the map type. Must be destroyed with `duckdb_destroy_logical_type`.
@@ -1476,7 +1810,7 @@ DUCKDB_API duckdb_logical_type duckdb_map_type_key_type(duckdb_logical_type type
 /*!
 Retrieves the value type of the given map type.
 
-The result must be freed with `duckdb_destroy_logical_type`
+The result must be freed with `duckdb_destroy_logical_type`.
 
 * type: The logical type object
 * returns: The value type of the map type. Must be destroyed with `duckdb_destroy_logical_type`.
@@ -1494,7 +1828,7 @@ DUCKDB_API idx_t duckdb_struct_type_child_count(duckdb_logical_type type);
 /*!
 Retrieves the name of the struct child.
 
-The result must be freed with `duckdb_free`
+The result must be freed with `duckdb_free`.
 
 * type: The logical type object
 * index: The child index
@@ -1505,7 +1839,7 @@ DUCKDB_API char *duckdb_struct_type_child_name(duckdb_logical_type type, idx_t i
 /*!
 Retrieves the child type of the given struct type at the specified index.
 
-The result must be freed with `duckdb_destroy_logical_type`
+The result must be freed with `duckdb_destroy_logical_type`.
 
 * type: The logical type object
 * index: The child index
@@ -1524,7 +1858,7 @@ DUCKDB_API idx_t duckdb_union_type_member_count(duckdb_logical_type type);
 /*!
 Retrieves the name of the union member.
 
-The result must be freed with `duckdb_free`
+The result must be freed with `duckdb_free`.
 
 * type: The logical type object
 * index: The child index
@@ -1535,7 +1869,7 @@ DUCKDB_API char *duckdb_union_type_member_name(duckdb_logical_type type, idx_t i
 /*!
 Retrieves the child type of the given union member at the specified index.
 
-The result must be freed with `duckdb_destroy_logical_type`
+The result must be freed with `duckdb_destroy_logical_type`.
 
 * type: The logical type object
 * index: The child index
@@ -1553,9 +1887,12 @@ DUCKDB_API void duckdb_destroy_logical_type(duckdb_logical_type *type);
 //===--------------------------------------------------------------------===//
 // Data Chunk Interface
 //===--------------------------------------------------------------------===//
+
 /*!
 Creates an empty DataChunk with the specified set of types.
 
+Note that the result must be destroyed with `duckdb_destroy_data_chunk`.
+
 * types: An array of types of the data chunk.
 * column_count: The number of columns.
 * returns: The data chunk.
@@ -1614,6 +1951,7 @@ DUCKDB_API void duckdb_data_chunk_set_size(duckdb_data_chunk chunk, idx_t size);
 //===--------------------------------------------------------------------===//
 // Vector Interface
 //===--------------------------------------------------------------------===//
+
 /*!
 Retrieves the column type of the specified vector.
 
@@ -1698,7 +2036,7 @@ The resulting vector is valid as long as the parent vector is valid.
 DUCKDB_API duckdb_vector duckdb_list_vector_get_child(duckdb_vector vector);
 
 /*!
-Returns the size of the child vector of the list
+Returns the size of the child vector of the list.
 
 * vector: The vector
 * returns: The size of the child list
@@ -1737,6 +2075,7 @@ DUCKDB_API duckdb_vector duckdb_struct_vector_get_child(duckdb_vector vector, id
 //===--------------------------------------------------------------------===//
 // Validity Mask Functions
 //===--------------------------------------------------------------------===//
+
 /*!
 Returns whether or not a row is valid (i.e. not NULL) in the given validity mask.
 
@@ -1781,15 +2120,6 @@ DUCKDB_API void duckdb_validity_set_row_valid(uint64_t *validity, idx_t row);
 //===--------------------------------------------------------------------===//
 // Table Functions
 //===--------------------------------------------------------------------===//
-typedef void *duckdb_table_function;
-typedef void *duckdb_bind_info;
-typedef void *duckdb_init_info;
-typedef void *duckdb_function_info;
-
-typedef void (*duckdb_table_function_bind_t)(duckdb_bind_info info);
-typedef void (*duckdb_table_function_init_t)(duckdb_init_info info);
-typedef void (*duckdb_table_function_t)(duckdb_function_info info, duckdb_data_chunk output);
-typedef void (*duckdb_delete_callback_t)(void *data);
 
 /*!
 Creates a new empty table function.
@@ -1844,7 +2174,7 @@ DUCKDB_API void duckdb_table_function_set_extra_info(duckdb_table_function table
                                                      duckdb_delete_callback_t destroy);
 
 /*!
-Sets the bind function of the table function
+Sets the bind function of the table function.
 
 * table_function: The table function
 * bind: The bind function
@@ -1852,7 +2182,7 @@ Sets the bind function of the table function
 DUCKDB_API void duckdb_table_function_set_bind(duckdb_table_function table_function, duckdb_table_function_bind_t bind);
 
 /*!
-Sets the init function of the table function
+Sets the init function of the table function.
 
 * table_function: The table function
 * init: The init function
@@ -1860,7 +2190,7 @@ Sets the init function of the table function
 DUCKDB_API void duckdb_table_function_set_init(duckdb_table_function table_function, duckdb_table_function_init_t init);
 
 /*!
-Sets the thread-local init function of the table function
+Sets the thread-local init function of the table function.
 
 * table_function: The table function
 * init: The init function
@@ -1869,7 +2199,7 @@ DUCKDB_API void duckdb_table_function_set_local_init(duckdb_table_function table
                                                      duckdb_table_function_init_t init);
 
 /*!
-Sets the main function of the table function
+Sets the main function of the table function.
 
 * table_function: The table function
 * function: The function
@@ -1905,8 +2235,9 @@ DUCKDB_API duckdb_state duckdb_register_table_function(duckdb_connection con, du
 //===--------------------------------------------------------------------===//
 // Table Function Bind
 //===--------------------------------------------------------------------===//
+
 /*!
-Retrieves the extra info of the function as set in `duckdb_table_function_set_extra_info`
+Retrieves the extra info of the function as set in `duckdb_table_function_set_extra_info`.
 
 * info: The info object
 * returns: The extra info
@@ -1982,7 +2313,7 @@ DUCKDB_API void duckdb_bind_set_error(duckdb_bind_info info, const char *error);
 //===--------------------------------------------------------------------===//
 
 /*!
-Retrieves the extra info of the function as set in `duckdb_table_function_set_extra_info`
+Retrieves the extra info of the function as set in `duckdb_table_function_set_extra_info`.
 
 * info: The info object
 * returns: The extra info
@@ -2051,12 +2382,13 @@ DUCKDB_API void duckdb_init_set_error(duckdb_init_info info, const char *error);
 //===--------------------------------------------------------------------===//
 
 /*!
-Retrieves the extra info of the function as set in `duckdb_table_function_set_extra_info`
+Retrieves the extra info of the function as set in `duckdb_table_function_set_extra_info`.
 
 * info: The info object
 * returns: The extra info
 */
 DUCKDB_API void *duckdb_function_get_extra_info(duckdb_function_info info);
+
 /*!
 Gets the bind data set by `duckdb_bind_set_bind_data` during the bind.
 
@@ -2095,12 +2427,9 @@ DUCKDB_API void duckdb_function_set_error(duckdb_function_info info, const char
 //===--------------------------------------------------------------------===//
 // Replacement Scans
 //===--------------------------------------------------------------------===//
-typedef void *duckdb_replacement_scan_info;
-
-typedef void (*duckdb_replacement_callback_t)(duckdb_replacement_scan_info info, const char *table_name, void *data);
 
 /*!
-Add a replacement scan definition to the specified database
+Add a replacement scan definition to the specified database.
 
 * db: The database object to add the replacement scan to
 * replacement: The replacement scan callback
@@ -2111,8 +2440,8 @@ DUCKDB_API void duckdb_add_replacement_scan(duckdb_database db, duckdb_replaceme
                                             void *extra_data, duckdb_delete_callback_t delete_callback);
 
 /*!
-Sets the replacement function name to use. If this function is called in the replacement callback,
- the replacement scan is performed. If it is not called, the replacement callback is not performed.
+Sets the replacement function name. If this function is called in the replacement callback,
+the replacement scan is performed. If it is not called, the replacement callback is not performed.
 
 * info: The info object
 * function_name: The function name to substitute.
@@ -2146,12 +2475,17 @@ DUCKDB_API void duckdb_replacement_scan_set_error(duckdb_replacement_scan_info i
 // the row should be finished by calling `duckdb_appender_end_row`. After all rows have been appended,
 // `duckdb_appender_destroy` should be used to finalize the appender and clean up the resulting memory.
 
+// Instead of appending rows with `duckdb_appender_end_row`, it is also possible to fill and append
+// chunks-at-a-time.
+
 // Note that `duckdb_appender_destroy` should always be called on the resulting appender, even if the function returns
 // `DuckDBError`.
 
 /*!
 Creates an appender object.
 
+Note that the object must be destroyed with `duckdb_appender_destroy`.
+
 * connection: The connection context to create the appender in.
 * schema: The schema of the table to append to, or `nullptr` for the default schema.
 * table: The table name to append to.
@@ -2161,6 +2495,25 @@ Creates an appender object.
 DUCKDB_API duckdb_state duckdb_appender_create(duckdb_connection connection, const char *schema, const char *table,
                                                duckdb_appender *out_appender);
 
+/*!
+Returns the number of columns in the table that belongs to the appender.
+
+* appender The appender to get the column count from.
+* returns: The number of columns in the table.
+*/
+DUCKDB_API idx_t duckdb_appender_column_count(duckdb_appender appender);
+
+/*!
+Returns the type of the column at the specified index.
+
+Note: The resulting type should be destroyed with `duckdb_destroy_logical_type`.
+
+* appender The appender to get the column type from.
+* col_idx The index of the column to get the type of.
+* returns: The duckdb_logical_type of the column.
+*/
+DUCKDB_API duckdb_logical_type duckdb_appender_column_type(duckdb_appender appender, idx_t col_idx);
+
 /*!
 Returns the error message associated with the given appender.
 If the appender has no error message, this returns `nullptr` instead.
@@ -2225,18 +2578,22 @@ DUCKDB_API duckdb_state duckdb_append_bool(duckdb_appender appender, bool value)
 Append an int8_t value to the appender.
 */
 DUCKDB_API duckdb_state duckdb_append_int8(duckdb_appender appender, int8_t value);
+
 /*!
 Append an int16_t value to the appender.
 */
 DUCKDB_API duckdb_state duckdb_append_int16(duckdb_appender appender, int16_t value);
+
 /*!
 Append an int32_t value to the appender.
 */
 DUCKDB_API duckdb_state duckdb_append_int32(duckdb_appender appender, int32_t value);
+
 /*!
 Append an int64_t value to the appender.
 */
 DUCKDB_API duckdb_state duckdb_append_int64(duckdb_appender appender, int64_t value);
+
 /*!
 Append a duckdb_hugeint value to the appender.
 */
@@ -2246,23 +2603,32 @@ DUCKDB_API duckdb_state duckdb_append_hugeint(duckdb_appender appender, duckdb_h
 Append a uint8_t value to the appender.
 */
 DUCKDB_API duckdb_state duckdb_append_uint8(duckdb_appender appender, uint8_t value);
+
 /*!
 Append a uint16_t value to the appender.
 */
 DUCKDB_API duckdb_state duckdb_append_uint16(duckdb_appender appender, uint16_t value);
+
 /*!
 Append a uint32_t value to the appender.
 */
 DUCKDB_API duckdb_state duckdb_append_uint32(duckdb_appender appender, uint32_t value);
+
 /*!
 Append a uint64_t value to the appender.
 */
 DUCKDB_API duckdb_state duckdb_append_uint64(duckdb_appender appender, uint64_t value);
 
+/*!
+Append a duckdb_uhugeint value to the appender.
+*/
+DUCKDB_API duckdb_state duckdb_append_uhugeint(duckdb_appender appender, duckdb_uhugeint value);
+
 /*!
 Append a float value to the appender.
 */
 DUCKDB_API duckdb_state duckdb_append_float(duckdb_appender appender, float value);
+
 /*!
 Append a double value to the appender.
 */
@@ -2272,14 +2638,17 @@ DUCKDB_API duckdb_state duckdb_append_double(duckdb_appender appender, double va
 Append a duckdb_date value to the appender.
 */
 DUCKDB_API duckdb_state duckdb_append_date(duckdb_appender appender, duckdb_date value);
+
 /*!
 Append a duckdb_time value to the appender.
 */
 DUCKDB_API duckdb_state duckdb_append_time(duckdb_appender appender, duckdb_time value);
+
 /*!
 Append a duckdb_timestamp value to the appender.
 */
 DUCKDB_API duckdb_state duckdb_append_timestamp(duckdb_appender appender, duckdb_timestamp value);
+
 /*!
 Append a duckdb_interval value to the appender.
 */
@@ -2289,14 +2658,17 @@ DUCKDB_API duckdb_state duckdb_append_interval(duckdb_appender appender, duckdb_
 Append a varchar value to the appender.
 */
 DUCKDB_API duckdb_state duckdb_append_varchar(duckdb_appender appender, const char *val);
+
 /*!
 Append a varchar value to the appender.
 */
 DUCKDB_API duckdb_state duckdb_append_varchar_length(duckdb_appender appender, const char *val, idx_t length);
+
 /*!
 Append a blob value to the appender.
 */
 DUCKDB_API duckdb_state duckdb_append_blob(duckdb_appender appender, const void *data, idx_t length);
+
 /*!
 Append a NULL value to the appender (of any type).
 */
@@ -2318,6 +2690,7 @@ DUCKDB_API duckdb_state duckdb_append_data_chunk(duckdb_appender appender, duckd
 //===--------------------------------------------------------------------===//
 // Arrow Interface
 //===--------------------------------------------------------------------===//
+
 /*!
 Executes a SQL query within a connection and stores the full (materialized) result in an arrow structure.
 If the query fails to execute, DuckDBError is returned and the error message can be retrieved by calling
@@ -2334,7 +2707,8 @@ query fails, otherwise the error stored within the result will not be freed corr
 DUCKDB_API duckdb_state duckdb_query_arrow(duckdb_connection connection, const char *query, duckdb_arrow *out_result);
 
 /*!
-Fetch the internal arrow schema from the arrow result.
+Fetch the internal arrow schema from the arrow result. Remember to call release on the respective
+ArrowSchema object.
 
 * result: The result to fetch the schema from.
 * out_schema: The output schema.
@@ -2343,7 +2717,8 @@ Fetch the internal arrow schema from the arrow result.
 DUCKDB_API duckdb_state duckdb_query_arrow_schema(duckdb_arrow result, duckdb_arrow_schema *out_schema);
 
 /*!
-Fetch the internal arrow schema from the prepared statement.
+Fetch the internal arrow schema from the prepared statement. Remember to call release on the respective
+ArrowSchema object.
 
 * result: The prepared statement to fetch the schema from.
 * out_schema: The output schema.
@@ -2351,9 +2726,19 @@ Fetch the internal arrow schema from the prepared statement.
 */
 DUCKDB_API duckdb_state duckdb_prepared_arrow_schema(duckdb_prepared_statement prepared,
                                                      duckdb_arrow_schema *out_schema);
+/*!
+Convert a data chunk into an arrow struct array. Remember to call release on the respective
+ArrowArray object.
+
+* result: The result object the data chunk have been fetched from.
+* chunk: The data chunk to convert.
+* out_array: The output array.
+*/
+DUCKDB_API void duckdb_result_arrow_array(duckdb_result result, duckdb_data_chunk chunk, duckdb_arrow_array *out_array);
 
 /*!
-Fetch an internal arrow array from the arrow result.
+Fetch an internal arrow struct array from the arrow result. Remember to call release on the respective
+ArrowArray object.
 
 This function can be called multiple time to get next chunks, which will free the previous out_array.
 So consume the out_array before calling this function again.
@@ -2365,7 +2750,7 @@ So consume the out_array before calling this function again.
 DUCKDB_API duckdb_state duckdb_query_arrow_array(duckdb_arrow result, duckdb_arrow_array *out_array);
 
 /*!
-Returns the number of columns present in a the arrow result object.
+Returns the number of columns present in the arrow result object.
 
 * result: The result object.
 * returns: The number of columns present in the result object.
@@ -2373,7 +2758,7 @@ Returns the number of columns present in a the arrow result object.
 DUCKDB_API idx_t duckdb_arrow_column_count(duckdb_arrow result);
 
 /*!
-Returns the number of rows present in a the arrow result object.
+Returns the number of rows present in the arrow result object.
 
 * result: The result object.
 * returns: The number of rows present in the result object.
@@ -2395,7 +2780,7 @@ Returns the error message contained within the result. The error is only set if
 
 The error message should not be freed. It will be de-allocated when `duckdb_destroy_arrow` is called.
 
-* result: The result object to fetch the nullmask from.
+* result: The result object to fetch the error from.
 * returns: The error of the result.
 */
 DUCKDB_API const char *duckdb_query_arrow_error(duckdb_arrow result);
@@ -2407,10 +2792,53 @@ Closes the result and de-allocates all memory allocated for the arrow result.
 */
 DUCKDB_API void duckdb_destroy_arrow(duckdb_arrow *result);
 
+/*!
+Releases the arrow array stream and de-allocates its memory.
+
+* stream: The arrow array stream to destroy.
+*/
+DUCKDB_API void duckdb_destroy_arrow_stream(duckdb_arrow_stream *stream_p);
+
+/*!
+Executes the prepared statement with the given bound parameters, and returns an arrow query result.
+Note that after running `duckdb_execute_prepared_arrow`, `duckdb_destroy_arrow` must be called on the result object.
+
+* prepared_statement: The prepared statement to execute.
+* out_result: The query result.
+* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+*/
+DUCKDB_API duckdb_state duckdb_execute_prepared_arrow(duckdb_prepared_statement prepared_statement,
+                                                      duckdb_arrow *out_result);
+
+/*!
+Scans the Arrow stream and creates a view with the given name.
+
+* connection: The connection on which to execute the scan.
+* table_name: Name of the temporary view to create.
+* arrow: Arrow stream wrapper.
+* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+*/
+DUCKDB_API duckdb_state duckdb_arrow_scan(duckdb_connection connection, const char *table_name,
+                                          duckdb_arrow_stream arrow);
+
+/*!
+Scans the Arrow array and creates a view with the given name.
+Note that after running `duckdb_arrow_array_scan`, `duckdb_destroy_arrow_stream` must be called on the out stream.
+
+* connection: The connection on which to execute the scan.
+* table_name: Name of the temporary view to create.
+* arrow_schema: Arrow schema wrapper.
+* arrow_array: Arrow array wrapper.
+* out_stream: Output array stream that wraps around the passed schema, for releasing/deleting once done.
+* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+*/
+DUCKDB_API duckdb_state duckdb_arrow_array_scan(duckdb_connection connection, const char *table_name,
+                                                duckdb_arrow_schema arrow_schema, duckdb_arrow_array arrow_array,
+                                                duckdb_arrow_stream *out_stream);
+
 //===--------------------------------------------------------------------===//
 // Threading Information
 //===--------------------------------------------------------------------===//
-typedef void *duckdb_task_state;
 
 /*!
 Execute DuckDB tasks on this thread.
@@ -2424,9 +2852,9 @@ DUCKDB_API void duckdb_execute_tasks(duckdb_database database, idx_t max_tasks);
 
 /*!
 Creates a task state that can be used with duckdb_execute_tasks_state to execute tasks until
- duckdb_finish_execution is called on the state.
+`duckdb_finish_execution` is called on the state.
 
-duckdb_destroy_state should be called on the result in order to free memory.
+`duckdb_destroy_state` must be called on the result.
 
 * database: The database object to create the task state for
 * returns: The task state that can be used with duckdb_execute_tasks_state.
@@ -2483,7 +2911,7 @@ on the task state.
 DUCKDB_API void duckdb_destroy_task_state(duckdb_task_state state);
 
 /*!
-Returns true if execution of the current query is finished.
+Returns true if the execution of the current query is finished.
 
 * con: The connection on which to check
 */