duckdb 1.3.4 → 1.4.0

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

@@ -3,10 +3,12 @@
 
 using duckdb::Appender;
 using duckdb::AppenderWrapper;
+using duckdb::BaseAppender;
 using duckdb::Connection;
 using duckdb::date_t;
 using duckdb::dtime_t;
 using duckdb::ErrorData;
+using duckdb::ErrorDataWrapper;
 using duckdb::hugeint_t;
 using duckdb::interval_t;
 using duckdb::string_t;
@@ -33,15 +35,58 @@ duckdb_state duckdb_appender_create_ext(duckdb_connection connection, const char
 	}
 
 	auto wrapper = new AppenderWrapper();
-	*out_appender = (duckdb_appender)wrapper;
+	*out_appender = reinterpret_cast<duckdb_appender>(wrapper);
 	try {
 		wrapper->appender = duckdb::make_uniq<Appender>(*conn, catalog, schema, table);
 	} catch (std::exception &ex) {
-		ErrorData error(ex);
-		wrapper->error = error.RawMessage();
+		wrapper->error_data = ErrorData(ex);
 		return DuckDBError;
 	} catch (...) { // LCOV_EXCL_START
-		wrapper->error = "Unknown create appender error";
+		wrapper->error_data = ErrorData("Unknown create appender error");
+		return DuckDBError;
+	} // LCOV_EXCL_STOP
+	return DuckDBSuccess;
+}
+
+duckdb_state duckdb_appender_create_query(duckdb_connection connection, const char *query, idx_t column_count,
+                                          duckdb_logical_type *types_p, const char *table_name_p,
+                                          const char **column_names_p, duckdb_appender *out_appender) {
+	Connection *conn = reinterpret_cast<Connection *>(connection);
+
+	if (!connection || !query || !column_count || !types_p) {
+		return DuckDBError;
+	}
+	duckdb::vector<duckdb::LogicalType> types;
+	duckdb::vector<duckdb::string> column_names;
+	duckdb::string table_name;
+	for (idx_t c = 0; c < column_count; ++c) {
+		if (!types_p[c]) {
+			return DuckDBError;
+		}
+		types.push_back(*reinterpret_cast<duckdb::LogicalType *>(types_p[c]));
+	}
+	if (table_name_p) {
+		table_name = table_name_p;
+	}
+	if (column_names_p) {
+		for (idx_t c = 0; c < column_count; ++c) {
+			if (!column_names_p[c]) {
+				return DuckDBError;
+			}
+			column_names.push_back(column_names_p[c]);
+		}
+	}
+
+	auto wrapper = new AppenderWrapper();
+	*out_appender = reinterpret_cast<duckdb_appender>(wrapper);
+	try {
+		wrapper->appender = duckdb::make_uniq<duckdb::QueryAppender>(*conn, query, std::move(types),
+		                                                             std::move(column_names), std::move(table_name));
+	} catch (std::exception &ex) {
+		wrapper->error_data = ErrorData(ex);
+		return DuckDBError;
+	} catch (...) { // LCOV_EXCL_START
+		wrapper->error_data = ErrorData("Unknown create appender error");
 		return DuckDBError;
 	} // LCOV_EXCL_STOP
 	return DuckDBSuccess;
@@ -67,27 +112,27 @@ duckdb_state duckdb_appender_run_function(duckdb_appender appender, FUN &&functi
 	}
 	auto wrapper = reinterpret_cast<AppenderWrapper *>(appender);
 	if (!wrapper->appender) {
+		wrapper->error_data = ErrorData("not a valid appender");
 		return DuckDBError;
 	}
 	try {
 		function(*wrapper->appender);
 	} catch (std::exception &ex) {
-		ErrorData error(ex);
-		wrapper->error = error.RawMessage();
+		wrapper->error_data = ErrorData(ex);
 		return DuckDBError;
 	} catch (...) { // LCOV_EXCL_START
-		wrapper->error = "Unknown appender error.";
+		wrapper->error_data = ErrorData("Unknown appender error");
 		return DuckDBError;
 	} // LCOV_EXCL_STOP
 	return DuckDBSuccess;
 }
 
