duckdb 1.0.1-dev21.0 → 1.0.1-dev27.0

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

@@ -126,7 +126,7 @@ struct CDecimalConverter : public CBaseConverter {
 template <class SRC, class DST = SRC, class OP = CStandardConverter>
 void WriteData(duckdb_column *column, ColumnDataCollection &source, const vector<column_t> &column_ids) {
 	idx_t row = 0;
-	auto target = (DST *)column->__deprecated_data;
+	auto target = (DST *)column->deprecated_data;
 	for (auto &input : source.Chunks(column_ids)) {
 		auto source = FlatVector::GetData<SRC>(input.data[0]);
 		auto &mask = FlatVector::Validity(input.data[0]);
@@ -145,20 +145,20 @@ duckdb_state deprecated_duckdb_translate_column(MaterializedQueryResult &result,
 	D_ASSERT(!result.HasError());
 	auto &collection = result.Collection();
 	idx_t row_count = collection.Count();
-	column->__deprecated_nullmask = (bool *)duckdb_malloc(sizeof(bool) * collection.Count());
+	column->deprecated_nullmask = (bool *)duckdb_malloc(sizeof(bool) * collection.Count());
 
-	auto type_size = GetCTypeSize(column->__deprecated_type);
+	auto type_size = GetCTypeSize(column->deprecated_type);
 	if (type_size == 0) {
 		for (idx_t row_id = 0; row_id < row_count; row_id++) {
-			column->__deprecated_nullmask[row_id] = false;
+			column->deprecated_nullmask[row_id] = false;
 		}
 		// Unsupported type, e.g., a LIST. By returning DuckDBSuccess here,
 		// we allow filling other columns, and return NULL for all unsupported types.
 		return DuckDBSuccess;
 	}
 
-	column->__deprecated_data = duckdb_malloc(type_size * row_count);
-	if (!column->__deprecated_nullmask || !column->__deprecated_data) { // LCOV_EXCL_START
+	column->deprecated_data = duckdb_malloc(type_size * row_count);
+	if (!column->deprecated_nullmask || !column->deprecated_data) { // LCOV_EXCL_START
 		// malloc failure
 		return DuckDBError;
 	} // LCOV_EXCL_STOP
@@ -169,7 +169,7 @@ duckdb_state deprecated_duckdb_translate_column(MaterializedQueryResult &result,
 		idx_t row = 0;
 		for (auto &input : collection.Chunks(column_ids)) {
 			for (idx_t k = 0; k < input.size(); k++) {
-				column->__deprecated_nullmask[row++] = FlatVector::IsNull(input.data[0], k);
+				column->deprecated_nullmask[row++] = FlatVector::IsNull(input.data[0], k);
 			}
 		}
 	}
@@ -302,13 +302,13 @@ duckdb_state DuckDBTranslateResult(unique_ptr<QueryResult> result_p, duckdb_resu
 
 	if (result.HasError()) {
 		// write the error message
-		out->__deprecated_error_message = (char *)result.GetError().c_str(); // NOLINT
+		out->deprecated_error_message = (char *)result.GetError().c_str(); // NOLINT
 		return DuckDBError;
 	}
 	// copy the data
 	// first write the metadata
-	out->__deprecated_column_count = result.ColumnCount();
-	out->__deprecated_rows_changed = 0;
+	out->deprecated_column_count = result.ColumnCount();
+	out->deprecated_rows_changed = 0;
 	return DuckDBSuccess;
 }
 
@@ -335,8 +335,8 @@ bool DeprecatedMaterializeResult(duckdb_result *result) {
 	// materialize as deprecated result set
 	result_data->result_set_type = CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED;
 	auto column_count = result_data->result->ColumnCount();
-	result->__deprecated_columns = (duckdb_column *)duckdb_malloc(sizeof(duckdb_column) * column_count);
-	if (!result->__deprecated_columns) { // LCOV_EXCL_START
+	result->deprecated_columns = (duckdb_column *)duckdb_malloc(sizeof(duckdb_column) * column_count);
+	if (!result->deprecated_columns) { // LCOV_EXCL_START
 		// malloc failure
 		return DuckDBError;
 	} // LCOV_EXCL_STOP
@@ -351,25 +351,24 @@ bool DeprecatedMaterializeResult(duckdb_result *result) {
 
 	// convert the result to a materialized result
 	// zero initialize the columns (so we can cleanly delete it in case a malloc fails)
-	memset(result->__deprecated_columns, 0, sizeof(duckdb_column) * column_count);
+	memset(result->deprecated_columns, 0, sizeof(duckdb_column) * column_count);
 	for (idx_t i = 0; i < column_count; i++) {
-		result->__deprecated_columns[i].__deprecated_type = ConvertCPPTypeToC(result_data->result->types[i]);
-		result->__deprecated_columns[i].__deprecated_name = (char *)result_data->result->names[i].c_str(); // NOLINT
+		result->deprecated_columns[i].deprecated_type = ConvertCPPTypeToC(result_data->result->types[i]);
+		result->deprecated_columns[i].deprecated_name = (char *)result_data->result->names[i].c_str(); // NOLINT
 	}
 
-	result->__deprecated_row_count = materialized.RowCount();
-	if (result->__deprecated_row_count > 0 &&
-	    materialized.properties.return_type == StatementReturnType::CHANGED_ROWS) {
+	result->deprecated_row_count = materialized.RowCount();
+	if (result->deprecated_row_count > 0 && materialized.properties.return_type == StatementReturnType::CHANGED_ROWS) {
 		// update total changes
 		auto row_changes = materialized.GetValue(0, 0);
 		if (!row_changes.IsNull() && row_changes.DefaultTryCastAs(LogicalType::BIGINT)) {
-			result->__deprecated_rows_changed = NumericCast<idx_t>(row_changes.GetValue<int64_t>());
+			result->deprecated_rows_changed = NumericCast<idx_t>(row_changes.GetValue<int64_t>());
 		}
 	}
 
 	// Now write the data and skip any unsupported columns.
 	for (idx_t col = 0; col < column_count; col++) {
-		auto state = deprecated_duckdb_translate_column(materialized, &result->__deprecated_columns[col], col);
+		auto state = deprecated_duckdb_translate_column(materialized, &result->deprecated_columns[col], col);
 		if (state != DuckDBSuccess) {
 			return false;
 		}
@@ -377,40 +376,132 @@ bool DeprecatedMaterializeResult(duckdb_result *result) {
 	return true;
 }
 
+duckdb_error_type CAPIErrorType(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;
+	}
+	return DUCKDB_ERROR_INVALID;
+}
+
 } // namespace duckdb
 
 static void DuckdbDestroyColumn(duckdb_column column, idx_t count) {
-	if (column.__deprecated_data) {
-		if (column.__deprecated_type == DUCKDB_TYPE_VARCHAR) {
+	if (column.deprecated_data) {
+		if (column.deprecated_type == DUCKDB_TYPE_VARCHAR) {
 			// varchar, delete individual strings
-			auto data = reinterpret_cast<char **>(column.__deprecated_data);
+			auto data = reinterpret_cast<char **>(column.deprecated_data);
 			for (idx_t i = 0; i < count; i++) {
 				if (data[i]) {
 					duckdb_free(data[i]);
 				}
 			}
-		} else if (column.__deprecated_type == DUCKDB_TYPE_BLOB) {
+		} else if (column.deprecated_type == DUCKDB_TYPE_BLOB) {
 			// blob, delete individual blobs
-			auto data = reinterpret_cast<duckdb_blob *>(column.__deprecated_data);
+			auto data = reinterpret_cast<duckdb_blob *>(column.deprecated_data);
 			for (idx_t i = 0; i < count; i++) {
 				if (data[i].data) {
 					duckdb_free((void *)data[i].data);
 				}
 			}
 		}
-		duckdb_free(column.__deprecated_data);
+		duckdb_free(column.deprecated_data);
 	}
-	if (column.__deprecated_nullmask) {
-		duckdb_free(column.__deprecated_nullmask);
+	if (column.deprecated_nullmask) {
+		duckdb_free(column.deprecated_nullmask);
 	}
 }
 
 void duckdb_destroy_result(duckdb_result *result) {
-	if (result->__deprecated_columns) {
-		for (idx_t i = 0; i < result->__deprecated_column_count; i++) {
-			DuckdbDestroyColumn(result->__deprecated_columns[i], result->__deprecated_row_count);
+	if (result->deprecated_columns) {
+		for (idx_t i = 0; i < result->deprecated_column_count; i++) {
+			DuckdbDestroyColumn(result->deprecated_columns[i], result->deprecated_row_count);
 		}
-		duckdb_free(result->__deprecated_columns);
+		duckdb_free(result->deprecated_columns);
 	}
 	if (result->internal_data) {
 		auto result_data = reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data);
@@ -471,7 +562,7 @@ idx_t duckdb_rows_changed(duckdb_result *result) {
 	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data));
 	if (result_data.result_set_type == duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED) {
 		// not a materialized result
-		return result->__deprecated_rows_changed;
+		return result->deprecated_rows_changed;
 	}
 	auto &materialized = reinterpret_cast<duckdb::MaterializedQueryResult &>(*result_data.result);
 	if (materialized.properties.return_type != duckdb::StatementReturnType::CHANGED_ROWS) {
@@ -486,23 +577,23 @@ idx_t duckdb_rows_changed(duckdb_result *result) {
 }
 
 void *duckdb_column_data(duckdb_result *result, idx_t col) {
-	if (!result || col >= result->__deprecated_column_count) {
+	if (!result || col >= result->deprecated_column_count) {
 		return nullptr;
 	}
 	if (!duckdb::DeprecatedMaterializeResult(result)) {
 		return nullptr;
 	}
-	return result->__deprecated_columns[col].__deprecated_data;
+	return result->deprecated_columns[col].deprecated_data;
 }
 
 bool *duckdb_nullmask_data(duckdb_result *result, idx_t col) {
-	if (!result || col >= result->__deprecated_column_count) {
+	if (!result || col >= result->deprecated_column_count) {
 		return nullptr;
 	}
 	if (!duckdb::DeprecatedMaterializeResult(result)) {
 		return nullptr;
 	}
-	return result->__deprecated_columns[col].__deprecated_nullmask;
+	return result->deprecated_columns[col].deprecated_nullmask;
 }
 
 const char *duckdb_result_error(duckdb_result *result) {
@@ -513,6 +604,17 @@ const char *duckdb_result_error(duckdb_result *result) {
 	return !result_data.result->HasError() ? nullptr : result_data.result->GetError().c_str();
 }
 
+duckdb_error_type duckdb_result_error_type(duckdb_result *result) {
+	if (!result || !result->internal_data) {
+		return DUCKDB_ERROR_INVALID;
+	}
+	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data));
+	if (!result_data.result->HasError()) {
+		return DUCKDB_ERROR_INVALID;
+	}
+	return duckdb::CAPIErrorType(result_data.result->GetErrorType());
+}
+
 idx_t duckdb_result_chunk_count(duckdb_result result) {
 	if (!result.internal_data) {
 		return 0;

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

@@ -0,0 +1,269 @@
+#include "duckdb/catalog/catalog.hpp"
+#include "duckdb/common/type_visitor.hpp"
+#include "duckdb/common/types.hpp"
+#include "duckdb/function/function.hpp"
+#include "duckdb/function/scalar_function.hpp"
+#include "duckdb/main/capi/capi_internal.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
+#include "duckdb/planner/expression/bound_function_expression.hpp"
+
+namespace duckdb {
+
+struct CScalarFunctionInfo : public ScalarFunctionInfo {
+	~CScalarFunctionInfo() override {
+		if (extra_info && delete_callback) {
+			delete_callback(extra_info);
+		}
+		extra_info = nullptr;
+		delete_callback = nullptr;
+	}
+
+	duckdb_scalar_function_t function = nullptr;
+	duckdb_function_info extra_info = nullptr;
+	duckdb_delete_callback_t delete_callback = nullptr;
+};
+
+struct CScalarExecuteInfo {
+	explicit CScalarExecuteInfo(CScalarFunctionInfo &info) : info(info) {
+	}
+
+	CScalarFunctionInfo &info;
+	bool success = true;
+	string error;
+};
+
+struct CScalarFunctionBindData : public FunctionData {
+	explicit CScalarFunctionBindData(CScalarFunctionInfo &info) : info(info) {
+	}
+
+	unique_ptr<FunctionData> Copy() const override {
+		return make_uniq<CScalarFunctionBindData>(info);
+	}
+	bool Equals(const FunctionData &other_p) const override {
+		auto &other = other_p.Cast<CScalarFunctionBindData>();
+		return info.extra_info == other.info.extra_info && info.function == other.info.function;
+	}
+
+	CScalarFunctionInfo &info;
+};
+
+duckdb::ScalarFunction &GetCScalarFunction(duckdb_scalar_function function) {
+	return *reinterpret_cast<duckdb::ScalarFunction *>(function);
+}
+
+duckdb::ScalarFunctionSet &GetCScalarFunctionSet(duckdb_scalar_function_set set) {
+	return *reinterpret_cast<duckdb::ScalarFunctionSet *>(set);
+}
+
+unique_ptr<FunctionData> BindCAPIScalarFunction(ClientContext &, ScalarFunction &bound_function,
+                                                vector<unique_ptr<Expression>> &arguments) {
+	auto &info = bound_function.function_info->Cast<CScalarFunctionInfo>();
+	return make_uniq<CScalarFunctionBindData>(info);
+}
+
+void CAPIScalarFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+	auto &function = state.expr.Cast<BoundFunctionExpression>();
+	auto &bind_info = function.bind_info;
+	auto &c_bind_info = bind_info->Cast<CScalarFunctionBindData>();
+
+	auto all_const = input.AllConstant();
+	input.Flatten();
+	auto c_input = reinterpret_cast<duckdb_data_chunk>(&input);
+	auto c_result = reinterpret_cast<duckdb_vector>(&result);
+
+	CScalarExecuteInfo exec_info(c_bind_info.info);
+	auto c_function_info = reinterpret_cast<duckdb_function_info>(&exec_info);
+	c_bind_info.info.function(c_function_info, c_input, c_result);
+	if (!exec_info.success) {
+		throw InvalidInputException(exec_info.error);
+	}
+	if (all_const && (input.size() == 1 || function.function.stability != FunctionStability::VOLATILE)) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+}
+
+} // namespace duckdb
+
+using duckdb::GetCScalarFunction;
+using duckdb::GetCScalarFunctionSet;
+
+duckdb_scalar_function duckdb_create_scalar_function() {
+	auto function = new duckdb::ScalarFunction("", {}, duckdb::LogicalType::INVALID, duckdb::CAPIScalarFunction,
+	                                           duckdb::BindCAPIScalarFunction);
+	function->function_info = duckdb::make_shared_ptr<duckdb::CScalarFunctionInfo>();
+	return reinterpret_cast<duckdb_scalar_function>(function);
+}
+
+void duckdb_destroy_scalar_function(duckdb_scalar_function *function) {
+	if (function && *function) {
+		auto scalar_function = reinterpret_cast<duckdb::ScalarFunction *>(*function);
+		delete scalar_function;
+		*function = nullptr;
+	}
+}
+
+void duckdb_scalar_function_set_name(duckdb_scalar_function function, const char *name) {
+	if (!function || !name) {
+		return;
+	}
+	auto &scalar_function = GetCScalarFunction(function);
+	scalar_function.name = name;
+}
+
+void duckdb_scalar_function_set_varargs(duckdb_scalar_function function, duckdb_logical_type type) {
+	if (!function || !type) {
+		return;
+	}
+	auto &scalar_function = GetCScalarFunction(function);
+	auto logical_type = reinterpret_cast<duckdb::LogicalType *>(type);
+	scalar_function.varargs = *logical_type;
+}
+
+void duckdb_scalar_function_set_special_handling(duckdb_scalar_function function) {
+	if (!function) {
+		return;
+	}
+	auto &scalar_function = GetCScalarFunction(function);
+	scalar_function.null_handling = duckdb::FunctionNullHandling::SPECIAL_HANDLING;
+}
+
+void duckdb_scalar_function_set_volatile(duckdb_scalar_function function) {
+	if (!function) {
+		return;
+	}
+	auto &scalar_function = GetCScalarFunction(function);
+	scalar_function.stability = duckdb::FunctionStability::VOLATILE;
+}
+
+void duckdb_scalar_function_add_parameter(duckdb_scalar_function function, duckdb_logical_type type) {
+	if (!function || !type) {
+		return;
+	}
+	auto &scalar_function = GetCScalarFunction(function);
+	auto logical_type = reinterpret_cast<duckdb::LogicalType *>(type);
+	scalar_function.arguments.push_back(*logical_type);
+}
+
+void duckdb_scalar_function_set_return_type(duckdb_scalar_function function, duckdb_logical_type type) {
+	if (!function || !type) {
+		return;
+	}
+	auto &scalar_function = GetCScalarFunction(function);
+	auto logical_type = reinterpret_cast<duckdb::LogicalType *>(type);
+	scalar_function.return_type = *logical_type;
+}
+
+duckdb::CScalarExecuteInfo &GetCScalarExecInfo(duckdb_function_info info) {
+	D_ASSERT(info);
+	return *reinterpret_cast<duckdb::CScalarExecuteInfo *>(info);
+}
+
+void *duckdb_scalar_function_get_extra_info(duckdb_function_info info) {
+	if (!info) {
+		return nullptr;
+	}
+	auto &scalar_function = GetCScalarExecInfo(info);
+	return scalar_function.info.extra_info;
+}
+
+void duckdb_scalar_function_set_error(duckdb_function_info info, const char *error) {
+	if (!info || !error) {
+		return;
+	}
+	auto &scalar_function = GetCScalarExecInfo(info);
+	scalar_function.error = error;
+	scalar_function.success = false;
+}
+
+void duckdb_scalar_function_set_extra_info(duckdb_scalar_function function, void *extra_info,
+                                           duckdb_delete_callback_t destroy) {
+	if (!function || !extra_info) {
+		return;
+	}
+	auto &scalar_function = GetCScalarFunction(function);
+	auto &info = scalar_function.function_info->Cast<duckdb::CScalarFunctionInfo>();
+	info.extra_info = reinterpret_cast<duckdb_function_info>(extra_info);
+	info.delete_callback = destroy;
+}
+
+void duckdb_scalar_function_set_function(duckdb_scalar_function function, duckdb_scalar_function_t execute_func) {
+	if (!function || !execute_func) {
+		return;
+	}
+	auto &scalar_function = GetCScalarFunction(function);
+	auto &info = scalar_function.function_info->Cast<duckdb::CScalarFunctionInfo>();
+	info.function = execute_func;
+}
+
+duckdb_state duckdb_register_scalar_function(duckdb_connection connection, duckdb_scalar_function function) {
+	if (!connection || !function) {
+		return DuckDBError;
+	}
+	auto &scalar_function = GetCScalarFunction(function);
+	duckdb::ScalarFunctionSet set(scalar_function.name);
+	set.AddFunction(scalar_function);
+	return duckdb_register_scalar_function_set(connection, reinterpret_cast<duckdb_scalar_function_set>(&set));
+}
+
+duckdb_scalar_function_set duckdb_create_scalar_function_set(const char *name) {
+	if (!name || !*name) {
+		return nullptr;
+	}
+	auto function = new duckdb::ScalarFunctionSet(name);
+	return reinterpret_cast<duckdb_scalar_function_set>(function);
+}
+
+void duckdb_destroy_scalar_function_set(duckdb_scalar_function_set *set) {
+	if (set && *set) {
+		auto scalar_function_set = reinterpret_cast<duckdb::ScalarFunctionSet *>(*set);
+		delete scalar_function_set;
+		*set = nullptr;
+	}
+}
+
+duckdb_state duckdb_add_scalar_function_to_set(duckdb_scalar_function_set set, duckdb_scalar_function function) {
+	if (!set || !function) {
+		return DuckDBError;
+	}
+	auto &scalar_function_set = GetCScalarFunctionSet(set);
+	auto &scalar_function = GetCScalarFunction(function);
+	scalar_function_set.AddFunction(scalar_function);
+	return DuckDBSuccess;
+}
+
+duckdb_state duckdb_register_scalar_function_set(duckdb_connection connection, duckdb_scalar_function_set set) {
+	if (!connection || !set) {
+		return DuckDBError;
+	}
+	auto &scalar_function_set = GetCScalarFunctionSet(set);
+	for (idx_t idx = 0; idx < scalar_function_set.Size(); idx++) {
+		auto &scalar_function = scalar_function_set.GetFunctionReferenceByOffset(idx);
+		auto &info = scalar_function.function_info->Cast<duckdb::CScalarFunctionInfo>();
+
+		if (scalar_function.name.empty() || !info.function) {
+			return DuckDBError;
+		}
+		if (duckdb::TypeVisitor::Contains(scalar_function.return_type, duckdb::LogicalTypeId::INVALID) ||
+		    duckdb::TypeVisitor::Contains(scalar_function.return_type, duckdb::LogicalTypeId::ANY)) {
+			return DuckDBError;
+		}
+		for (const auto &argument : scalar_function.arguments) {
+			if (duckdb::TypeVisitor::Contains(argument, duckdb::LogicalTypeId::INVALID)) {
+				return DuckDBError;
+			}
+		}
+	}
+
+	try {
+		auto con = reinterpret_cast<duckdb::Connection *>(connection);
+		con->context->RunFunctionInTransaction([&]() {
+			auto &catalog = duckdb::Catalog::GetSystemCatalog(*con->context);
+			duckdb::CreateScalarFunctionInfo sf_info(scalar_function_set);
+			catalog.CreateFunction(*con->context, sf_info);
+		});
+	} catch (...) {
+		return DuckDBError;
+	}
+	return DuckDBSuccess;
+}

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

@@ -0,0 +1,82 @@
+#include "duckdb/main/capi/capi_internal.hpp"
+#include "duckdb/common/string_util.hpp"
+
+using duckdb::Connection;
+using duckdb::ErrorData;
+using duckdb::TableDescription;
+using duckdb::TableDescriptionWrapper;
+
+duckdb_state duckdb_table_description_create(duckdb_connection connection, const char *schema, const char *table,
+                                             duckdb_table_description *out) {
+	Connection *conn = reinterpret_cast<Connection *>(connection);
+
+	if (!out) {
+		return DuckDBError;
+	}
+	auto wrapper = new TableDescriptionWrapper();
+	*out = (duckdb_table_description)wrapper;
+
+	if (!connection || !table) {
+		return DuckDBError;
+	}
+
+	if (schema == nullptr) {
+		schema = DEFAULT_SCHEMA;
+	}
+
+	try {
+		wrapper->description = conn->TableInfo(schema, table);
+	} catch (std::exception &ex) {
+		ErrorData error(ex);
+		wrapper->error = error.RawMessage();
+		return DuckDBError;
+	} catch (...) { // LCOV_EXCL_START
+		wrapper->error = "Unknown Connection::TableInfo error";
+		return DuckDBError;
+	} // LCOV_EXCL_STOP
+	if (!wrapper->description) {
+		wrapper->error = "No table with that schema+name could be located";
+		return DuckDBError;
+	}
+	return DuckDBSuccess;
+}
+
+void duckdb_table_description_destroy(duckdb_table_description *table) {
+	if (!table || !*table) {
+		return;
+	}
+	auto wrapper = reinterpret_cast<TableDescriptionWrapper *>(*table);
+	delete wrapper;
+	*table = nullptr;
+}
+
+const char *duckdb_table_description_error(duckdb_table_description table) {
+	if (!table) {
+		return nullptr;
+	}
+	auto wrapper = reinterpret_cast<TableDescriptionWrapper *>(table);
+	if (wrapper->error.empty()) {
+		return nullptr;
+	}
+	return wrapper->error.c_str();
+}
+
+duckdb_state duckdb_column_has_default(duckdb_table_description table_description, idx_t index, bool *out) {
+	auto wrapper = reinterpret_cast<TableDescriptionWrapper *>(table_description);
+	if (!wrapper || !out) {
+		if (wrapper) {
+			wrapper->error = "Please provide a valid (non-null) 'out' variable";
+		}
+		return DuckDBError;
+	}
+
+	auto &table = wrapper->description;
+	if (index >= table->columns.size()) {
+		wrapper->error = duckdb::StringUtil::Format("Column index %d is out of range, table only has %d columns", index,
+		                                            table->columns.size());
+		return DuckDBError;
+	}
+	auto &column = table->columns[index];
+	*out = column.HasDefaultValue();
+	return DuckDBSuccess;
+}