duckdb 0.5.2-dev1545.0 → 0.5.2-dev1579.0

package/src/duckdb.cpp

@@ -24035,7 +24035,7 @@ bool TryCastFromDecimal::Operation(hugeint_t input, double &result, string *erro
                                    uint8_t scale);
 
 //===--------------------------------------------------------------------===//
-// Cast Decimal -> VARCHAR
+// Cast Decimal <-> VARCHAR
 //===--------------------------------------------------------------------===//
 template <>
 DUCKDB_API bool TryCastToDecimal::Operation(string_t input, int16_t &result, string *error_message, uint8_t width,
@@ -45527,6 +45527,12 @@ bool Hugeint::TryConvert(uint64_t value, hugeint_t &result) {
 	return true;
 }
 
+template <>
+bool Hugeint::TryConvert(hugeint_t value, hugeint_t &result) {
+	result = value;
+	return true;
+}
+
 template <>
 bool Hugeint::TryConvert(float value, hugeint_t &result) {
 	return Hugeint::TryConvert(double(value), result);
@@ -111076,14 +111082,18 @@ namespace duckdb {
 static void CardinalityFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &map = args.data[0];
 	UnifiedVectorFormat list_data;
+	UnifiedVectorFormat map_data;
 	result.SetVectorType(VectorType::FLAT_VECTOR);
 	auto result_data = FlatVector::GetData<uint64_t>(result);
+	auto &result_validity = FlatVector::Validity(result);
 
+	map.ToUnifiedFormat(args.size(), map_data);
 	auto &children = StructVector::GetEntries(map);
 	children[0]->ToUnifiedFormat(args.size(), list_data);
 	for (idx_t row = 0; row < args.size(); row++) {
 		auto list_entry = ((list_entry_t *)list_data.data)[list_data.sel->get_index(row)];
 		result_data[row] = list_entry.length;
+		result_validity.Set(row, map_data.validity.RowIsValid(map_data.sel->get_index(row)));
 	}
 
 	if (args.size() == 1) {
@@ -111093,6 +111103,9 @@ static void CardinalityFunction(DataChunk &args, ExpressionState &state, Vector
 
 static unique_ptr<FunctionData> CardinalityBind(ClientContext &context, ScalarFunction &bound_function,
                                                 vector<unique_ptr<Expression>> &arguments) {
+	if (arguments.size() != 1) {
+		throw BinderException("Cardinality must have exactly one arguments");
+	}
 
 	if (arguments[0]->return_type.id() != LogicalTypeId::MAP) {
 		throw BinderException("Cardinality can only operate on MAPs");
@@ -111105,7 +111118,7 @@ static unique_ptr<FunctionData> CardinalityBind(ClientContext &context, ScalarFu
 void CardinalityFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunction fun("cardinality", {LogicalType::ANY}, LogicalType::UBIGINT, CardinalityFunction, CardinalityBind);
 	fun.varargs = LogicalType::ANY;
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+	fun.null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING;
 	set.AddFunction(fun);
 }
 
@@ -129375,7 +129388,7 @@ void BaseAppender::Close() {
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/main/capi_internal.hpp
+// duckdb/main/capi/capi_internal.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -129761,6 +129774,399 @@ duckdb_state duckdb_execute_prepared_arrow(duckdb_prepared_statement prepared_st
 	*out_result = (duckdb_arrow)arrow_wrapper;
 	return !arrow_wrapper->result->HasError() ? DuckDBSuccess : DuckDBError;
 }
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/capi/capi_cast_from_decimal.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/capi/cast/utils.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// Unsafe Fetch (for internal use only)
+//===--------------------------------------------------------------------===//
+template <class T>
+T UnsafeFetchFromPtr(void *pointer) {
+	return *((T *)pointer);
+}
+
+template <class T>
+void *UnsafeFetchPtr(duckdb_result *result, idx_t col, idx_t row) {
+	D_ASSERT(row < result->__deprecated_row_count);
+	return (void *)&(((T *)result->__deprecated_columns[col].__deprecated_data)[row]);
+}
+
+template <class T>
+T UnsafeFetch(duckdb_result *result, idx_t col, idx_t row) {
+	return UnsafeFetchFromPtr<T>(UnsafeFetchPtr<T>(result, col, row));
+}
+
+//===--------------------------------------------------------------------===//
+// Fetch Default Value
+//===--------------------------------------------------------------------===//
+struct FetchDefaultValue {
+	template <class T>
+	static T Operation() {
+		return 0;
+	}
+};
+
+template <>
+duckdb_decimal FetchDefaultValue::Operation();
+template <>
+date_t FetchDefaultValue::Operation();
+template <>
+dtime_t FetchDefaultValue::Operation();
+template <>
+timestamp_t FetchDefaultValue::Operation();
+template <>
+interval_t FetchDefaultValue::Operation();
+template <>
+char *FetchDefaultValue::Operation();
+template <>
+duckdb_blob FetchDefaultValue::Operation();
+
+//===--------------------------------------------------------------------===//
+// String Casts
+//===--------------------------------------------------------------------===//
+template <class OP>
+struct FromCStringCastWrapper {
+	template <class SOURCE_TYPE, class RESULT_TYPE>
+	static bool Operation(SOURCE_TYPE input_str, RESULT_TYPE &result) {
+		string_t input(input_str);
+		return OP::template Operation<string_t, RESULT_TYPE>(input, result);
+	}
+};
+
+template <class OP>
+struct ToCStringCastWrapper {
+	template <class SOURCE_TYPE, class RESULT_TYPE>
+	static bool Operation(SOURCE_TYPE input, RESULT_TYPE &result) {
+		Vector result_vector(LogicalType::VARCHAR, nullptr);
+		auto result_string = OP::template Operation<SOURCE_TYPE>(input, result_vector);
+		auto result_size = result_string.GetSize();
+		auto result_data = result_string.GetDataUnsafe();
+
+		result = (char *)duckdb_malloc(result_size + 1);
+		memcpy(result, result_data, result_size);
+		result[result_size] = '\0';
+		return true;
+	}
+};
+
+//===--------------------------------------------------------------------===//
+// Blob Casts
+//===--------------------------------------------------------------------===//
+struct FromCBlobCastWrapper {
+	template <class SOURCE_TYPE, class RESULT_TYPE>
+	static bool Operation(SOURCE_TYPE input_str, RESULT_TYPE &result) {
+		return false;
+	}
+};
+
+template <>
+bool FromCBlobCastWrapper::Operation(duckdb_blob input, char *&result);
+
+template <class SOURCE_TYPE, class RESULT_TYPE, class OP>
+RESULT_TYPE TryCastCInternal(duckdb_result *result, idx_t col, idx_t row) {
+	RESULT_TYPE result_value;
+	try {
+		if (!OP::template Operation<SOURCE_TYPE, RESULT_TYPE>(UnsafeFetch<SOURCE_TYPE>(result, col, row),
+		                                                      result_value)) {
+			return FetchDefaultValue::Operation<RESULT_TYPE>();
+		}
+	} catch (...) {
+		return FetchDefaultValue::Operation<RESULT_TYPE>();
+	}
+	return result_value;
+}
+
+} // namespace duckdb
+
+bool CanFetchValue(duckdb_result *result, idx_t col, idx_t row);
+bool CanUseDeprecatedFetch(duckdb_result *result, idx_t col, idx_t row);
+
+
+namespace duckdb {
+
+//! DECIMAL -> ?
+template <class RESULT_TYPE>
+bool CastDecimalCInternal(duckdb_result *source, RESULT_TYPE &result, idx_t col, idx_t row) {
+	auto result_data = (duckdb::DuckDBResultData *)source->internal_data;
+	auto &query_result = result_data->result;
+	auto &source_type = query_result->types[col];
+	auto width = duckdb::DecimalType::GetWidth(source_type);
+	auto scale = duckdb::DecimalType::GetScale(source_type);
+	void *source_address = UnsafeFetchPtr<hugeint_t>(source, col, row);
+	switch (source_type.InternalType()) {
+	case duckdb::PhysicalType::INT16:
+		return duckdb::TryCastFromDecimal::Operation<int16_t, RESULT_TYPE>(UnsafeFetchFromPtr<int16_t>(source_address),
+		                                                                   result, nullptr, width, scale);
+	case duckdb::PhysicalType::INT32:
+		return duckdb::TryCastFromDecimal::Operation<int32_t, RESULT_TYPE>(UnsafeFetchFromPtr<int32_t>(source_address),
+		                                                                   result, nullptr, width, scale);
+	case duckdb::PhysicalType::INT64:
+		return duckdb::TryCastFromDecimal::Operation<int64_t, RESULT_TYPE>(UnsafeFetchFromPtr<int64_t>(source_address),
+		                                                                   result, nullptr, width, scale);
+	case duckdb::PhysicalType::INT128:
+		return duckdb::TryCastFromDecimal::Operation<hugeint_t, RESULT_TYPE>(
+		    UnsafeFetchFromPtr<hugeint_t>(source_address), result, nullptr, width, scale);
+	default:
+		throw duckdb::InternalException("Unimplemented internal type for decimal");
+	}
+}
+
+//! DECIMAL -> VARCHAR
+template <>
+bool CastDecimalCInternal(duckdb_result *source, char *&result, idx_t col, idx_t row);
+
+//! DECIMAL -> DECIMAL (internal fetch)
+template <>
+bool CastDecimalCInternal(duckdb_result *source, duckdb_decimal &result, idx_t col, idx_t row);
+
+//! DECIMAL -> ...
+template <class RESULT_TYPE>
+RESULT_TYPE TryCastDecimalCInternal(duckdb_result *source, idx_t col, idx_t row) {
+	RESULT_TYPE result_value;
+	try {
+		if (!CastDecimalCInternal<RESULT_TYPE>(source, result_value, col, row)) {
+			return FetchDefaultValue::Operation<RESULT_TYPE>();
+		}
+	} catch (...) {
+		return FetchDefaultValue::Operation<RESULT_TYPE>();
+	}
+	return result_value;
+}
+
+} // namespace duckdb
+
+
+
+namespace duckdb {
+
+//! DECIMAL -> VARCHAR
+template <>
+bool CastDecimalCInternal(duckdb_result *source, char *&result, idx_t col, idx_t row) {
+	auto result_data = (duckdb::DuckDBResultData *)source->internal_data;
+	auto &query_result = result_data->result;
+	auto &source_type = query_result->types[col];
+	auto width = duckdb::DecimalType::GetWidth(source_type);
+	auto scale = duckdb::DecimalType::GetScale(source_type);
+	duckdb::Vector result_vec(duckdb::LogicalType::VARCHAR, false, false);
+	duckdb::string_t result_string;
+	void *source_address = UnsafeFetchPtr<hugeint_t>(source, col, row);
+	switch (source_type.InternalType()) {
+	case duckdb::PhysicalType::INT16:
+		result_string = duckdb::StringCastFromDecimal::Operation<int16_t>(UnsafeFetchFromPtr<int16_t>(source_address),
+		                                                                  width, scale, result_vec);
+		break;
+	case duckdb::PhysicalType::INT32:
+		result_string = duckdb::StringCastFromDecimal::Operation<int32_t>(UnsafeFetchFromPtr<int32_t>(source_address),
+		                                                                  width, scale, result_vec);
+		break;
+	case duckdb::PhysicalType::INT64:
+		result_string = duckdb::StringCastFromDecimal::Operation<int64_t>(UnsafeFetchFromPtr<int64_t>(source_address),
+		                                                                  width, scale, result_vec);
+		break;
+	case duckdb::PhysicalType::INT128:
+		result_string = duckdb::StringCastFromDecimal::Operation<hugeint_t>(
+		    UnsafeFetchFromPtr<hugeint_t>(source_address), width, scale, result_vec);
+		break;
+	default:
+		throw duckdb::InternalException("Unimplemented internal type for decimal");
+	}
+	result = (char *)duckdb_malloc(sizeof(char) * (result_string.GetSize() + 1));
+	memcpy(result, result_string.GetDataUnsafe(), result_string.GetSize());
+	result[result_string.GetSize()] = '\0';
+	return true;
+}
+
+template <class INTERNAL_TYPE>
+duckdb_hugeint FetchInternals(void *source_address) {
+	throw duckdb::NotImplementedException("FetchInternals not implemented for internal type");
+}
+
+template <>
+duckdb_hugeint FetchInternals<int16_t>(void *source_address) {
+	duckdb_hugeint result;
+	int16_t intermediate_result;
+
+	if (!TryCast::Operation<int16_t, int16_t>(UnsafeFetchFromPtr<int16_t>(source_address), intermediate_result)) {
+		intermediate_result = FetchDefaultValue::Operation<int16_t>();
+	}
+	hugeint_t hugeint_result = Hugeint::Cast<int16_t>(intermediate_result);
+	result.lower = hugeint_result.lower;
+	result.upper = hugeint_result.upper;
+	return result;
+}
+template <>
+duckdb_hugeint FetchInternals<int32_t>(void *source_address) {
+	duckdb_hugeint result;
+	int32_t intermediate_result;
+
+	if (!TryCast::Operation<int32_t, int32_t>(UnsafeFetchFromPtr<int32_t>(source_address), intermediate_result)) {
+		intermediate_result = FetchDefaultValue::Operation<int32_t>();
+	}
+	hugeint_t hugeint_result = Hugeint::Cast<int32_t>(intermediate_result);
+	result.lower = hugeint_result.lower;
+	result.upper = hugeint_result.upper;
+	return result;
+}
+template <>
+duckdb_hugeint FetchInternals<int64_t>(void *source_address) {
+	duckdb_hugeint result;
+	int64_t intermediate_result;
+
+	if (!TryCast::Operation<int64_t, int64_t>(UnsafeFetchFromPtr<int64_t>(source_address), intermediate_result)) {
+		intermediate_result = FetchDefaultValue::Operation<int64_t>();
+	}
+	hugeint_t hugeint_result = Hugeint::Cast<int64_t>(intermediate_result);
+	result.lower = hugeint_result.lower;
+	result.upper = hugeint_result.upper;
+	return result;
+}
+template <>
+duckdb_hugeint FetchInternals<hugeint_t>(void *source_address) {
+	duckdb_hugeint result;
+	hugeint_t intermediate_result;
+
+	if (!TryCast::Operation<hugeint_t, hugeint_t>(UnsafeFetchFromPtr<hugeint_t>(source_address), intermediate_result)) {
+		intermediate_result = FetchDefaultValue::Operation<hugeint_t>();
+	}
+	result.lower = intermediate_result.lower;
+	result.upper = intermediate_result.upper;
+	return result;
+}
+
+//! DECIMAL -> DECIMAL (internal fetch)
+template <>
+bool CastDecimalCInternal(duckdb_result *source, duckdb_decimal &result, idx_t col, idx_t row) {
+	auto result_data = (duckdb::DuckDBResultData *)source->internal_data;
+	result_data->result->types[col].GetDecimalProperties(result.width, result.scale);
+	auto source_address = UnsafeFetchPtr<hugeint_t>(source, col, row);
+
+	if (result.width > duckdb::Decimal::MAX_WIDTH_INT64) {
+		result.value = FetchInternals<hugeint_t>(source_address);
+	} else if (result.width > duckdb::Decimal::MAX_WIDTH_INT32) {
+		result.value = FetchInternals<int64_t>(source_address);
+	} else if (result.width > duckdb::Decimal::MAX_WIDTH_INT16) {
+		result.value = FetchInternals<int32_t>(source_address);
+	} else {
+		result.value = FetchInternals<int16_t>(source_address);
+	}
+	return true;
+}
+
+} // namespace duckdb
+
+
+namespace duckdb {
+
+template <>
+duckdb_decimal FetchDefaultValue::Operation() {
+	duckdb_decimal result;
+	result.scale = 0;
+	result.width = 0;
+	result.value = {0, 0};
+	return result;
+}
+
+template <>
+date_t FetchDefaultValue::Operation() {
+	date_t result;
+	result.days = 0;
+	return result;
+}
+
+template <>
+dtime_t FetchDefaultValue::Operation() {
+	dtime_t result;
+	result.micros = 0;
+	return result;
+}
+
+template <>
+timestamp_t FetchDefaultValue::Operation() {
+	timestamp_t result;
+	result.value = 0;
+	return result;
+}
+
+template <>
+interval_t FetchDefaultValue::Operation() {
+	interval_t result;
+	result.months = 0;
+	result.days = 0;
+	result.micros = 0;
+	return result;
+}
+
+template <>
+char *FetchDefaultValue::Operation() {
+	return nullptr;
+}
+
+template <>
+duckdb_blob FetchDefaultValue::Operation() {
+	duckdb_blob result;
+	result.data = nullptr;
+	result.size = 0;
+	return result;
+}
+
+//===--------------------------------------------------------------------===//
+// Blob Casts
+//===--------------------------------------------------------------------===//
+
+template <>
+bool FromCBlobCastWrapper::Operation(duckdb_blob input, char *&result) {
+	string_t input_str((const char *)input.data, input.size);
+	return ToCStringCastWrapper<duckdb::CastFromBlob>::template Operation<string_t, char *>(input_str, result);
+}
+
+} // namespace duckdb
+
+bool CanUseDeprecatedFetch(duckdb_result *result, idx_t col, idx_t row) {
+	if (!result) {
+		return false;
+	}
+	if (!duckdb::deprecated_materialize_result(result)) {
+		return false;
+	}
+	if (col >= result->__deprecated_column_count || row >= result->__deprecated_row_count) {
+		return false;
+	}
+	return true;
+}
+
+bool CanFetchValue(duckdb_result *result, idx_t col, idx_t row) {
+	if (!CanUseDeprecatedFetch(result, col, row)) {
+		return false;
+	}
+	if (result->__deprecated_columns[col].__deprecated_nullmask[row]) {
+		return false;
+	}
+	return true;
+}
 
 
 
@@ -130382,6 +130788,142 @@ idx_t duckdb_vector_size() {
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/capi/capi_cast_from_decimal.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+template <class INTERNAL_TYPE>
+struct ToCDecimalCastWrapper {
+	template <class SOURCE_TYPE>
+	static bool Operation(SOURCE_TYPE input, duckdb_decimal &result, std::string *error, uint8_t width, uint8_t scale) {
+		throw NotImplementedException("Type not implemented for CDecimalCastWrapper");
+	}
+};
+
+//! Hugeint
+template <>
+struct ToCDecimalCastWrapper<hugeint_t> {
+	template <class SOURCE_TYPE>
+	static bool Operation(SOURCE_TYPE input, duckdb_decimal &result, std::string *error, uint8_t width, uint8_t scale) {
+		hugeint_t intermediate_result;
+
+		if (!TryCastToDecimal::Operation<SOURCE_TYPE, hugeint_t>(input, intermediate_result, error, width, scale)) {
+			result = FetchDefaultValue::Operation<duckdb_decimal>();
+			return false;
+		}
+		result.scale = scale;
+		result.width = width;
+
+		duckdb_hugeint hugeint_value;
+		hugeint_value.upper = intermediate_result.upper;
+		hugeint_value.lower = intermediate_result.lower;
+		result.value = hugeint_value;
+		return true;
+	}
+};
+
+//! FIXME: reduce duplication here by just matching on the signed-ness of the type
+//! INTERNAL_TYPE = int16_t
+template <>
+struct ToCDecimalCastWrapper<int16_t> {
+	template <class SOURCE_TYPE>
+	static bool Operation(SOURCE_TYPE input, duckdb_decimal &result, std::string *error, uint8_t width, uint8_t scale) {
+		int16_t intermediate_result;
+
+		if (!TryCastToDecimal::Operation<SOURCE_TYPE, int16_t>(input, intermediate_result, error, width, scale)) {
+			result = FetchDefaultValue::Operation<duckdb_decimal>();
+			return false;
+		}
+		hugeint_t hugeint_result = Hugeint::Convert(intermediate_result);
+
+		result.scale = scale;
+		result.width = width;
+
+		duckdb_hugeint hugeint_value;
+		hugeint_value.upper = hugeint_result.upper;
+		hugeint_value.lower = hugeint_result.lower;
+		result.value = hugeint_value;
+		return true;
+	}
+};
+//! INTERNAL_TYPE = int32_t
+template <>
+struct ToCDecimalCastWrapper<int32_t> {
+	template <class SOURCE_TYPE>
+	static bool Operation(SOURCE_TYPE input, duckdb_decimal &result, std::string *error, uint8_t width, uint8_t scale) {
+		int32_t intermediate_result;
+
+		if (!TryCastToDecimal::Operation<SOURCE_TYPE, int32_t>(input, intermediate_result, error, width, scale)) {
+			result = FetchDefaultValue::Operation<duckdb_decimal>();
+			return false;
+		}
+		hugeint_t hugeint_result = Hugeint::Convert(intermediate_result);
+
+		result.scale = scale;
+		result.width = width;
+
+		duckdb_hugeint hugeint_value;
+		hugeint_value.upper = hugeint_result.upper;
+		hugeint_value.lower = hugeint_result.lower;
+		result.value = hugeint_value;
+		return true;
+	}
+};
+//! INTERNAL_TYPE = int64_t
+template <>
+struct ToCDecimalCastWrapper<int64_t> {
+	template <class SOURCE_TYPE>
+	static bool Operation(SOURCE_TYPE input, duckdb_decimal &result, std::string *error, uint8_t width, uint8_t scale) {
+		int64_t intermediate_result;
+
+		if (!TryCastToDecimal::Operation<SOURCE_TYPE, int64_t>(input, intermediate_result, error, width, scale)) {
+			result = FetchDefaultValue::Operation<duckdb_decimal>();
+			return false;
+		}
+		hugeint_t hugeint_result = Hugeint::Convert(intermediate_result);
+
+		result.scale = scale;
+		result.width = width;
+
+		duckdb_hugeint hugeint_value;
+		hugeint_value.upper = hugeint_result.upper;
+		hugeint_value.lower = hugeint_result.lower;
+		result.value = hugeint_value;
+		return true;
+	}
+};
+
+template <class SOURCE_TYPE, class OP>
+duckdb_decimal TryCastToDecimalCInternal(SOURCE_TYPE source, uint8_t width, uint8_t scale) {
+	duckdb_decimal result;
+	try {
+		if (!OP::template Operation<SOURCE_TYPE>(source, result, nullptr, width, scale)) {
+			return FetchDefaultValue::Operation<duckdb_decimal>();
+		}
+	} catch (...) {
+		return FetchDefaultValue::Operation<duckdb_decimal>();
+	}
+	return result;
+}
+
+template <class SOURCE_TYPE, class OP>
+duckdb_decimal TryCastToDecimalCInternal(duckdb_result *result, idx_t col, idx_t row, uint8_t width, uint8_t scale) {
+	return TryCastToDecimalCInternal<SOURCE_TYPE, OP>(UnsafeFetch<SOURCE_TYPE>(result, col, row), width, scale);
+}
+
+} // namespace duckdb
+
+
 using duckdb::Hugeint;
 using duckdb::hugeint_t;
 using duckdb::Value;
@@ -130393,6 +130935,26 @@ double duckdb_hugeint_to_double(duckdb_hugeint val) {
 	return Hugeint::Cast<double>(internal);
 }
 
+static duckdb_decimal to_decimal_cast(double val, uint8_t width, uint8_t scale) {
+	if (width > duckdb::Decimal::MAX_WIDTH_INT64) {
+		return duckdb::TryCastToDecimalCInternal<double, duckdb::ToCDecimalCastWrapper<hugeint_t>>(val, width, scale);
+	}
+	if (width > duckdb::Decimal::MAX_WIDTH_INT32) {
+		return duckdb::TryCastToDecimalCInternal<double, duckdb::ToCDecimalCastWrapper<int64_t>>(val, width, scale);
+	}
+	if (width > duckdb::Decimal::MAX_WIDTH_INT16) {
+		return duckdb::TryCastToDecimalCInternal<double, duckdb::ToCDecimalCastWrapper<int32_t>>(val, width, scale);
+	}
+	return duckdb::TryCastToDecimalCInternal<double, duckdb::ToCDecimalCastWrapper<int16_t>>(val, width, scale);
+}
+
+duckdb_decimal duckdb_double_to_decimal(double val, uint8_t width, uint8_t scale) {
+	if (scale > width || width > duckdb::Decimal::MAX_WIDTH_INT128) {
+		return duckdb::FetchDefaultValue::Operation<duckdb_decimal>();
+	}
+	return to_decimal_cast(val, width, scale);
+}
+
 duckdb_hugeint duckdb_double_to_hugeint(double val) {
 	hugeint_t internal_result;
 	if (!Value::DoubleIsFinite(val) || !Hugeint::TryConvert<double>(val, internal_result)) {
@@ -130711,6 +131273,7 @@ duckdb_state duckdb_execute_pending(duckdb_pending_result pending_result, duckdb
 
 
 
+
 using duckdb::Connection;
 using duckdb::date_t;
 using duckdb::dtime_t;
@@ -130806,11 +131369,15 @@ duckdb_state duckdb_bind_int64(duckdb_prepared_statement prepared_statement, idx
 	return duckdb_bind_value(prepared_statement, param_idx, Value::BIGINT(val));
 }
 
-duckdb_state duckdb_bind_hugeint(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_hugeint val) {
+static hugeint_t duckdb_internal_hugeint(duckdb_hugeint val) {
 	hugeint_t internal;
 	internal.lower = val.lower;
 	internal.upper = val.upper;
-	return duckdb_bind_value(prepared_statement, param_idx, Value::HUGEINT(internal));
+	return internal;
+}
+
+duckdb_state duckdb_bind_hugeint(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_hugeint val) {
+	return duckdb_bind_value(prepared_statement, param_idx, Value::HUGEINT(duckdb_internal_hugeint(val)));
 }
 
 duckdb_state duckdb_bind_uint8(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint8_t val) {
@@ -130871,6 +131438,15 @@ duckdb_state duckdb_bind_varchar_length(duckdb_prepared_statement prepared_state
 	}
 }
 
+duckdb_state duckdb_bind_decimal(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_decimal val) {
+	auto hugeint_val = duckdb_internal_hugeint(val.value);
+	if (val.width > duckdb::Decimal::MAX_WIDTH_INT64) {
+		return duckdb_bind_value(prepared_statement, param_idx, Value::DECIMAL(hugeint_val, val.width, val.scale));
+	}
+	auto value = hugeint_val.lower;
+	return duckdb_bind_value(prepared_statement, param_idx, Value::DECIMAL((int64_t)value, val.width, val.scale));
+}
+
 duckdb_state duckdb_bind_blob(duckdb_prepared_statement prepared_statement, idx_t param_idx, const void *data,
                               idx_t length) {
 	return duckdb_bind_value(prepared_statement, param_idx, Value::BLOB((duckdb::const_data_ptr_t)data, length));
@@ -132026,180 +132602,28 @@ void duckdb_destroy_task_state(duckdb_task_state state_p) {
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/capi/cast/generic_cast.hpp
+//
+//
+//===----------------------------------------------------------------------===//
 
-using duckdb::const_data_ptr_t;
-using duckdb::Date;
-using duckdb::date_t;
-using duckdb::dtime_t;
-using duckdb::hugeint_t;
-using duckdb::interval_t;
-using duckdb::LogicalType;
-using duckdb::string;
-using duckdb::string_t;
-using duckdb::Time;
-using duckdb::Timestamp;
-using duckdb::timestamp_t;
-using duckdb::Value;
-using duckdb::Vector;
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Unsafe Fetch (for internal use only)
-//===--------------------------------------------------------------------===//
-template <class T>
-T UnsafeFetch(duckdb_result *result, idx_t col, idx_t row) {
-	D_ASSERT(row < result->__deprecated_row_count);
-	return ((T *)result->__deprecated_columns[col].__deprecated_data)[row];
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch Default Value
-//===--------------------------------------------------------------------===//
-struct FetchDefaultValue {
-	template <class T>
-	static T Operation() {
-		return 0;
-	}
-};
-
-template <>
-date_t FetchDefaultValue::Operation() {
-	date_t result;
-	result.days = 0;
-	return result;
-}
-
-template <>
-dtime_t FetchDefaultValue::Operation() {
-	dtime_t result;
-	result.micros = 0;
-	return result;
-}
-
-template <>
-timestamp_t FetchDefaultValue::Operation() {
-	timestamp_t result;
-	result.value = 0;
-	return result;
-}
-
-template <>
-interval_t FetchDefaultValue::Operation() {
-	interval_t result;
-	result.months = 0;
-	result.days = 0;
-	result.micros = 0;
-	return result;
-}
-
-template <>
-char *FetchDefaultValue::Operation() {
-	return nullptr;
-}
 
-template <>
-duckdb_blob FetchDefaultValue::Operation() {
-	duckdb_blob result;
-	result.data = nullptr;
-	result.size = 0;
-	return result;
-}
 
-//===--------------------------------------------------------------------===//
-// String Casts
-//===--------------------------------------------------------------------===//
-template <class OP>
-struct FromCStringCastWrapper {
-	template <class SOURCE_TYPE, class RESULT_TYPE>
-	static bool Operation(SOURCE_TYPE input_str, RESULT_TYPE &result) {
-		string_t input(input_str);
-		return OP::template Operation<string_t, RESULT_TYPE>(input, result);
-	}
-};
 
-template <class OP>
-struct ToCStringCastWrapper {
-	template <class SOURCE_TYPE, class RESULT_TYPE>
-	static bool Operation(SOURCE_TYPE input, RESULT_TYPE &result) {
-		Vector result_vector(LogicalType::VARCHAR, nullptr);
-		auto result_string = OP::template Operation<SOURCE_TYPE>(input, result_vector);
-		auto result_size = result_string.GetSize();
-		auto result_data = result_string.GetDataUnsafe();
 
-		result = (char *)duckdb_malloc(result_size + 1);
-		memcpy(result, result_data, result_size);
-		result[result_size] = '\0';
-		return true;
-	}
-};
 
-//===--------------------------------------------------------------------===//
-// Blob Casts
-//===--------------------------------------------------------------------===//
-struct FromCBlobCastWrapper {
-	template <class SOURCE_TYPE, class RESULT_TYPE>
-	static bool Operation(SOURCE_TYPE input_str, RESULT_TYPE &result) {
-		return false;
-	}
-};
 
-template <>
-bool FromCBlobCastWrapper::Operation(duckdb_blob input, char *&result) {
-	string_t input_str((const char *)input.data, input.size);
-	return ToCStringCastWrapper<duckdb::CastFromBlob>::template Operation<string_t, char *>(input_str, result);
-}
-
-} // namespace duckdb
 
-using duckdb::FetchDefaultValue;
-using duckdb::FromCBlobCastWrapper;
-using duckdb::FromCStringCastWrapper;
-using duckdb::ToCStringCastWrapper;
-using duckdb::UnsafeFetch;
 
-//===--------------------------------------------------------------------===//
-// Templated Casts
-//===--------------------------------------------------------------------===//
-template <class SOURCE_TYPE, class RESULT_TYPE, class OP>
-RESULT_TYPE TryCastCInternal(duckdb_result *result, idx_t col, idx_t row) {
-	RESULT_TYPE result_value;
-	try {
-		if (!OP::template Operation<SOURCE_TYPE, RESULT_TYPE>(UnsafeFetch<SOURCE_TYPE>(result, col, row),
-		                                                      result_value)) {
-			return FetchDefaultValue::Operation<RESULT_TYPE>();
-		}
-	} catch (...) {
-		return FetchDefaultValue::Operation<RESULT_TYPE>();
-	}
-	return result_value;
-}
 
-static bool CanUseDeprecatedFetch(duckdb_result *result, idx_t col, idx_t row) {
-	if (!result) {
-		return false;
-	}
-	if (!duckdb::deprecated_materialize_result(result)) {
-		return false;
-	}
-	if (col >= result->__deprecated_column_count || row >= result->__deprecated_row_count) {
-		return false;
-	}
-	return true;
-}
 
-static bool CanFetchValue(duckdb_result *result, idx_t col, idx_t row) {
-	if (!CanUseDeprecatedFetch(result, col, row)) {
-		return false;
-	}
-	if (result->__deprecated_columns[col].__deprecated_nullmask[row]) {
-		return false;
-	}
-	return true;
-}
+namespace duckdb {
 
 template <class RESULT_TYPE, class OP = duckdb::TryCast>
-static RESULT_TYPE GetInternalCValue(duckdb_result *result, idx_t col, idx_t row) {
+RESULT_TYPE GetInternalCValue(duckdb_result *result, idx_t col, idx_t row) {
 	if (!CanFetchValue(result, col, row)) {
 		return FetchDefaultValue::Operation<RESULT_TYPE>();
 	}
@@ -132235,23 +132659,35 @@ static RESULT_TYPE GetInternalCValue(duckdb_result *result, idx_t col, idx_t row
 	case DUCKDB_TYPE_HUGEINT:
 		return TryCastCInternal<hugeint_t, RESULT_TYPE, OP>(result, col, row);
 	case DUCKDB_TYPE_DECIMAL:
-		return TryCastCInternal<hugeint_t, RESULT_TYPE, OP>(result, col, row);
+		return TryCastDecimalCInternal<RESULT_TYPE>(result, col, row);
 	case DUCKDB_TYPE_INTERVAL:
 		return TryCastCInternal<interval_t, RESULT_TYPE, OP>(result, col, row);
 	case DUCKDB_TYPE_VARCHAR:
 		return TryCastCInternal<char *, RESULT_TYPE, FromCStringCastWrapper<OP>>(result, col, row);
 	case DUCKDB_TYPE_BLOB:
 		return TryCastCInternal<duckdb_blob, RESULT_TYPE, FromCBlobCastWrapper>(result, col, row);
-	default: // LCOV_EXCL_START
+	default: { // LCOV_EXCL_START
 		// invalid type for C to C++ conversion
 		D_ASSERT(0);
 		return FetchDefaultValue::Operation<RESULT_TYPE>();
 	} // LCOV_EXCL_STOP
+	}
 }
 
-//===--------------------------------------------------------------------===//
-// duckdb_value_ functions
-//===--------------------------------------------------------------------===//
+} // namespace duckdb
+
+
+using duckdb::date_t;
+using duckdb::dtime_t;
+using duckdb::FetchDefaultValue;
+using duckdb::GetInternalCValue;
+using duckdb::hugeint_t;
+using duckdb::interval_t;
+using duckdb::StringCast;
+using duckdb::timestamp_t;
+using duckdb::ToCStringCastWrapper;
+using duckdb::UnsafeFetch;
+
 bool duckdb_value_boolean(duckdb_result *result, idx_t col, idx_t row) {
 	return GetInternalCValue<bool>(result, col, row);
 }
@@ -132272,16 +132708,25 @@ int64_t duckdb_value_int64(duckdb_result *result, idx_t col, idx_t row) {
 	return GetInternalCValue<int64_t>(result, col, row);
 }
 
-duckdb_decimal duckdb_value_decimal(duckdb_result *result, idx_t col, idx_t row) {
-	duckdb_decimal result_value;
-
+static bool ResultIsDecimal(duckdb_result *result, idx_t col) {
+	if (!result) {
+		return false;
+	}
+	if (!result->internal_data) {
+		return false;
+	}
 	auto result_data = (duckdb::DuckDBResultData *)result->internal_data;
-	result_data->result->types[col].GetDecimalProperties(result_value.width, result_value.scale);
+	auto &query_result = result_data->result;
+	auto &source_type = query_result->types[col];
+	return source_type.id() == duckdb::LogicalTypeId::DECIMAL;
+}
 
-	auto internal_value = GetInternalCValue<hugeint_t>(result, col, row);
-	result_value.value.lower = internal_value.lower;
-	result_value.value.upper = internal_value.upper;
-	return result_value;
+duckdb_decimal duckdb_value_decimal(duckdb_result *result, idx_t col, idx_t row) {
+	if (!CanFetchValue(result, col, row) || !ResultIsDecimal(result, col)) {
+		return FetchDefaultValue::Operation<duckdb_decimal>();
+	}
+
+	return GetInternalCValue<duckdb_decimal>(result, col, row);
 }
 
 duckdb_hugeint duckdb_value_hugeint(duckdb_result *result, idx_t col, idx_t row) {
@@ -132344,7 +132789,7 @@ duckdb_interval duckdb_value_interval(duckdb_result *result, idx_t col, idx_t ro
 }
 
 char *duckdb_value_varchar(duckdb_result *result, idx_t col, idx_t row) {
-	return GetInternalCValue<char *, ToCStringCastWrapper<duckdb::StringCast>>(result, col, row);
+	return GetInternalCValue<char *, ToCStringCastWrapper<StringCast>>(result, col, row);
 }
 
 char *duckdb_value_varchar_internal(duckdb_result *result, idx_t col, idx_t row) {