-duckdb_state duckdb_appender_add_column(duckdb_appender appender, const char *name) {
-	return duckdb_appender_run_function(appender, [&](Appender &appender) { appender.AddColumn(name); });
+duckdb_state duckdb_appender_add_column(duckdb_appender appender_p, const char *name) {
+	return duckdb_appender_run_function(appender_p, [&](BaseAppender &appender) { appender.AddColumn(name); });
 }
 
-duckdb_state duckdb_appender_clear_columns(duckdb_appender appender) {
-	return duckdb_appender_run_function(appender, [&](Appender &appender) { appender.ClearColumns(); });
+duckdb_state duckdb_appender_clear_columns(duckdb_appender appender_p) {
+	return duckdb_appender_run_function(appender_p, [&](BaseAppender &appender) { appender.ClearColumns(); });
 }
 
 const char *duckdb_appender_error(duckdb_appender appender) {
@@ -95,18 +140,29 @@ const char *duckdb_appender_error(duckdb_appender appender) {
 		return nullptr;
 	}
 	auto wrapper = reinterpret_cast<AppenderWrapper *>(appender);
-	if (wrapper->error.empty()) {
+	if (!wrapper->error_data.HasError()) {
 		return nullptr;
 	}
-	return wrapper->error.c_str();
+	return wrapper->error_data.RawMessage().c_str();
+}
+
+duckdb_error_data duckdb_appender_error_data(duckdb_appender appender) {
+	auto errorDataWrapper = new ErrorDataWrapper();
+	if (!appender) {
+		return reinterpret_cast<duckdb_error_data>(errorDataWrapper);
+	}
+
+	auto appenderWrapper = reinterpret_cast<AppenderWrapper *>(appender);
+	errorDataWrapper->error_data = appenderWrapper->error_data;
+	return reinterpret_cast<duckdb_error_data>(errorDataWrapper);
 }
 
 duckdb_state duckdb_appender_begin_row(duckdb_appender appender) {
 	return DuckDBSuccess;
 }
 
-duckdb_state duckdb_appender_end_row(duckdb_appender appender) {
-	return duckdb_appender_run_function(appender, [&](Appender &appender) { appender.EndRow(); });
+duckdb_state duckdb_appender_end_row(duckdb_appender appender_p) {
+	return duckdb_appender_run_function(appender_p, [&](BaseAppender &appender) { appender.EndRow(); });
 }
 
 template <class T>
@@ -118,8 +174,7 @@ duckdb_state duckdb_append_internal(duckdb_appender appender, T value) {
 	try {
 		appender_instance->appender->Append<T>(value);
 	} catch (std::exception &ex) {
-		ErrorData error(ex);
-		appender_instance->error = error.RawMessage();
+		appender_instance->error_data = ErrorData(ex);
 		return DuckDBError;
 	} catch (...) {
 		return DuckDBError;
@@ -136,8 +191,7 @@ duckdb_state duckdb_append_default(duckdb_appender appender) {
 	try {
 		appender_instance->appender->AppendDefault();
 	} catch (std::exception &ex) {
-		ErrorData error(ex);
-		appender_instance->error = error.RawMessage();
+		appender_instance->error_data = ErrorData(ex);
 		return DuckDBError;
 	} catch (...) {
 		return DuckDBError;
@@ -157,8 +211,7 @@ duckdb_state duckdb_append_default_to_chunk(duckdb_appender appender, duckdb_dat
 	try {
 		appender_instance->appender->AppendDefault(*data_chunk, col, row);
 	} catch (std::exception &ex) {
-		ErrorData error(ex);
-		appender_instance->error = error.RawMessage();
+		appender_instance->error_data = ErrorData(ex);
 		return DuckDBError;
 	} catch (...) {
 		return DuckDBError;
@@ -257,16 +310,16 @@ duckdb_state duckdb_append_varchar_length(duckdb_appender appender, const char *
 }
 
 duckdb_state duckdb_append_blob(duckdb_appender appender, const void *data, idx_t length) {
-	auto value = duckdb::Value::BLOB((duckdb::const_data_ptr_t)data, length);
+	auto value = duckdb::Value::BLOB(duckdb::const_data_ptr_cast(data), length);
 	return duckdb_append_internal<duckdb::Value>(appender, value);
 }
 
-duckdb_state duckdb_appender_flush(duckdb_appender appender) {
-	return duckdb_appender_run_function(appender, [&](Appender &appender) { appender.Flush(); });
+duckdb_state duckdb_appender_flush(duckdb_appender appender_p) {
+	return duckdb_appender_run_function(appender_p, [&](BaseAppender &appender) { appender.Flush(); });
 }
 
-duckdb_state duckdb_appender_close(duckdb_appender appender) {
-	return duckdb_appender_run_function(appender, [&](Appender &appender) { appender.Close(); });
+duckdb_state duckdb_appender_close(duckdb_appender appender_p) {
+	return duckdb_appender_run_function(appender_p, [&](BaseAppender &appender) { appender.Close(); });
 }
 
 idx_t duckdb_appender_column_count(duckdb_appender appender) {
@@ -300,10 +353,11 @@ duckdb_state duckdb_append_value(duckdb_appender appender, duckdb_value value) {
 	return duckdb_append_internal<duckdb::Value>(appender, *(reinterpret_cast<duckdb::Value *>(value)));
 }
 
-duckdb_state duckdb_append_data_chunk(duckdb_appender appender, duckdb_data_chunk chunk) {
+duckdb_state duckdb_append_data_chunk(duckdb_appender appender_p, duckdb_data_chunk chunk) {
 	if (!chunk) {
 		return DuckDBError;
 	}
 	auto data_chunk = reinterpret_cast<duckdb::DataChunk *>(chunk);
-	return duckdb_appender_run_function(appender, [&](Appender &appender) { appender.AppendDataChunk(*data_chunk); });
+	return duckdb_appender_run_function(appender_p,
+	                                    [&](BaseAppender &appender) { appender.AppendDataChunk(*data_chunk); });
 }

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

@@ -3,9 +3,11 @@
 #include "duckdb/function/table/arrow.hpp"
 #include "duckdb/main/capi/capi_internal.hpp"
 #include "duckdb/main/prepared_statement_data.hpp"
+#include "fmt/format.h"
 
 using duckdb::ArrowConverter;
 using duckdb::ArrowResultWrapper;
+using duckdb::CClientArrowOptionsWrapper;
 using duckdb::Connection;
 using duckdb::DataChunk;
 using duckdb::LogicalType;
@@ -14,12 +16,157 @@ using duckdb::PreparedStatementWrapper;
 using duckdb::QueryResult;
 using duckdb::QueryResultType;
 
+duckdb_error_data duckdb_to_arrow_schema(duckdb_arrow_options arrow_options, duckdb_logical_type *types,
+                                         const char **names, idx_t column_count, struct ArrowSchema *out_schema) {
+
+	if (!types || !names || !arrow_options || !out_schema) {
+		return duckdb_create_error_data(DUCKDB_ERROR_INVALID_INPUT, "Invalid argument(s) to duckdb_to_arrow_schema");
+	}
+	duckdb::vector<LogicalType> schema_types;
+	duckdb::vector<std::string> schema_names;
+	for (idx_t i = 0; i < column_count; i++) {
+		schema_names.emplace_back(names[i]);
+		schema_types.emplace_back(*reinterpret_cast<duckdb::LogicalType *>(types[i]));
+	}
+	const auto arrow_options_wrapper = reinterpret_cast<CClientArrowOptionsWrapper *>(arrow_options);
+	try {
+		ArrowConverter::ToArrowSchema(out_schema, schema_types, schema_names, arrow_options_wrapper->properties);
+	} catch (const duckdb::Exception &ex) {
+		return duckdb_create_error_data(DUCKDB_ERROR_INVALID_INPUT, ex.what());
+	} catch (const std::exception &ex) {
+		return duckdb_create_error_data(DUCKDB_ERROR_INVALID_INPUT, ex.what());
+	} catch (...) {
+		return duckdb_create_error_data(DUCKDB_ERROR_INVALID_INPUT, "Unknown error occurred during conversion");
+	}
+	return nullptr;
+}
+
+duckdb_error_data duckdb_data_chunk_to_arrow(duckdb_arrow_options arrow_options, duckdb_data_chunk chunk,
+                                             struct ArrowArray *out_arrow_array) {
+	if (!arrow_options || !chunk || !out_arrow_array) {
+		return duckdb_create_error_data(DUCKDB_ERROR_INVALID_INPUT,
+		                                "Invalid argument(s) to duckdb_data_chunk_to_arrow");
+	}
+	auto dchunk = reinterpret_cast<duckdb::DataChunk *>(chunk);
+	auto arrow_options_wrapper = reinterpret_cast<CClientArrowOptionsWrapper *>(arrow_options);
+	auto extension_type_cast = duckdb::ArrowTypeExtensionData::GetExtensionTypes(
+	    *arrow_options_wrapper->properties.client_context, dchunk->GetTypes());
+
+	try {
+		ArrowConverter::ToArrowArray(*dchunk, out_arrow_array, arrow_options_wrapper->properties, extension_type_cast);
+	} catch (const duckdb::Exception &ex) {
+		return duckdb_create_error_data(DUCKDB_ERROR_INVALID_INPUT, ex.what());
+	} catch (const std::exception &ex) {
+		return duckdb_create_error_data(DUCKDB_ERROR_INVALID_INPUT, ex.what());
+	} catch (...) {
+		return duckdb_create_error_data(DUCKDB_ERROR_INVALID_INPUT, "Unknown error occurred during conversion");
+	}
+	return nullptr;
+}
+
+duckdb_error_data duckdb_schema_from_arrow(duckdb_connection connection, struct ArrowSchema *schema,
+                                           duckdb_arrow_converted_schema *out_types) {
+	if (!connection || !out_types || !schema) {
+		return duckdb_create_error_data(DUCKDB_ERROR_INVALID_INPUT,
+		                                "Invalid argument(s) to duckdb_data_chunk_to_arrow");
+	}
+	duckdb::vector<std::string> names;
+	const auto conn = reinterpret_cast<Connection *>(connection);
+	auto arrow_table = duckdb::make_uniq<duckdb::ArrowTableSchema>();
+	try {
+		duckdb::vector<LogicalType> return_types;
+		duckdb::ArrowTableFunction::PopulateArrowTableSchema(duckdb::DBConfig::GetConfig(*conn->context), *arrow_table,
+		                                                     *schema);
+	} catch (const duckdb::Exception &ex) {
+		return duckdb_create_error_data(DUCKDB_ERROR_INVALID_INPUT, ex.what());
+	} catch (const std::exception &ex) {
+		return duckdb_create_error_data(DUCKDB_ERROR_INVALID_INPUT, ex.what());
+	} catch (...) {
+		return duckdb_create_error_data(DUCKDB_ERROR_INVALID_INPUT, "Unknown error occurred during conversion");
+	}
+	*out_types = reinterpret_cast<duckdb_arrow_converted_schema>(arrow_table.release());
+	return nullptr;
+}
+
+duckdb_error_data duckdb_data_chunk_from_arrow(duckdb_connection connection, struct ArrowArray *arrow_array,
+                                               duckdb_arrow_converted_schema converted_schema,
+                                               duckdb_data_chunk *out_chunk) {
+	if (!connection || !converted_schema || !out_chunk || !arrow_array) {
+		return duckdb_create_error_data(DUCKDB_ERROR_INVALID_INPUT,
+		                                "Invalid argument(s) to duckdb_data_chunk_to_arrow");
+	}
+	auto arrow_table = reinterpret_cast<duckdb::ArrowTableSchema *>(converted_schema);
+	auto conn = reinterpret_cast<Connection *>(connection);
+	auto &types = arrow_table->GetTypes();
+
+	auto dchunk = duckdb::make_uniq<duckdb::DataChunk>();
+	dchunk->Initialize(duckdb::Allocator::DefaultAllocator(), types, duckdb::NumericCast<idx_t>(arrow_array->length));
+
+	auto &arrow_types = arrow_table->GetColumns();
+	dchunk->SetCardinality(duckdb::NumericCast<idx_t>(arrow_array->length));
+	for (idx_t i = 0; i < dchunk->ColumnCount(); i++) {
+		auto &parent_array = *arrow_array;
+		auto &array = parent_array.children[i];
+		auto arrow_type = arrow_types.at(i);
+		auto array_physical_type = arrow_type->GetPhysicalType();
+		auto array_state = duckdb::make_uniq<duckdb::ArrowArrayScanState>(*conn->context);
+		// We need to make sure that our chunk will hold the ownership
+		array_state->owned_data = duckdb::make_shared_ptr<duckdb::ArrowArrayWrapper>();
+		array_state->owned_data->arrow_array = *arrow_array;
+		// We set it to nullptr to effectively transfer the ownership
+		arrow_array->release = nullptr;
+		try {
+			switch (array_physical_type) {
+			case duckdb::ArrowArrayPhysicalType::DICTIONARY_ENCODED:
+				duckdb::ArrowToDuckDBConversion::ColumnArrowToDuckDBDictionary(dchunk->data[i], *array, 0, *array_state,
+				                                                               dchunk->size(), *arrow_type);
+				break;
+			case duckdb::ArrowArrayPhysicalType::RUN_END_ENCODED:
+				duckdb::ArrowToDuckDBConversion::ColumnArrowToDuckDBRunEndEncoded(
+				    dchunk->data[i], *array, 0, *array_state, dchunk->size(), *arrow_type);
+				break;
+			case duckdb::ArrowArrayPhysicalType::DEFAULT:
+				duckdb::ArrowToDuckDBConversion::SetValidityMask(dchunk->data[i], *array, 0, dchunk->size(),
+				                                                 parent_array.offset, -1);
+
+				duckdb::ArrowToDuckDBConversion::ColumnArrowToDuckDB(dchunk->data[i], *array, 0, *array_state,
+				                                                     dchunk->size(), *arrow_type);
+				break;
+			default:
+				return duckdb_create_error_data(DUCKDB_ERROR_NOT_IMPLEMENTED,
+				                                "Only Default Physical Types are currently supported");
+			}
+		} catch (const duckdb::Exception &ex) {
+			return duckdb_create_error_data(DUCKDB_ERROR_INVALID_INPUT, ex.what());
+		} catch (const std::exception &ex) {
+			return duckdb_create_error_data(DUCKDB_ERROR_INVALID_INPUT, ex.what());
+		} catch (...) {
+			return duckdb_create_error_data(DUCKDB_ERROR_INVALID_INPUT, "Unknown error occurred during conversion");
+		}
+	}
+	*out_chunk = reinterpret_cast<duckdb_data_chunk>(dchunk.release());
+	return nullptr;
+}
+
+void duckdb_destroy_arrow_converted_schema(duckdb_arrow_converted_schema *arrow_converted_schema) {
+	if (arrow_converted_schema && *arrow_converted_schema) {
+		auto converted_schema = reinterpret_cast<duckdb::ArrowTableSchema *>(*arrow_converted_schema);
+		delete converted_schema;
+		*arrow_converted_schema = nullptr;
+	}
+}
+
 duckdb_state duckdb_query_arrow(duckdb_connection connection, const char *query, duckdb_arrow *out_result) {
 	Connection *conn = (Connection *)connection;
 	auto wrapper = new ArrowResultWrapper();
-	wrapper->result = conn->Query(query);
-	*out_result = (duckdb_arrow)wrapper;
-	return !wrapper->result->HasError() ? DuckDBSuccess : DuckDBError;
+	try {
+		wrapper->result = conn->Query(query);
+		*out_result = (duckdb_arrow)wrapper;
+		return !wrapper->result->HasError() ? DuckDBSuccess : DuckDBError;
+	} catch (...) {
+		delete wrapper;
+		return DuckDBError;
+	}
 }
 
 duckdb_state duckdb_query_arrow_schema(duckdb_arrow result, duckdb_arrow_schema *out_schema) {
@@ -171,11 +318,16 @@ duckdb_state duckdb_execute_prepared_arrow(duckdb_prepared_statement prepared_st
 		return DuckDBError;
 	}
 	auto arrow_wrapper = new ArrowResultWrapper();
-	auto result = wrapper->statement->Execute(wrapper->values, false);
-	D_ASSERT(result->type == QueryResultType::MATERIALIZED_RESULT);
-	arrow_wrapper->result = duckdb::unique_ptr_cast<QueryResult, MaterializedQueryResult>(std::move(result));
-	*out_result = reinterpret_cast<duckdb_arrow>(arrow_wrapper);
-	return !arrow_wrapper->result->HasError() ? DuckDBSuccess : DuckDBError;
+	try {
+		auto result = wrapper->statement->Execute(wrapper->values, false);
+		D_ASSERT(result->type == QueryResultType::MATERIALIZED_RESULT);
+		arrow_wrapper->result = duckdb::unique_ptr_cast<QueryResult, MaterializedQueryResult>(std::move(result));
+		*out_result = reinterpret_cast<duckdb_arrow>(arrow_wrapper);
+		return !arrow_wrapper->result->HasError() ? DuckDBSuccess : DuckDBError;
+	} catch (...) {
+		delete arrow_wrapper;
+		return DuckDBError;
+	}
 }
 
 namespace arrow_array_stream_wrapper {
@@ -321,13 +473,25 @@ duckdb_state duckdb_arrow_array_scan(duckdb_connection connection, const char *t
 	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));
+	ArrowArrayStream *stream;
+	try {
+		stream = new ArrowArrayStream;
+	} catch (...) {
+		delete private_data;
+		return DuckDBError;
+	}
+	try {
+		*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));
+	} catch (...) {
+		delete private_data;
+		delete stream;
+		return DuckDBError;
+	}
 }

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

@@ -23,7 +23,8 @@ duckdb_state duckdb_create_config(duckdb_config *out_config) {
 }
 
 size_t duckdb_config_count() {
-	return DBConfig::GetOptionCount() + duckdb::ExtensionHelper::ArraySize(duckdb::EXTENSION_SETTINGS);
+	return DBConfig::GetOptionCount() + DBConfig::GetAliasCount() +
+	       duckdb::ExtensionHelper::ArraySize(duckdb::EXTENSION_SETTINGS);
 }
 
 duckdb_state duckdb_get_config_flag(size_t index, const char **out_name, const char **out_description) {
@@ -37,9 +38,23 @@ duckdb_state duckdb_get_config_flag(size_t index, const char **out_name, const c
 		}
 		return DuckDBSuccess;
 	}
+	// alias
+	index -= DBConfig::GetOptionCount();
+	auto alias = DBConfig::GetAliasByIndex(index);
+	if (alias) {
+		if (out_name) {
+			*out_name = alias->alias;
+		}
+		option = DBConfig::GetOptionByIndex(alias->option_index);
+		if (out_description) {
+			*out_description = option->description;
+		}
+		return DuckDBSuccess;
+	}
+	index -= DBConfig::GetAliasCount();
 
-	// extension index?
-	auto entry = duckdb::ExtensionHelper::GetArrayEntry(duckdb::EXTENSION_SETTINGS, index - DBConfig::GetOptionCount());
+	// extension index
+	auto entry = duckdb::ExtensionHelper::GetArrayEntry(duckdb::EXTENSION_SETTINGS, index);
 	if (!entry) {
 		return DuckDBError;
 	}

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

@@ -48,8 +48,12 @@ void duckdb_data_chunk_reset(duckdb_data_chunk chunk) {
 
 duckdb_vector duckdb_create_vector(duckdb_logical_type type, idx_t capacity) {
 	auto dtype = reinterpret_cast<duckdb::LogicalType *>(type);
-	auto vector = new duckdb::Vector(*dtype, capacity);
-	return reinterpret_cast<duckdb_vector>(vector);
+	try {
+		auto vector = new duckdb::Vector(*dtype, capacity);
+		return reinterpret_cast<duckdb_vector>(vector);
+	} catch (...) {
+		return nullptr;
+	}
 }
 
 void duckdb_destroy_vector(duckdb_vector *vector) {
@@ -234,18 +238,26 @@ duckdb_selection_vector duckdb_create_selection_vector(idx_t size) {
 	return reinterpret_cast<duckdb_selection_vector>(new duckdb::SelectionVector(size));
 }
 
-void duckdb_destroy_selection_vector(duckdb_selection_vector vector) {
-	delete reinterpret_cast<duckdb::SelectionVector *>(vector);
+void duckdb_destroy_selection_vector(duckdb_selection_vector sel) {
+	delete reinterpret_cast<duckdb::SelectionVector *>(sel);
+}
+
+sel_t *duckdb_selection_vector_get_data_ptr(duckdb_selection_vector sel) {
+	return reinterpret_cast<duckdb::SelectionVector *>(sel)->data();
 }
 
-sel_t *duckdb_selection_vector_get_data_ptr(duckdb_selection_vector vector) {
-	return reinterpret_cast<duckdb::SelectionVector *>(vector)->data();
+void duckdb_slice_vector(duckdb_vector dict, duckdb_selection_vector sel, idx_t len) {
+	auto d_dict = reinterpret_cast<duckdb::Vector *>(dict);
+	auto d_sel = reinterpret_cast<duckdb::SelectionVector *>(sel);
+	d_dict->Slice(*d_sel, len);
 }
 
-void duckdb_slice_vector(duckdb_vector dict, duckdb_selection_vector selection, idx_t len) {
-	auto ddict = reinterpret_cast<duckdb::Vector *>(dict);
-	auto dselection = reinterpret_cast<duckdb::SelectionVector *>(selection);
-	ddict->Slice(*dselection, len);
+void duckdb_vector_copy_sel(duckdb_vector src, duckdb_vector dst, duckdb_selection_vector sel, idx_t src_count,
+                            idx_t src_offset, idx_t dst_offset) {
+	auto d_src = reinterpret_cast<duckdb::Vector *>(src);
+	auto d_dst = reinterpret_cast<duckdb::Vector *>(dst);
+	auto d_sel = reinterpret_cast<duckdb::SelectionVector *>(sel);
+	duckdb::VectorOperations::Copy(*d_src, *d_dst, *d_sel, src_count, src_offset, dst_offset);
 }
 
 void duckdb_vector_reference_value(duckdb_vector vector, duckdb_value value) {

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

@@ -1,5 +1,6 @@
 #include "duckdb/main/capi/capi_internal.hpp"
 
+using duckdb::CClientArrowOptionsWrapper;
 using duckdb::CClientContextWrapper;
 using duckdb::Connection;
 using duckdb::DatabaseWrapper;
@@ -147,8 +148,26 @@ void duckdb_connection_get_client_context(duckdb_connection connection, duckdb_c
 		return;
 	}
 	Connection *conn = reinterpret_cast<Connection *>(connection);
-	auto wrapper = new CClientContextWrapper(*conn->context);
-	*out_context = reinterpret_cast<duckdb_client_context>(wrapper);
+	try {
+		auto wrapper = new CClientContextWrapper(*conn->context);
+		*out_context = reinterpret_cast<duckdb_client_context>(wrapper);
+	} catch (...) {
+		*out_context = nullptr;
+	}
+}
+
+void duckdb_connection_get_arrow_options(duckdb_connection connection, duckdb_arrow_options *out_arrow_options) {
+	if (!connection || !out_arrow_options) {
+		return;
+	}
+	Connection *conn = reinterpret_cast<Connection *>(connection);
+	try {
+		auto client_properties = conn->context->GetClientProperties();
+		auto wrapper = new CClientArrowOptionsWrapper(client_properties);
+		*out_arrow_options = reinterpret_cast<duckdb_arrow_options>(wrapper);
+	} catch (...) {
+		*out_arrow_options = nullptr;
+	}
 }
 
 idx_t duckdb_client_context_get_connection_id(duckdb_client_context context) {
@@ -164,10 +183,22 @@ void duckdb_destroy_client_context(duckdb_client_context *context) {
 	}
 }
 
+void duckdb_destroy_arrow_options(duckdb_arrow_options *arrow_options) {
+	if (arrow_options && *arrow_options) {
+		auto wrapper = reinterpret_cast<CClientArrowOptionsWrapper *>(*arrow_options);
+		delete wrapper;
+		*arrow_options = nullptr;
+	}
+}
+
 duckdb_state duckdb_query(duckdb_connection connection, const char *query, duckdb_result *out) {
 	Connection *conn = reinterpret_cast<Connection *>(connection);
-	auto result = conn->Query(query);
-	return DuckDBTranslateResult(std::move(result), out);
+	try {
+		auto result = conn->Query(query);
+		return DuckDBTranslateResult(std::move(result), out);
+	} catch (...) {
+		return DuckDBError;
+	}
 }
 
 const char *duckdb_library_version() {
@@ -176,26 +207,38 @@ const char *duckdb_library_version() {
 
 duckdb_value duckdb_get_table_names(duckdb_connection connection, const char *query, bool qualified) {
 	Connection *conn = reinterpret_cast<Connection *>(connection);
-	auto table_names = conn->GetTableNames(query, qualified);
+	try {
+		auto table_names = conn->GetTableNames(query, qualified);
+
+		auto count = table_names.size();
+		auto ptr = malloc(count * sizeof(duckdb_value));
+		if (!ptr) {
+			return nullptr;
+		}
+		auto list_values = reinterpret_cast<duckdb_value *>(ptr);
 
-	auto count = table_names.size();
-	auto ptr = malloc(count * sizeof(duckdb_value));
-	auto list_values = reinterpret_cast<duckdb_value *>(ptr);
+		try {
+			idx_t name_ix = 0;
+			for (const auto &name : table_names) {
+				list_values[name_ix] = duckdb_create_varchar(name.c_str());
+				name_ix++;
+			}
 
-	idx_t name_ix = 0;
-	for (const auto &name : table_names) {
-		list_values[name_ix] = duckdb_create_varchar(name.c_str());
-		name_ix++;
-	}
+			auto varchar_type = duckdb_create_logical_type(DUCKDB_TYPE_VARCHAR);
+			auto list_value = duckdb_create_list_value(varchar_type, list_values, count);
 
-	auto varchar_type = duckdb_create_logical_type(DUCKDB_TYPE_VARCHAR);
-	auto list_value = duckdb_create_list_value(varchar_type, list_values, count);
+			for (idx_t i = 0; i < count; i++) {
+				duckdb_destroy_value(&list_values[i]);
+			}
+			duckdb_free(ptr);
+			duckdb_destroy_logical_type(&varchar_type);
 
-	for (idx_t i = 0; i < count; i++) {
-		duckdb_destroy_value(&list_values[i]);
+			return list_value;
+		} catch (...) {
+			duckdb_free(ptr);
+			return nullptr;
+		}
+	} catch (...) {
+		return nullptr;
 	}
-	duckdb_free(ptr);
-	duckdb_destroy_logical_type(&varchar_type);
-
-	return list_value;
 }