duckdb 0.8.2-dev37.0 → 0.8.2-dev3989.0

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

@@ -47,7 +47,7 @@ public:
 	void VerifyForeignKey(const vector<PhysicalIndex> &fk_keys, DataChunk &chunk, ConflictManager &conflict_manager);
 
 	//! Serialize all indexes owned by this table, returns a vector of block info of all indexes
-	vector<BlockPointer> SerializeIndexes(duckdb::MetaBlockWriter &writer);
+	vector<BlockPointer> SerializeIndexes(duckdb::MetadataWriter &writer);
 
 	vector<column_t> GetRequiredColumns();
 

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

@@ -16,6 +16,8 @@
 namespace duckdb {
 class ColumnList;
 class PersistentTableData;
+class FormatSerializer;
+class FormatDeserializer;
 
 class TableStatisticsLock {
 public:
@@ -50,6 +52,9 @@ public:
 	void Serialize(Serializer &serializer);
 	void Deserialize(Deserializer &source, ColumnList &columns);
 
+	void FormatSerialize(FormatSerializer &serializer);
+	void FormatDeserialize(FormatDeserializer &deserializer, ColumnList &columns);
+
 private:
 	//! The statistics lock
 	mutex stats_lock;

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

@@ -13,6 +13,7 @@
 namespace duckdb {
 class BlockManager;
 class DataTable;
+class MetadataManager;
 
 class TableIOManager {
 public:
@@ -27,6 +28,8 @@ public:
 
 	//! The block manager used for storing row group data
 	virtual BlockManager &GetBlockManagerForRowData() = 0;
+
+	virtual MetadataManager &GetMetadataManager() = 0;
 };
 
 } // namespace duckdb

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

@@ -39,8 +39,7 @@ class TransactionManager;
 class ReplayState {
 public:
 	ReplayState(AttachedDatabase &db, ClientContext &context, Deserializer &source)
-	    : db(db), context(context), catalog(db.GetCatalog()), source(source), deserialize_only(false),
-	      checkpoint_id(INVALID_BLOCK) {
+	    : db(db), context(context), catalog(db.GetCatalog()), source(source), deserialize_only(false) {
 	}
 
 	AttachedDatabase &db;
@@ -49,7 +48,7 @@ public:
 	Deserializer &source;
 	optional_ptr<TableCatalogEntry> current_table;
 	bool deserialize_only;
-	block_id_t checkpoint_id;
+	MetaBlockPointer checkpoint_id;
 
 public:
 	void ReplayEntry(WALType entry_type);
@@ -157,7 +156,7 @@ public:
 	void Delete();
 	void Flush();
 
-	void WriteCheckpoint(block_id_t meta_block);
+	void WriteCheckpoint(MetaBlockPointer meta_block);
 
 protected:
 	AttachedDatabase &database;

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

@@ -32,7 +32,7 @@ public:
 	LocalTableStorage(DataTable &table, LocalTableStorage &parent, idx_t drop_idx);
 	// Create a LocalTableStorage from an ADD COLUMN
 	LocalTableStorage(ClientContext &context, DataTable &table, LocalTableStorage &parent, ColumnDefinition &new_column,
-	                  optional_ptr<Expression> default_value);
+	                  Expression &default_value);
 	~LocalTableStorage();
 
 	reference<DataTable> table_ref;
@@ -143,8 +143,7 @@ public:
 
 	idx_t AddedRows(DataTable &table);
 
-	void AddColumn(DataTable &old_dt, DataTable &new_dt, ColumnDefinition &new_column,
-	               optional_ptr<Expression> default_value);
+	void AddColumn(DataTable &old_dt, DataTable &new_dt, ColumnDefinition &new_column, Expression &default_value);
 	void DropColumn(DataTable &old_dt, DataTable &new_dt, idx_t removed_column);
 	void ChangeType(DataTable &old_dt, DataTable &new_dt, idx_t changed_idx, const LogicalType &target_type,
 	                const vector<column_t> &bound_columns, Expression &cast_expr);

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

@@ -23,4 +23,10 @@ public:
 	static unique_ptr<StatementVerifier> Create(const SQLStatement &statement);
 };
 
+class DeserializedStatementVerifierNoDefaultV2 : public StatementVerifier {
+public:
+	explicit DeserializedStatementVerifierNoDefaultV2(unique_ptr<SQLStatement> statement_p);
+	static unique_ptr<StatementVerifier> Create(const SQLStatement &statement);
+};
+
 } // namespace duckdb

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

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

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

@@ -19,6 +19,7 @@ enum class VerificationType : uint8_t {
 	COPIED,
 	DESERIALIZED,
 	DESERIALIZED_V2,
+	DESERIALIZED_V2_NO_DEFAULT,
 	PARSED,
 	UNOPTIMIZED,
 	NO_OPERATOR_CACHING,

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

@@ -279,6 +279,9 @@ typedef struct _duckdb_appender {
 typedef struct _duckdb_arrow {
 	void *__arrw;
 } * duckdb_arrow;
+typedef struct _duckdb_arrow_stream {
+	void *__arrwstr;
+} * duckdb_arrow_stream;
 typedef struct _duckdb_config {
 	void *__cnfg;
 } * duckdb_config;
@@ -305,7 +308,8 @@ 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_ERROR = 2,
+	DUCKDB_PENDING_NO_TASKS_AVAILABLE = 3
 } duckdb_pending_state;
 
 //===--------------------------------------------------------------------===//
@@ -357,6 +361,21 @@ The instantiated connection should be closed using 'duckdb_disconnect'
 */
 DUCKDB_API duckdb_state duckdb_connect(duckdb_database database, duckdb_connection *out_connection);
 
+/*!
+Interrupt running query
+
+* connection: The connection to interruot
+*/
+DUCKDB_API void duckdb_interrupt(duckdb_connection connection);
+
+/*!
+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);
+
 /*!
 Closes the specified connection and de-allocates all memory allocated for that connection.
 
@@ -926,6 +945,16 @@ Returns 0 if the query was not successfully prepared.
 */
 DUCKDB_API idx_t duckdb_nparams(duckdb_prepared_statement prepared_statement);
 
+/*!
+Returns the name used to identify the parameter
+The returned string should be freed using `duckdb_free`.
+
+Returns NULL if the index is out of range for the provided prepared statement.
+
+* prepared_statement: The prepared statement for which to get the parameter name from.
+*/
+const char *duckdb_parameter_name(duckdb_prepared_statement prepared_statement, idx_t index);
+
 /*!
 Returns the parameter type for the parameter at the given index.
 
@@ -942,6 +971,18 @@ Clear the params bind to the prepared statement.
 */
 DUCKDB_API duckdb_state duckdb_clear_bindings(duckdb_prepared_statement prepared_statement);
 
+/*!
+Binds a value to the prepared statement at the specified index.
+*/
+DUCKDB_API duckdb_state duckdb_bind_value(duckdb_prepared_statement prepared_statement, idx_t param_idx,
+                                          duckdb_value val);
+
+/*!
+Retrieve the index of the parameter for the prepared statement, identified by name
+*/
+DUCKDB_API duckdb_state duckdb_bind_parameter_index(duckdb_prepared_statement prepared_statement, idx_t *param_idx_out,
+                                                    const char *name);
+
 /*!
 Binds a bool value to the prepared statement at the specified index.
 */
@@ -1078,6 +1119,31 @@ Executes the prepared statement with the given bound parameters, and returns an
 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.
+
+* 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);
+
 //===--------------------------------------------------------------------===//
 // Extract Statements
 //===--------------------------------------------------------------------===//
@@ -1201,6 +1267,15 @@ Otherwise, all remaining tasks must be executed first.
 */
 DUCKDB_API duckdb_state duckdb_execute_pending(duckdb_pending_result pending_result, duckdb_result *out_result);
 
+/*!
+Returns whether a duckdb_pending_state is finished executing. For example if `pending_state` is
+DUCKDB_PENDING_RESULT_READY, this function will return true.
+
+* pending_state: The pending state on which to decide whether to finish execution.
+* returns: Boolean indicating pending execution should be considered finished.
+*/
+DUCKDB_API bool duckdb_pending_execution_is_finished(duckdb_pending_state pending_state);
+
 //===--------------------------------------------------------------------===//
 // Value Interface
 //===--------------------------------------------------------------------===//
@@ -1297,6 +1372,18 @@ The resulting type should be destroyed with `duckdb_destroy_logical_type`.
 DUCKDB_API duckdb_logical_type duckdb_create_union_type(duckdb_logical_type member_types, const char **member_names,
                                                         idx_t member_count);
 
+/*!
+Creates a STRUCT type from the passed member name and type arrays.
+The resulting type should be destroyed with `duckdb_destroy_logical_type`.
+
+* member_types: The array of types that the struct should consist of.
+* member_names: The array of names that the struct should consist of.
+* member_count: The number of members that were specified for both arrays.
+* returns: The logical type.
+*/
+DUCKDB_API duckdb_logical_type duckdb_create_struct_type(duckdb_logical_type *member_types, 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`.
@@ -2255,6 +2342,16 @@ 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.
+
+* result: The prepared statement to fetch the schema from.
+* out_schema: The output schema.
+* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+*/
+DUCKDB_API duckdb_state duckdb_prepared_arrow_schema(duckdb_prepared_statement prepared,
+                                                     duckdb_arrow_schema *out_schema);
+
 /*!
 Fetch an internal arrow array from the arrow result.
 

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

@@ -184,9 +184,11 @@ void BaseAppender::AppendValueInternal(T input) {
 		AppendValueInternal<T, timestamp_t>(col, input);
 		break;
 	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
 		AppendValueInternal<T, dtime_t>(col, input);
 		break;
+	case LogicalTypeId::TIME_TZ:
+		AppendValueInternal<T, dtime_tz_t>(col, input);
+		break;
 	case LogicalTypeId::INTERVAL:
 		AppendValueInternal<T, interval_t>(col, input);
 		break;

package/src/duckdb/src/main/attached_database.cpp

@@ -87,11 +87,11 @@ bool AttachedDatabase::IsReadOnly() const {
 	return type == AttachedDatabaseType::READ_ONLY_DATABASE;
 }
 
-string AttachedDatabase::ExtractDatabaseName(const string &dbpath) {
+string AttachedDatabase::ExtractDatabaseName(const string &dbpath, FileSystem &fs) {
 	if (dbpath.empty() || dbpath == ":memory:") {
 		return "memory";
 	}
-	return FileSystem::ExtractBaseName(dbpath);
+	return fs.ExtractBaseName(dbpath);
 }
 
 void AttachedDatabase::Initialize() {

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

@@ -1,5 +1,8 @@
-#include "duckdb/main/capi/capi_internal.hpp"
 #include "duckdb/common/arrow/arrow_converter.hpp"
+#include "duckdb/function/table/arrow.hpp"
+#include "duckdb/main/capi/capi_internal.hpp"
+#include "duckdb/main/prepared_statement_data.hpp"
+#include "duckdb/common/arrow/arrow.hpp"
 
 using duckdb::ArrowConverter;
 using duckdb::ArrowResultWrapper;
@@ -29,6 +32,45 @@ duckdb_state duckdb_query_arrow_schema(duckdb_arrow result, duckdb_arrow_schema
 	return DuckDBSuccess;
 }
 
+duckdb_state duckdb_prepared_arrow_schema(duckdb_prepared_statement prepared, duckdb_arrow_schema *out_schema) {
+	if (!out_schema) {
+		return DuckDBSuccess;
+	}
+	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared);
+	if (!wrapper || !wrapper->statement || !wrapper->statement->data) {
+		return DuckDBError;
+	}
+	auto properties = wrapper->statement->context->GetClientProperties();
+	duckdb::vector<duckdb::LogicalType> prepared_types;
+	duckdb::vector<duckdb::string> prepared_names;
+
+	auto count = wrapper->statement->data->properties.parameter_count;
+	for (idx_t i = 0; i < count; i++) {
+		// Every prepared parameter type is UNKNOWN, which we need to map to NULL according to the spec of
+		// 'AdbcStatementGetParameterSchema'
+		auto type = LogicalType::SQLNULL;
+
+		// FIXME: we don't support named parameters yet, but when we do, this needs to be updated
+		auto name = std::to_string(i);
+		prepared_types.push_back(std::move(type));
+		prepared_names.push_back(name);
+	}
+
+	auto result_schema = (ArrowSchema *)*out_schema;
+	if (!result_schema) {
+		return DuckDBError;
+	}
+
+	if (result_schema->release) {
+		// Need to release the existing schema before we overwrite it
+		result_schema->release(result_schema);
+		result_schema->release = nullptr;
+	}
+
+	ArrowConverter::ToArrowSchema(result_schema, prepared_types, prepared_names, properties);
+	return DuckDBSuccess;
+}
+
 duckdb_state duckdb_query_arrow_array(duckdb_arrow result, duckdb_arrow_array *out_array) {
 	if (!out_array) {
 		return DuckDBSuccess;
@@ -94,13 +136,7 @@ duckdb_state duckdb_execute_prepared_arrow(duckdb_prepared_statement prepared_st
 		return DuckDBError;
 	}
 	auto arrow_wrapper = new ArrowResultWrapper();
-	if (wrapper->statement->context->config.set_variables.find("TimeZone") ==
-	    wrapper->statement->context->config.set_variables.end()) {
-		arrow_wrapper->options.time_zone = "UTC";
-	} else {
-		arrow_wrapper->options.time_zone =
-		    wrapper->statement->context->config.set_variables["TimeZone"].GetValue<std::string>();
-	}
+	arrow_wrapper->options = wrapper->statement->context->GetClientProperties();
 
 	auto result = wrapper->statement->Execute(wrapper->values, false);
 	D_ASSERT(result->type == QueryResultType::MATERIALIZED_RESULT);
@@ -108,3 +144,155 @@ duckdb_state duckdb_execute_prepared_arrow(duckdb_prepared_statement prepared_st
 	*out_result = reinterpret_cast<duckdb_arrow>(arrow_wrapper);
 	return !arrow_wrapper->result->HasError() ? DuckDBSuccess : DuckDBError;
 }
+
+namespace arrow_array_stream_wrapper {
+namespace {
+struct PrivateData {
+	ArrowSchema *schema;
+	ArrowArray *array;
+	bool done = false;
+};
+
+// LCOV_EXCL_START
+// This function is never called, but used to set ArrowSchema's release functions to a non-null NOOP.
+void EmptySchemaRelease(ArrowSchema *) {
+}
+// LCOV_EXCL_STOP
+
+void EmptyArrayRelease(ArrowArray *) {
+}
+
+void EmptyStreamRelease(ArrowArrayStream *) {
+}
+
+void FactoryGetSchema(uintptr_t stream_factory_ptr, duckdb::ArrowSchemaWrapper &schema) {
+	auto stream = reinterpret_cast<ArrowArrayStream *>(stream_factory_ptr);
+	stream->get_schema(stream, &schema.arrow_schema);
+
+	// Need to nullify the root schema's release function here, because streams don't allow us to set the release
+	// function. For the schema's children, we nullify the release functions in `duckdb_arrow_scan`, so we don't need to
+	// handle them again here. We set this to nullptr and not EmptySchemaRelease to prevent ArrowSchemaWrapper's
+	// destructor from destroying the schema (it's the caller's responsibility).
+	schema.arrow_schema.release = nullptr;
+}
+
+int GetSchema(struct ArrowArrayStream *stream, struct ArrowSchema *out) {
+	auto private_data = static_cast<arrow_array_stream_wrapper::PrivateData *>((stream->private_data));
+	if (private_data->schema == nullptr) {
+		return DuckDBError;
+	}
+
+	*out = *private_data->schema;
+	out->release = EmptySchemaRelease;
+	return DuckDBSuccess;
+}
+
+int GetNext(struct ArrowArrayStream *stream, struct ArrowArray *out) {
+	auto private_data = static_cast<arrow_array_stream_wrapper::PrivateData *>((stream->private_data));
+	*out = *private_data->array;
+	if (private_data->done) {
+		out->release = nullptr;
+	} else {
+		out->release = EmptyArrayRelease;
+	}
+
+	private_data->done = true;
+	return DuckDBSuccess;
+}
+
+duckdb::unique_ptr<duckdb::ArrowArrayStreamWrapper> FactoryGetNext(uintptr_t stream_factory_ptr,
+                                                                   duckdb::ArrowStreamParameters &parameters) {
+	auto stream = reinterpret_cast<ArrowArrayStream *>(stream_factory_ptr);
+	auto ret = duckdb::make_uniq<duckdb::ArrowArrayStreamWrapper>();
+	ret->arrow_array_stream = *stream;
+	ret->arrow_array_stream.release = EmptyStreamRelease;
+	return ret;
+}
+
+// LCOV_EXCL_START
+// This function is never be called, because it's used to construct a stream wrapping around a caller-supplied
+// ArrowArray. Thus, the stream itself cannot produce an error.
+const char *GetLastError(struct ArrowArrayStream *stream) {
+	return nullptr;
+}
+// LCOV_EXCL_STOP
+
+void Release(struct ArrowArrayStream *stream) {
+	if (stream->private_data != nullptr) {
+		delete reinterpret_cast<PrivateData *>(stream->private_data);
+	}
+
+	stream->private_data = nullptr;
+	stream->release = nullptr;
+}
+
+duckdb_state Ingest(duckdb_connection connection, const char *table_name, struct ArrowArrayStream *input) {
+	try {
+		auto cconn = reinterpret_cast<duckdb::Connection *>(connection);
+		cconn
+		    ->TableFunction("arrow_scan", {duckdb::Value::POINTER((uintptr_t)input),
+		                                   duckdb::Value::POINTER((uintptr_t)FactoryGetNext),
+		                                   duckdb::Value::POINTER((uintptr_t)FactoryGetSchema)})
+		    ->CreateView(table_name, true, false);
+	} catch (...) { // LCOV_EXCL_START
+		// Tried covering this in tests, but it proved harder than expected. At the time of writing:
+		// - Passing any name to `CreateView` worked without throwing an exception
+		// - Passing a null Arrow array worked without throwing an exception
+		// - Passing an invalid schema (without any columns) led to an InternalException with SIGABRT, which is meant to
+		//   be un-catchable. This case likely needs to be handled gracefully within `arrow_scan`.
+		// Ref: https://discord.com/channels/909674491309850675/921100573732909107/1115230468699336785
+		return DuckDBError;
+	} // LCOV_EXCL_STOP
+
+	return DuckDBSuccess;
+}
+} // namespace
+} // namespace arrow_array_stream_wrapper
+
+duckdb_state duckdb_arrow_scan(duckdb_connection connection, const char *table_name, duckdb_arrow_stream arrow) {
+	auto stream = reinterpret_cast<ArrowArrayStream *>(arrow);
+
+	// Backup release functions - we nullify children schema release functions because we don't want to release on
+	// behalf of the caller, downstream in our code. Note that Arrow releases target immediate children, but aren't
+	// recursive. So we only back up immediate children here and restore their functions.
+	ArrowSchema schema;
+	if (stream->get_schema(stream, &schema) == DuckDBError) {
+		return DuckDBError;
+	}
+
+	typedef void (*release_fn_t)(ArrowSchema *);
+	std::vector<release_fn_t> release_fns(schema.n_children);
+	for (int64_t i = 0; i < schema.n_children; i++) {
+		auto child = schema.children[i];
+		release_fns[i] = child->release;
+		child->release = arrow_array_stream_wrapper::EmptySchemaRelease;
+	}
+
+	auto ret = arrow_array_stream_wrapper::Ingest(connection, table_name, stream);
+
+	// Restore release functions.
+	for (int64_t i = 0; i < schema.n_children; i++) {
+		schema.children[i]->release = release_fns[i];
+	}
+
+	return ret;
+}
+
+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) {
+	auto private_data = new arrow_array_stream_wrapper::PrivateData;
+	private_data->schema = reinterpret_cast<ArrowSchema *>(arrow_schema);
+	private_data->array = reinterpret_cast<ArrowArray *>(arrow_array);
+	private_data->done = false;
+
+	ArrowArrayStream *stream = new ArrowArrayStream;
+	*out_stream = reinterpret_cast<duckdb_arrow_stream>(stream);
+	stream->get_schema = arrow_array_stream_wrapper::GetSchema;
+	stream->get_next = arrow_array_stream_wrapper::GetNext;
+	stream->get_last_error = arrow_array_stream_wrapper::GetLastError;
+	stream->release = arrow_array_stream_wrapper::Release;
+	stream->private_data = private_data;
+
+	return duckdb_arrow_scan(connection, table_name, reinterpret_cast<duckdb_arrow_stream>(stream));
+}

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

@@ -54,6 +54,22 @@ duckdb_state duckdb_connect(duckdb_database database, duckdb_connection *out) {
 	return DuckDBSuccess;
 }
 
+void duckdb_interrupt(duckdb_connection connection) {
+	if (!connection) {
+		return;
+	}
+	Connection *conn = reinterpret_cast<Connection *>(connection);
+	conn->Interrupt();
+}
+
+double duckdb_query_progress(duckdb_connection connection) {
+	if (!connection) {
+		return -1;
+	}
+	Connection *conn = reinterpret_cast<Connection *>(connection);
+	return conn->context->GetProgress();
+}
+
 void duckdb_disconnect(duckdb_connection *connection) {
 	if (connection && *connection) {
 		Connection *conn = reinterpret_cast<Connection *>(*connection);

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

@@ -26,7 +26,7 @@ char *duckdb_get_varchar(duckdb_value value) {
 	auto str_val = val->DefaultCastAs(duckdb::LogicalType::VARCHAR);
 	auto &str = duckdb::StringValue::Get(str_val);
 
-	auto result = reinterpret_cast<char *>(malloc(sizeof(char *) * (str.size() + 1)));
+	auto result = reinterpret_cast<char *>(malloc(sizeof(char) * (str.size() + 1)));
 	memcpy(result, str.c_str(), str.size());
 	result[str.size()] = '\0';
 	return result;

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

@@ -51,6 +51,28 @@ duckdb_logical_type duckdb_create_union_type(duckdb_logical_type member_types_p,
 	return reinterpret_cast<duckdb_logical_type>(mtype);
 }
 
+duckdb_logical_type duckdb_create_struct_type(duckdb_logical_type *member_types_p, const char **member_names,
+                                              idx_t member_count) {
+	if (!member_types_p || !member_names) {
+		return nullptr;
+	}
+	duckdb::LogicalType **member_types = (duckdb::LogicalType **)member_types_p;
+	for (idx_t i = 0; i < member_count; i++) {
+		if (!member_names[i] || !member_types[i]) {
+			return nullptr;
+		}
+	}
+
+	duckdb::LogicalType *mtype = new duckdb::LogicalType;
+	duckdb::child_list_t<duckdb::LogicalType> members;
+
+	for (idx_t i = 0; i < member_count; i++) {
+		members.push_back(make_pair(member_names[i], *member_types[i]));
+	}
+	*mtype = duckdb::LogicalType::STRUCT(members);
+	return reinterpret_cast<duckdb_logical_type>(mtype);
+}
+
 duckdb_logical_type duckdb_create_map_type(duckdb_logical_type key_type, duckdb_logical_type value_type) {
 	if (!key_type || !value_type) {
 		return nullptr;

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

@@ -2,12 +2,17 @@
 #include "duckdb/main/query_result.hpp"
 #include "duckdb/main/pending_query_result.hpp"
 #include "duckdb/common/preserved_error.hpp"
+#include "duckdb/common/case_insensitive_map.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
+using duckdb::case_insensitive_map_t;
 using duckdb::make_uniq;
+using duckdb::optional_ptr;
 using duckdb::PendingExecutionResult;
 using duckdb::PendingQueryResult;
 using duckdb::PendingStatementWrapper;
 using duckdb::PreparedStatementWrapper;
+using duckdb::Value;
 
 duckdb_state duckdb_pending_prepared_internal(duckdb_prepared_statement prepared_statement,
                                               duckdb_pending_result *out_result, bool allow_streaming) {
@@ -17,6 +22,7 @@ duckdb_state duckdb_pending_prepared_internal(duckdb_prepared_statement prepared
 	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
 	auto result = new PendingStatementWrapper();
 	result->allow_streaming = allow_streaming;
+
 	try {
 		result->statement = wrapper->statement->PendingQuery(wrapper->values, allow_streaming);
 	} catch (const duckdb::Exception &ex) {
@@ -86,6 +92,8 @@ duckdb_pending_state duckdb_pending_execute_task(duckdb_pending_result pending_r
 	switch (return_value) {
 	case PendingExecutionResult::RESULT_READY:
 		return DUCKDB_PENDING_RESULT_READY;
+	case PendingExecutionResult::NO_TASKS_AVAILABLE:
+		return DUCKDB_PENDING_NO_TASKS_AVAILABLE;
 	case PendingExecutionResult::RESULT_NOT_READY:
 		return DUCKDB_PENDING_RESULT_NOT_READY;
 	default:
@@ -93,6 +101,21 @@ duckdb_pending_state duckdb_pending_execute_task(duckdb_pending_result pending_r
 	}
 }
 
+bool duckdb_pending_execution_is_finished(duckdb_pending_state pending_state) {
+	switch (pending_state) {
+	case DUCKDB_PENDING_RESULT_READY:
+		return PendingQueryResult::IsFinished(PendingExecutionResult::RESULT_READY);
+	case DUCKDB_PENDING_NO_TASKS_AVAILABLE:
+		return PendingQueryResult::IsFinished(PendingExecutionResult::NO_TASKS_AVAILABLE);
+	case DUCKDB_PENDING_RESULT_NOT_READY:
+		return PendingQueryResult::IsFinished(PendingExecutionResult::RESULT_NOT_READY);
+	case DUCKDB_PENDING_ERROR:
+		return PendingQueryResult::IsFinished(PendingExecutionResult::EXECUTION_ERROR);
+	default:
+		return PendingQueryResult::IsFinished(PendingExecutionResult::EXECUTION_ERROR);
+	}
+}
+
 duckdb_state duckdb_execute_pending(duckdb_pending_result pending_result, duckdb_result *out_result) {
 	if (!pending_result || !out_result) {
 		return DuckDBError;