duckdb 1.3.4 → 1.4.0

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

@@ -5,7 +5,7 @@
 #include "duckdb/common/types/string_type.hpp"
 #include "duckdb/common/types/uuid.hpp"
 #include "duckdb/common/types/value.hpp"
-#include "duckdb/common/types/varint.hpp"
+#include "duckdb/common/types/bignum.hpp"
 #include "duckdb/main/capi/capi_internal.hpp"
 
 using duckdb::LogicalTypeId;
@@ -119,16 +119,16 @@ duckdb_uhugeint duckdb_get_uhugeint(duckdb_value val) {
 	auto res = CAPIGetValue<duckdb::uhugeint_t, LogicalTypeId::UHUGEINT>(val);
 	return {res.lower, res.upper};
 }
-duckdb_value duckdb_create_varint(duckdb_varint input) {
+duckdb_value duckdb_create_bignum(duckdb_bignum input) {
 	return WrapValue(new duckdb::Value(
-	    duckdb::Value::VARINT(duckdb::Varint::FromByteArray(input.data, input.size, input.is_negative))));
+	    duckdb::Value::BIGNUM(duckdb::Bignum::FromByteArray(input.data, input.size, input.is_negative))));
 }
-duckdb_varint duckdb_get_varint(duckdb_value val) {
-	auto v = UnwrapValue(val).DefaultCastAs(duckdb::LogicalType::VARINT);
+duckdb_bignum duckdb_get_bignum(duckdb_value val) {
+	auto v = UnwrapValue(val).DefaultCastAs(duckdb::LogicalType::BIGNUM);
 	auto &str = duckdb::StringValue::Get(v);
 	duckdb::vector<uint8_t> byte_array;
 	bool is_negative;
-	duckdb::Varint::GetByteArray(byte_array, is_negative, duckdb::string_t(str));
+	duckdb::Bignum::GetByteArray(byte_array, is_negative, duckdb::string_t(str));
 	auto size = byte_array.size();
 	auto data = reinterpret_cast<uint8_t *>(malloc(size));
 	memcpy(data, byte_array.data(), size);
@@ -186,6 +186,12 @@ duckdb_value duckdb_create_time_tz_value(duckdb_time_tz input) {
 duckdb_time_tz duckdb_get_time_tz(duckdb_value val) {
 	return {CAPIGetValue<duckdb::dtime_tz_t, LogicalTypeId::TIME_TZ>(val).bits};
 }
+duckdb_value duckdb_create_time_ns(duckdb_time_ns input) {
+	return CAPICreateValue(duckdb::dtime_ns_t(input.nanos));
+}
+duckdb_time_ns duckdb_get_time_ns(duckdb_value val) {
+	return {CAPIGetValue<duckdb::dtime_ns_t, LogicalTypeId::TIME_NS>(val).micros};
+}
 
 duckdb_value duckdb_create_timestamp(duckdb_timestamp input) {
 	duckdb::timestamp_t ts(input.micros);
@@ -352,7 +358,7 @@ duckdb_value duckdb_create_list_value(duckdb_logical_type type, duckdb_value *va
 		}
 		unwrapped_values.push_back(UnwrapValue(value));
 	}
-	duckdb::Value *list_value = new duckdb::Value;
+	auto list_value = new duckdb::Value;
 	try {
 		*list_value = duckdb::Value::LIST(logical_type, std::move(unwrapped_values));
 	} catch (...) {

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

@@ -0,0 +1,46 @@
+#include "duckdb/main/capi/capi_internal.hpp"
+
+using duckdb::ErrorData;
+using duckdb::ErrorDataWrapper;
+
+duckdb_error_data duckdb_create_error_data(duckdb_error_type type, const char *message) {
+	auto wrapper = new ErrorDataWrapper();
+	wrapper->error_data = ErrorData(duckdb::ErrorTypeFromC(type), message);
+	return reinterpret_cast<duckdb_error_data>(wrapper);
+}
+
+void duckdb_destroy_error_data(duckdb_error_data *error_data) {
+	if (!error_data || !*error_data) {
+		return;
+	}
+	auto wrapper = reinterpret_cast<ErrorDataWrapper *>(*error_data);
+	delete wrapper;
+	*error_data = nullptr;
+}
+
+duckdb_error_type duckdb_error_data_error_type(duckdb_error_data error_data) {
+	if (!error_data) {
+		return DUCKDB_ERROR_INVALID_TYPE;
+	}
+
+	auto *wrapper = reinterpret_cast<ErrorDataWrapper *>(error_data);
+	return duckdb::ErrorTypeToC(wrapper->error_data.Type());
+}
+
+const char *duckdb_error_data_message(duckdb_error_data error_data) {
+	if (!error_data) {
+		return nullptr;
+	}
+
+	auto *wrapper = reinterpret_cast<ErrorDataWrapper *>(error_data);
+	return wrapper->error_data.RawMessage().c_str();
+}
+
+bool duckdb_error_data_has_error(duckdb_error_data error_data) {
+	if (!error_data) {
+		return false;
+	}
+
+	auto *wrapper = reinterpret_cast<ErrorDataWrapper *>(error_data);
+	return wrapper->error_data.HasError();
+}

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

@@ -0,0 +1,57 @@
+#include "duckdb/main/capi/capi_internal.hpp"
+
+#include "duckdb/execution/expression_executor.hpp"
+
+using duckdb::CClientContextWrapper;
+using duckdb::ExpressionWrapper;
+
+void duckdb_destroy_expression(duckdb_expression *expr) {
+	if (!expr || !*expr) {
+		return;
+	}
+	auto wrapper = reinterpret_cast<ExpressionWrapper *>(*expr);
+	delete wrapper;
+	*expr = nullptr;
+}
+
+duckdb_logical_type duckdb_expression_return_type(duckdb_expression expr) {
+	if (!expr) {
+		return nullptr;
+	}
+	auto wrapper = reinterpret_cast<ExpressionWrapper *>(expr);
+	auto logical_type = new duckdb::LogicalType(wrapper->expr->return_type);
+	return reinterpret_cast<duckdb_logical_type>(logical_type);
+}
+
+bool duckdb_expression_is_foldable(duckdb_expression expr) {
+	if (!expr) {
+		return false;
+	}
+	auto wrapper = reinterpret_cast<ExpressionWrapper *>(expr);
+	return wrapper->expr->IsFoldable();
+}
+
+duckdb_error_data duckdb_expression_fold(duckdb_client_context context, duckdb_expression expr,
+                                         duckdb_value *out_value) {
+	if (!expr || !duckdb_expression_is_foldable(expr)) {
+		return nullptr;
+	}
+
+	auto value = new duckdb::Value;
+	try {
+		auto context_wrapper = reinterpret_cast<CClientContextWrapper *>(context);
+		auto expr_wrapper = reinterpret_cast<ExpressionWrapper *>(expr);
+		*value = duckdb::ExpressionExecutor::EvaluateScalar(context_wrapper->context, *expr_wrapper->expr);
+		*out_value = reinterpret_cast<duckdb_value>(value);
+	} catch (const duckdb::Exception &ex) {
+		delete value;
+		return duckdb_create_error_data(DUCKDB_ERROR_INVALID_INPUT, ex.what());
+	} catch (const std::exception &ex) {
+		delete value;
+		return duckdb_create_error_data(DUCKDB_ERROR_INVALID_INPUT, ex.what());
+	} catch (...) {
+		delete value;
+		return duckdb_create_error_data(DUCKDB_ERROR_INVALID_INPUT, "unknown error occurred during folding");
+	}
+	return nullptr;
+}

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

@@ -2,8 +2,8 @@
 
 namespace duckdb {
 
-LogicalTypeId ConvertCTypeToCPP(duckdb_type c_type) {
-	switch (c_type) {
+LogicalTypeId LogicalTypeIdFromC(const duckdb_type type) {
+	switch (type) {
 	case DUCKDB_TYPE_INVALID:
 		return LogicalTypeId::INVALID;
 	case DUCKDB_TYPE_BOOLEAN:
@@ -74,8 +74,8 @@ LogicalTypeId ConvertCTypeToCPP(duckdb_type c_type) {
 		return LogicalTypeId::TIMESTAMP_TZ;
 	case DUCKDB_TYPE_ANY:
 		return LogicalTypeId::ANY;
-	case DUCKDB_TYPE_VARINT:
-		return LogicalTypeId::VARINT;
+	case DUCKDB_TYPE_BIGNUM:
+		return LogicalTypeId::BIGNUM;
 	case DUCKDB_TYPE_SQLNULL:
 		return LogicalTypeId::SQLNULL;
 	case DUCKDB_TYPE_STRING_LITERAL:
@@ -88,10 +88,12 @@ LogicalTypeId ConvertCTypeToCPP(duckdb_type c_type) {
 	} // LCOV_EXCL_STOP
 }
 
-duckdb_type ConvertCPPTypeToC(const LogicalType &sql_type) {
-	switch (sql_type.id()) {
+duckdb_type LogicalTypeIdToC(const LogicalTypeId type) {
+	switch (type) {
 	case LogicalTypeId::INVALID:
 		return DUCKDB_TYPE_INVALID;
+	case LogicalTypeId::UNKNOWN:
+		return DUCKDB_TYPE_INVALID;
 	case LogicalTypeId::BOOLEAN:
 		return DUCKDB_TYPE_BOOLEAN;
 	case LogicalTypeId::TINYINT:
@@ -140,8 +142,8 @@ duckdb_type ConvertCPPTypeToC(const LogicalType &sql_type) {
 		return DUCKDB_TYPE_BLOB;
 	case LogicalTypeId::BIT:
 		return DUCKDB_TYPE_BIT;
-	case LogicalTypeId::VARINT:
-		return DUCKDB_TYPE_VARINT;
+	case LogicalTypeId::BIGNUM:
+		return DUCKDB_TYPE_BIGNUM;
 	case LogicalTypeId::INTERVAL:
 		return DUCKDB_TYPE_INTERVAL;
 	case LogicalTypeId::DECIMAL:
@@ -174,7 +176,7 @@ duckdb_type ConvertCPPTypeToC(const LogicalType &sql_type) {
 	} // LCOV_EXCL_STOP
 }
 
-idx_t GetCTypeSize(duckdb_type type) {
+idx_t GetCTypeSize(const duckdb_type type) {
 	switch (type) {
 	case DUCKDB_TYPE_BOOLEAN:
 		return sizeof(bool);
@@ -227,69 +229,255 @@ idx_t GetCTypeSize(duckdb_type type) {
 	} // LCOV_EXCL_STOP
 }
 
-duckdb_statement_type StatementTypeToC(duckdb::StatementType statement_type) {
-	switch (statement_type) {
-	case duckdb::StatementType::SELECT_STATEMENT:
+duckdb_statement_type StatementTypeToC(const StatementType type) {
+	switch (type) {
+	case StatementType::SELECT_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_SELECT;
-	case duckdb::StatementType::INVALID_STATEMENT:
+	case StatementType::INVALID_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_INVALID;
-	case duckdb::StatementType::INSERT_STATEMENT:
+	case StatementType::INSERT_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_INSERT;
-	case duckdb::StatementType::UPDATE_STATEMENT:
+	case StatementType::UPDATE_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_UPDATE;
-	case duckdb::StatementType::EXPLAIN_STATEMENT:
+	case StatementType::EXPLAIN_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_EXPLAIN;
-	case duckdb::StatementType::DELETE_STATEMENT:
+	case StatementType::DELETE_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_DELETE;
-	case duckdb::StatementType::PREPARE_STATEMENT:
+	case StatementType::PREPARE_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_PREPARE;
-	case duckdb::StatementType::CREATE_STATEMENT:
+	case StatementType::CREATE_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_CREATE;
-	case duckdb::StatementType::EXECUTE_STATEMENT:
+	case StatementType::EXECUTE_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_EXECUTE;
-	case duckdb::StatementType::ALTER_STATEMENT:
+	case StatementType::ALTER_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_ALTER;
-	case duckdb::StatementType::TRANSACTION_STATEMENT:
+	case StatementType::TRANSACTION_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_TRANSACTION;
-	case duckdb::StatementType::COPY_STATEMENT:
+	case StatementType::COPY_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_COPY;
-	case duckdb::StatementType::ANALYZE_STATEMENT:
+	case StatementType::ANALYZE_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_ANALYZE;
-	case duckdb::StatementType::VARIABLE_SET_STATEMENT:
+	case StatementType::VARIABLE_SET_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_VARIABLE_SET;
-	case duckdb::StatementType::CREATE_FUNC_STATEMENT:
+	case StatementType::CREATE_FUNC_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_CREATE_FUNC;
-	case duckdb::StatementType::DROP_STATEMENT:
+	case StatementType::DROP_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_DROP;
-	case duckdb::StatementType::EXPORT_STATEMENT:
+	case StatementType::EXPORT_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_EXPORT;
-	case duckdb::StatementType::PRAGMA_STATEMENT:
+	case StatementType::PRAGMA_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_PRAGMA;
-	case duckdb::StatementType::VACUUM_STATEMENT:
+	case StatementType::VACUUM_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_VACUUM;
-	case duckdb::StatementType::CALL_STATEMENT:
+	case StatementType::CALL_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_CALL;
-	case duckdb::StatementType::SET_STATEMENT:
+	case StatementType::SET_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_SET;
-	case duckdb::StatementType::LOAD_STATEMENT:
+	case StatementType::LOAD_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_LOAD;
-	case duckdb::StatementType::RELATION_STATEMENT:
+	case StatementType::RELATION_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_RELATION;
-	case duckdb::StatementType::EXTENSION_STATEMENT:
+	case StatementType::EXTENSION_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_EXTENSION;
-	case duckdb::StatementType::LOGICAL_PLAN_STATEMENT:
+	case StatementType::LOGICAL_PLAN_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_LOGICAL_PLAN;
-	case duckdb::StatementType::ATTACH_STATEMENT:
+	case StatementType::ATTACH_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_ATTACH;
-	case duckdb::StatementType::DETACH_STATEMENT:
+	case StatementType::DETACH_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_DETACH;
-	case duckdb::StatementType::MULTI_STATEMENT:
+	case StatementType::MULTI_STATEMENT:
 		return DUCKDB_STATEMENT_TYPE_MULTI;
 	default:
 		return DUCKDB_STATEMENT_TYPE_INVALID;
 	}
 }
 
+duckdb_error_type ErrorTypeToC(const ExceptionType type) {
+	switch (type) {
+	case ExceptionType::INVALID:
+		return DUCKDB_ERROR_INVALID;
+	case ExceptionType::OUT_OF_RANGE:
+		return DUCKDB_ERROR_OUT_OF_RANGE;
+	case ExceptionType::CONVERSION:
+		return DUCKDB_ERROR_CONVERSION;
+	case ExceptionType::UNKNOWN_TYPE:
+		return DUCKDB_ERROR_UNKNOWN_TYPE;
+	case ExceptionType::DECIMAL:
+		return DUCKDB_ERROR_DECIMAL;
+	case ExceptionType::MISMATCH_TYPE:
+		return DUCKDB_ERROR_MISMATCH_TYPE;
+	case ExceptionType::DIVIDE_BY_ZERO:
+		return DUCKDB_ERROR_DIVIDE_BY_ZERO;
+	case ExceptionType::OBJECT_SIZE:
+		return DUCKDB_ERROR_OBJECT_SIZE;
+	case ExceptionType::INVALID_TYPE:
+		return DUCKDB_ERROR_INVALID_TYPE;
+	case ExceptionType::SERIALIZATION:
+		return DUCKDB_ERROR_SERIALIZATION;
+	case ExceptionType::TRANSACTION:
+		return DUCKDB_ERROR_TRANSACTION;
+	case ExceptionType::NOT_IMPLEMENTED:
+		return DUCKDB_ERROR_NOT_IMPLEMENTED;
+	case ExceptionType::EXPRESSION:
+		return DUCKDB_ERROR_EXPRESSION;
+	case ExceptionType::CATALOG:
+		return DUCKDB_ERROR_CATALOG;
+	case ExceptionType::PARSER:
+		return DUCKDB_ERROR_PARSER;
+	case ExceptionType::PLANNER:
+		return DUCKDB_ERROR_PLANNER;
+	case ExceptionType::SCHEDULER:
+		return DUCKDB_ERROR_SCHEDULER;
+	case ExceptionType::EXECUTOR:
+		return DUCKDB_ERROR_EXECUTOR;
+	case ExceptionType::CONSTRAINT:
+		return DUCKDB_ERROR_CONSTRAINT;
+	case ExceptionType::INDEX:
+		return DUCKDB_ERROR_INDEX;
+	case ExceptionType::STAT:
+		return DUCKDB_ERROR_STAT;
+	case ExceptionType::CONNECTION:
+		return DUCKDB_ERROR_CONNECTION;
+	case ExceptionType::SYNTAX:
+		return DUCKDB_ERROR_SYNTAX;
+	case ExceptionType::SETTINGS:
+		return DUCKDB_ERROR_SETTINGS;
+	case ExceptionType::BINDER:
+		return DUCKDB_ERROR_BINDER;
+	case ExceptionType::NETWORK:
+		return DUCKDB_ERROR_NETWORK;
+	case ExceptionType::OPTIMIZER:
+		return DUCKDB_ERROR_OPTIMIZER;
+	case ExceptionType::NULL_POINTER:
+		return DUCKDB_ERROR_NULL_POINTER;
+	case ExceptionType::IO:
+		return DUCKDB_ERROR_IO;
+	case ExceptionType::INTERRUPT:
+		return DUCKDB_ERROR_INTERRUPT;
+	case ExceptionType::FATAL:
+		return DUCKDB_ERROR_FATAL;
+	case ExceptionType::INTERNAL:
+		return DUCKDB_ERROR_INTERNAL;
+	case ExceptionType::INVALID_INPUT:
+		return DUCKDB_ERROR_INVALID_INPUT;
+	case ExceptionType::OUT_OF_MEMORY:
+		return DUCKDB_ERROR_OUT_OF_MEMORY;
+	case ExceptionType::PERMISSION:
+		return DUCKDB_ERROR_PERMISSION;
+	case ExceptionType::PARAMETER_NOT_RESOLVED:
+		return DUCKDB_ERROR_PARAMETER_NOT_RESOLVED;
+	case ExceptionType::PARAMETER_NOT_ALLOWED:
+		return DUCKDB_ERROR_PARAMETER_NOT_ALLOWED;
+	case ExceptionType::DEPENDENCY:
+		return DUCKDB_ERROR_DEPENDENCY;
+	case ExceptionType::HTTP:
+		return DUCKDB_ERROR_HTTP;
+	case ExceptionType::MISSING_EXTENSION:
+		return DUCKDB_ERROR_MISSING_EXTENSION;
+	case ExceptionType::AUTOLOAD:
+		return DUCKDB_ERROR_AUTOLOAD;
+	case ExceptionType::SEQUENCE:
+		return DUCKDB_ERROR_SEQUENCE;
+	case ExceptionType::INVALID_CONFIGURATION:
+		return DUCKDB_INVALID_CONFIGURATION;
+	default:
+		return DUCKDB_ERROR_INVALID;
+	}
+}
+
+ExceptionType ErrorTypeFromC(const duckdb_error_type type) {
+	switch (type) {
+	case DUCKDB_ERROR_INVALID:
+		return ExceptionType::INVALID;
+	case DUCKDB_ERROR_OUT_OF_RANGE:
+		return ExceptionType::OUT_OF_RANGE;
+	case DUCKDB_ERROR_CONVERSION:
+		return ExceptionType::CONVERSION;
+	case DUCKDB_ERROR_UNKNOWN_TYPE:
+		return ExceptionType::UNKNOWN_TYPE;
+	case DUCKDB_ERROR_DECIMAL:
+		return ExceptionType::DECIMAL;
+	case DUCKDB_ERROR_MISMATCH_TYPE:
+		return ExceptionType::MISMATCH_TYPE;
+	case DUCKDB_ERROR_DIVIDE_BY_ZERO:
+		return ExceptionType::DIVIDE_BY_ZERO;
+	case DUCKDB_ERROR_OBJECT_SIZE:
+		return ExceptionType::OBJECT_SIZE;
+	case DUCKDB_ERROR_INVALID_TYPE:
+		return ExceptionType::INVALID_TYPE;
+	case DUCKDB_ERROR_SERIALIZATION:
+		return ExceptionType::SERIALIZATION;
+	case DUCKDB_ERROR_TRANSACTION:
+		return ExceptionType::TRANSACTION;
+	case DUCKDB_ERROR_NOT_IMPLEMENTED:
+		return ExceptionType::NOT_IMPLEMENTED;
+	case DUCKDB_ERROR_EXPRESSION:
+		return ExceptionType::EXPRESSION;
+	case DUCKDB_ERROR_CATALOG:
+		return ExceptionType::CATALOG;
+	case DUCKDB_ERROR_PARSER:
+		return ExceptionType::PARSER;
+	case DUCKDB_ERROR_PLANNER:
+		return ExceptionType::PLANNER;
+	case DUCKDB_ERROR_SCHEDULER:
+		return ExceptionType::SCHEDULER;
+	case DUCKDB_ERROR_EXECUTOR:
+		return ExceptionType::EXECUTOR;
+	case DUCKDB_ERROR_CONSTRAINT:
+		return ExceptionType::CONSTRAINT;
+	case DUCKDB_ERROR_INDEX:
+		return ExceptionType::INDEX;
+	case DUCKDB_ERROR_STAT:
+		return ExceptionType::STAT;
+	case DUCKDB_ERROR_CONNECTION:
+		return ExceptionType::CONNECTION;
+	case DUCKDB_ERROR_SYNTAX:
+		return ExceptionType::SYNTAX;
+	case DUCKDB_ERROR_SETTINGS:
+		return ExceptionType::SETTINGS;
+	case DUCKDB_ERROR_BINDER:
+		return ExceptionType::BINDER;
+	case DUCKDB_ERROR_NETWORK:
+		return ExceptionType::NETWORK;
+	case DUCKDB_ERROR_OPTIMIZER:
+		return ExceptionType::OPTIMIZER;
+	case DUCKDB_ERROR_NULL_POINTER:
+		return ExceptionType::NULL_POINTER;
+	case DUCKDB_ERROR_IO:
+		return ExceptionType::IO;
+	case DUCKDB_ERROR_INTERRUPT:
+		return ExceptionType::INTERRUPT;
+	case DUCKDB_ERROR_FATAL:
+		return ExceptionType::FATAL;
+	case DUCKDB_ERROR_INTERNAL:
+		return ExceptionType::INTERNAL;
+	case DUCKDB_ERROR_INVALID_INPUT:
+		return ExceptionType::INVALID_INPUT;
+	case DUCKDB_ERROR_OUT_OF_MEMORY:
+		return ExceptionType::OUT_OF_MEMORY;
+	case DUCKDB_ERROR_PERMISSION:
+		return ExceptionType::PERMISSION;
+	case DUCKDB_ERROR_PARAMETER_NOT_RESOLVED:
+		return ExceptionType::PARAMETER_NOT_RESOLVED;
+	case DUCKDB_ERROR_PARAMETER_NOT_ALLOWED:
+		return ExceptionType::PARAMETER_NOT_ALLOWED;
+	case DUCKDB_ERROR_DEPENDENCY:
+		return ExceptionType::DEPENDENCY;
+	case DUCKDB_ERROR_HTTP:
+		return ExceptionType::HTTP;
+	case DUCKDB_ERROR_MISSING_EXTENSION:
+		return ExceptionType::MISSING_EXTENSION;
+	case DUCKDB_ERROR_AUTOLOAD:
+		return ExceptionType::AUTOLOAD;
+	case DUCKDB_ERROR_SEQUENCE:
+		return ExceptionType::SEQUENCE;
+	case DUCKDB_INVALID_CONFIGURATION:
+		return ExceptionType::INVALID_CONFIGURATION;
+	default:
+		return ExceptionType::INVALID;
+	}
+}
+
 } // namespace duckdb
 
 void *duckdb_malloc(size_t size) {

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

@@ -41,17 +41,21 @@ duckdb_logical_type duckdb_create_logical_type(duckdb_type type) {
 		type = DUCKDB_TYPE_INVALID;
 	}
 
-	auto cpp_type = duckdb::ConvertCTypeToCPP(type);
-	return reinterpret_cast<duckdb_logical_type>(new duckdb::LogicalType(cpp_type));
+	auto type_id = duckdb::LogicalTypeIdFromC(type);
+	return reinterpret_cast<duckdb_logical_type>(new duckdb::LogicalType(type_id));
 }
 
 duckdb_logical_type duckdb_create_list_type(duckdb_logical_type type) {
 	if (!type) {
 		return nullptr;
 	}
-	duckdb::LogicalType *logical_type = new duckdb::LogicalType;
-	*logical_type = duckdb::LogicalType::LIST(*reinterpret_cast<duckdb::LogicalType *>(type));
-	return reinterpret_cast<duckdb_logical_type>(logical_type);
+	try {
+		duckdb::LogicalType *logical_type =
+		    new duckdb::LogicalType(duckdb::LogicalType::LIST(*reinterpret_cast<duckdb::LogicalType *>(type)));
+		return reinterpret_cast<duckdb_logical_type>(logical_type);
+	} catch (...) {
+		return nullptr;
+	}
 }
 
 duckdb_logical_type duckdb_create_array_type(duckdb_logical_type type, idx_t array_size) {
@@ -61,9 +65,13 @@ duckdb_logical_type duckdb_create_array_type(duckdb_logical_type type, idx_t arr
 	if (array_size >= duckdb::ArrayType::MAX_ARRAY_SIZE) {
 		return nullptr;
 	}
-	duckdb::LogicalType *ltype = new duckdb::LogicalType;
-	*ltype = duckdb::LogicalType::ARRAY(*reinterpret_cast<duckdb::LogicalType *>(type), array_size);
-	return reinterpret_cast<duckdb_logical_type>(ltype);
+	try {
+		duckdb::LogicalType *ltype = new duckdb::LogicalType(
+		    duckdb::LogicalType::ARRAY(*reinterpret_cast<duckdb::LogicalType *>(type), array_size));
+		return reinterpret_cast<duckdb_logical_type>(ltype);
+	} catch (...) {
+		return nullptr;
+	}
 }
 
 duckdb_logical_type duckdb_create_union_type(duckdb_logical_type *member_types_p, const char **member_names,
@@ -72,14 +80,17 @@ duckdb_logical_type duckdb_create_union_type(duckdb_logical_type *member_types_p
 		return nullptr;
 	}
 	duckdb::LogicalType **member_types = reinterpret_cast<duckdb::LogicalType **>(member_types_p);
-	duckdb::LogicalType *mtype = new duckdb::LogicalType;
-	duckdb::child_list_t<duckdb::LogicalType> members;
+	try {
+		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]));
+		for (idx_t i = 0; i < member_count; i++) {
+			members.push_back(make_pair(member_names[i], *member_types[i]));
+		}
+		duckdb::LogicalType *mtype = new duckdb::LogicalType(duckdb::LogicalType::UNION(members));
+		return reinterpret_cast<duckdb_logical_type>(mtype);
+	} catch (...) {
+		return nullptr;
 	}
-	*mtype = duckdb::LogicalType::UNION(members);
-	return reinterpret_cast<duckdb_logical_type>(mtype);
 }
 
 duckdb_logical_type duckdb_create_struct_type(duckdb_logical_type *member_types_p, const char **member_names,
@@ -94,14 +105,17 @@ duckdb_logical_type duckdb_create_struct_type(duckdb_logical_type *member_types_
 		}
 	}
 
-	duckdb::LogicalType *mtype = new duckdb::LogicalType;
-	duckdb::child_list_t<duckdb::LogicalType> members;
+	try {
+		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]));
+		for (idx_t i = 0; i < member_count; i++) {
+			members.push_back(make_pair(member_names[i], *member_types[i]));
+		}
+		duckdb::LogicalType *mtype = new duckdb::LogicalType(duckdb::LogicalType::STRUCT(members));
+		return reinterpret_cast<duckdb_logical_type>(mtype);
+	} catch (...) {
+		return nullptr;
 	}
-	*mtype = duckdb::LogicalType::STRUCT(members);
-	return reinterpret_cast<duckdb_logical_type>(mtype);
 }
 
 duckdb_logical_type duckdb_create_enum_type(const char **member_names, idx_t member_count) {
@@ -118,19 +132,25 @@ duckdb_logical_type duckdb_create_enum_type(const char **member_names, idx_t mem
 		enum_vector_ptr[i] = duckdb::StringVector::AddStringOrBlob(enum_vector, member_names[i]);
 	}
 
-	duckdb::LogicalType *mtype = new duckdb::LogicalType;
-	*mtype = duckdb::LogicalType::ENUM(enum_vector, member_count);
-	return reinterpret_cast<duckdb_logical_type>(mtype);
+	try {
+		duckdb::LogicalType *mtype = new duckdb::LogicalType(duckdb::LogicalType::ENUM(enum_vector, member_count));
+		return reinterpret_cast<duckdb_logical_type>(mtype);
+	} catch (...) {
+		return nullptr;
+	}
 }
 
 duckdb_logical_type duckdb_create_map_type(duckdb_logical_type key_type, duckdb_logical_type value_type) {
 	if (!key_type || !value_type) {
 		return nullptr;
 	}
-	duckdb::LogicalType *mtype = new duckdb::LogicalType;
-	*mtype = duckdb::LogicalType::MAP(*reinterpret_cast<duckdb::LogicalType *>(key_type),
-	                                  *reinterpret_cast<duckdb::LogicalType *>(value_type));
-	return reinterpret_cast<duckdb_logical_type>(mtype);
+	try {
+		duckdb::LogicalType *mtype = new duckdb::LogicalType(duckdb::LogicalType::MAP(
+		    *reinterpret_cast<duckdb::LogicalType *>(key_type), *reinterpret_cast<duckdb::LogicalType *>(value_type)));
+		return reinterpret_cast<duckdb_logical_type>(mtype);
+	} catch (...) {
+		return nullptr;
+	}
 }
 
 duckdb_logical_type duckdb_create_decimal_type(uint8_t width, uint8_t scale) {
@@ -142,7 +162,7 @@ duckdb_type duckdb_get_type_id(duckdb_logical_type type) {
 		return DUCKDB_TYPE_INVALID;
 	}
 	auto logical_type = reinterpret_cast<duckdb::LogicalType *>(type);
-	return duckdb::ConvertCPPTypeToC(*logical_type);
+	return duckdb::LogicalTypeIdToC(logical_type->id());
 }
 
 void duckdb_destroy_logical_type(duckdb_logical_type *type) {