duckdb 1.3.4 → 1.4.0

package/src/duckdb/src/function/cast/variant/to_json.cpp

@@ -0,0 +1,272 @@
+#include "duckdb/function/scalar/variant_utils.hpp"
+#include "duckdb/function/cast/default_casts.hpp"
+#include "yyjson.hpp"
+#include "duckdb/common/serializer/memory_stream.hpp"
+#include "duckdb/common/serializer/varint.hpp"
+#include "duckdb/common/typedefs.hpp"
+#include "duckdb/common/optional_idx.hpp"
+#include "duckdb/common/string_map_set.hpp"
+#include "duckdb/common/types/selection_vector.hpp"
+#include "duckdb/common/types/decimal.hpp"
+#include "duckdb/common/types/time.hpp"
+#include "duckdb/common/types/timestamp.hpp"
+
+using namespace duckdb_yyjson; // NOLINT
+
+namespace duckdb {
+
+//! ------------ Variant -> JSON ------------
+
+yyjson_mut_val *VariantCasts::ConvertVariantToJSON(yyjson_mut_doc *doc, const RecursiveUnifiedVectorFormat &source,
+                                                   idx_t row, uint32_t values_idx) {
+	auto index = source.unified.sel->get_index(row);
+	if (!source.unified.validity.RowIsValid(index)) {
+		return yyjson_mut_null(doc);
+	}
+
+	//! values
+	auto &values = UnifiedVariantVector::GetValues(source);
+	auto values_data = values.GetData<list_entry_t>(values);
+
+	//! type_ids
+	auto &type_ids = UnifiedVariantVector::GetValuesTypeId(source);
+	auto type_ids_data = type_ids.GetData<uint8_t>(type_ids);
+
+	//! byte_offsets
+	auto &byte_offsets = UnifiedVariantVector::GetValuesByteOffset(source);
+	auto byte_offsets_data = byte_offsets.GetData<uint32_t>(byte_offsets);
+
+	//! children
+	auto &children = UnifiedVariantVector::GetChildren(source);
+	auto children_data = children.GetData<list_entry_t>(children);
+
+	//! values_index
+	auto &values_index = UnifiedVariantVector::GetChildrenValuesIndex(source);
+	auto values_index_data = values_index.GetData<uint32_t>(values_index);
+
+	//! keys_index
+	auto &keys_index = UnifiedVariantVector::GetChildrenKeysIndex(source);
+	auto keys_index_data = keys_index.GetData<uint32_t>(keys_index);
+
+	//! keys
+	auto &keys = UnifiedVariantVector::GetKeys(source);
+	auto keys_data = keys.GetData<list_entry_t>(keys);
+	auto &keys_entry = UnifiedVariantVector::GetKeysEntry(source);
+	auto keys_entry_data = keys_entry.GetData<string_t>(keys_entry);
+
+	//! list entries
+	auto keys_list_entry = keys_data[keys.sel->get_index(row)];
+	auto children_list_entry = children_data[children.sel->get_index(row)];
+	auto values_list_entry = values_data[values.sel->get_index(row)];
+
+	//! The 'values' data of the value we're currently converting
+	values_idx += values_list_entry.offset;
+	auto type_id = static_cast<VariantLogicalType>(type_ids_data[type_ids.sel->get_index(values_idx)]);
+	auto byte_offset = byte_offsets_data[byte_offsets.sel->get_index(values_idx)];
+
+	//! The blob data of the Variant, accessed by byte offset retrieved above ^
+	auto &value = UnifiedVariantVector::GetData(source);
+	auto value_data = value.GetData<string_t>(value);
+	auto &blob = value_data[value.sel->get_index(row)];
+	auto blob_data = const_data_ptr_cast(blob.GetData());
+
+	auto ptr = const_data_ptr_cast(blob_data + byte_offset);
+	switch (type_id) {
+	case VariantLogicalType::VARIANT_NULL:
+		return yyjson_mut_null(doc);
+	case VariantLogicalType::BOOL_TRUE:
+		return yyjson_mut_true(doc);
+	case VariantLogicalType::BOOL_FALSE:
+		return yyjson_mut_false(doc);
+	case VariantLogicalType::INT8: {
+		auto val = Load<int8_t>(ptr);
+		return yyjson_mut_sint(doc, val);
+	}
+	case VariantLogicalType::INT16: {
+		auto val = Load<int16_t>(ptr);
+		return yyjson_mut_sint(doc, val);
+	}
+	case VariantLogicalType::INT32: {
+		auto val = Load<int32_t>(ptr);
+		return yyjson_mut_sint(doc, val);
+	}
+	case VariantLogicalType::INT64: {
+		auto val = Load<int64_t>(ptr);
+		return yyjson_mut_sint(doc, val);
+	}
+	case VariantLogicalType::INT128: {
+		auto val = Load<hugeint_t>(ptr);
+		auto val_str = val.ToString();
+		return yyjson_mut_rawncpy(doc, val_str.c_str(), val_str.size());
+	}
+	case VariantLogicalType::UINT8: {
+		auto val = Load<uint8_t>(ptr);
+		return yyjson_mut_sint(doc, val);
+	}
+	case VariantLogicalType::UINT16: {
+		auto val = Load<uint16_t>(ptr);
+		return yyjson_mut_sint(doc, val);
+	}
+	case VariantLogicalType::UINT32: {
+		auto val = Load<uint32_t>(ptr);
+		return yyjson_mut_sint(doc, val);
+	}
+	case VariantLogicalType::UINT64: {
+		auto val = Load<uint64_t>(ptr);
+		return yyjson_mut_uint(doc, val);
+	}
+	case VariantLogicalType::UINT128: {
+		auto val = Load<uhugeint_t>(ptr);
+		auto val_str = val.ToString();
+		return yyjson_mut_rawncpy(doc, val_str.c_str(), val_str.size());
+	}
+	case VariantLogicalType::UUID: {
+		auto val = Value::UUID(Load<hugeint_t>(ptr));
+		auto val_str = val.ToString();
+		return yyjson_mut_strncpy(doc, val_str.c_str(), val_str.size());
+	}
+	case VariantLogicalType::INTERVAL: {
+		auto val = Value::INTERVAL(Load<interval_t>(ptr));
+		auto val_str = val.ToString();
+		return yyjson_mut_strncpy(doc, val_str.c_str(), val_str.size());
+	}
+	case VariantLogicalType::FLOAT: {
+		auto val = Load<float>(ptr);
+		return yyjson_mut_real(doc, val);
+	}
+	case VariantLogicalType::DOUBLE: {
+		auto val = Load<double>(ptr);
+		return yyjson_mut_real(doc, val);
+	}
+	case VariantLogicalType::DATE: {
+		auto val = Load<int32_t>(ptr);
+		auto val_str = Date::ToString(date_t(val));
+		return yyjson_mut_strncpy(doc, val_str.c_str(), val_str.size());
+	}
+	case VariantLogicalType::BLOB: {
+		auto string_length = VarintDecode<uint32_t>(ptr);
+		auto string_data = reinterpret_cast<const char *>(ptr);
+		auto val_str = Value::BLOB(const_data_ptr_cast(string_data), string_length).ToString();
+		return yyjson_mut_strncpy(doc, val_str.c_str(), val_str.size());
+	}
+	case VariantLogicalType::VARCHAR: {
+		auto string_length = VarintDecode<uint32_t>(ptr);
+		auto string_data = reinterpret_cast<const char *>(ptr);
+		return yyjson_mut_strncpy(doc, string_data, static_cast<size_t>(string_length));
+	}
+	case VariantLogicalType::DECIMAL: {
+		auto width = NumericCast<uint8_t>(VarintDecode<idx_t>(ptr));
+		auto scale = NumericCast<uint8_t>(VarintDecode<idx_t>(ptr));
+
+		string val_str;
+		if (width > DecimalWidth<int64_t>::max) {
+			val_str = Decimal::ToString(Load<hugeint_t>(ptr), width, scale);
+		} else if (width > DecimalWidth<int32_t>::max) {
+			val_str = Decimal::ToString(Load<int64_t>(ptr), width, scale);
+		} else if (width > DecimalWidth<int16_t>::max) {
+			val_str = Decimal::ToString(Load<int32_t>(ptr), width, scale);
+		} else {
+			val_str = Decimal::ToString(Load<int16_t>(ptr), width, scale);
+		}
+		return yyjson_mut_rawncpy(doc, val_str.c_str(), val_str.size());
+	}
+	case VariantLogicalType::TIME_MICROS: {
+		auto val = Load<dtime_t>(ptr);
+		auto val_str = Time::ToString(val);
+		return yyjson_mut_strncpy(doc, val_str.c_str(), val_str.size());
+	}
+	case VariantLogicalType::TIME_MICROS_TZ: {
+		auto val = Value::TIMETZ(Load<dtime_tz_t>(ptr));
+		auto val_str = val.ToString();
+		return yyjson_mut_strncpy(doc, val_str.c_str(), val_str.size());
+	}
+	case VariantLogicalType::TIMESTAMP_MICROS: {
+		auto val = Load<timestamp_t>(ptr);
+		auto val_str = Timestamp::ToString(val);
+		return yyjson_mut_strncpy(doc, val_str.c_str(), val_str.size());
+	}
+	case VariantLogicalType::TIMESTAMP_SEC: {
+		auto val = Value::TIMESTAMPSEC(Load<timestamp_sec_t>(ptr));
+		auto val_str = val.ToString();
+		return yyjson_mut_strncpy(doc, val_str.c_str(), val_str.size());
+	}
+	case VariantLogicalType::TIMESTAMP_NANOS: {
+		auto val = Value::TIMESTAMPNS(Load<timestamp_ns_t>(ptr));
+		auto val_str = val.ToString();
+		return yyjson_mut_strncpy(doc, val_str.c_str(), val_str.size());
+	}
+	case VariantLogicalType::TIMESTAMP_MILIS: {
+		auto val = Value::TIMESTAMPMS(Load<timestamp_ms_t>(ptr));
+		auto val_str = val.ToString();
+		return yyjson_mut_strncpy(doc, val_str.c_str(), val_str.size());
+	}
+	case VariantLogicalType::TIMESTAMP_MICROS_TZ: {
+		auto val = Value::TIMESTAMPTZ(Load<timestamp_tz_t>(ptr));
+		auto val_str = val.ToString();
+		return yyjson_mut_strncpy(doc, val_str.c_str(), val_str.size());
+	}
+	case VariantLogicalType::ARRAY: {
+		auto count = VarintDecode<uint32_t>(ptr);
+		auto arr = yyjson_mut_arr(doc);
+		if (!count) {
+			return arr;
+		}
+		auto child_index_start = VarintDecode<uint32_t>(ptr);
+		for (idx_t i = 0; i < count; i++) {
+			auto index = values_index.sel->get_index(children_list_entry.offset + child_index_start + i);
+			auto child_index = values_index_data[index];
+#ifdef DEBUG
+			auto key_id_index = keys_index.sel->get_index(children_list_entry.offset + child_index_start + i);
+			D_ASSERT(!keys_index.validity.RowIsValid(key_id_index));
+#endif
+			auto val = ConvertVariantToJSON(doc, source, row, child_index);
+			if (!val) {
+				return nullptr;
+			}
+			yyjson_mut_arr_add_val(arr, val);
+		}
+		return arr;
+	}
+	case VariantLogicalType::OBJECT: {
+		auto count = VarintDecode<uint32_t>(ptr);
+		auto obj = yyjson_mut_obj(doc);
+		if (!count) {
+			return obj;
+		}
+		auto child_index_start = VarintDecode<uint32_t>(ptr);
+
+		for (idx_t i = 0; i < count; i++) {
+			auto children_index = values_index.sel->get_index(children_list_entry.offset + child_index_start + i);
+			auto child_value_idx = values_index_data[children_index];
+			auto val = ConvertVariantToJSON(doc, source, row, child_value_idx);
+			if (!val) {
+				return nullptr;
+			}
+			auto keys_index_index = keys_index.sel->get_index(children_list_entry.offset + child_index_start + i);
+			D_ASSERT(keys_index.validity.RowIsValid(keys_index_index));
+			auto child_key_id = keys_index_data[keys_index_index];
+			auto &key = keys_entry_data[keys_entry.sel->get_index(keys_list_entry.offset + child_key_id)];
+			yyjson_mut_obj_put(obj, yyjson_mut_strncpy(doc, key.GetData(), key.GetSize()), val);
+		}
+		return obj;
+	}
+	case VariantLogicalType::BITSTRING: {
+		auto string_length = VarintDecode<uint32_t>(ptr);
+		auto string_data = reinterpret_cast<const char *>(ptr);
+		auto val_str = Value::BIT(const_data_ptr_cast(string_data), string_length).ToString();
+		return yyjson_mut_strncpy(doc, val_str.c_str(), val_str.size());
+	}
+	case VariantLogicalType::BIGNUM: {
+		auto string_length = VarintDecode<uint32_t>(ptr);
+		auto string_data = reinterpret_cast<const char *>(ptr);
+		auto val_str = Value::BIGNUM(const_data_ptr_cast(string_data), string_length).ToString();
+		return yyjson_mut_rawncpy(doc, val_str.c_str(), val_str.size());
+	}
+	default:
+		throw InternalException("VariantLogicalType(%d) not handled", static_cast<uint8_t>(type_id));
+	}
+
+	return nullptr;
+}
+
+} // namespace duckdb

package/src/duckdb/src/function/cast/variant/to_variant.cpp

@@ -0,0 +1,193 @@
+#include "duckdb/function/cast/default_casts.hpp"
+#include "duckdb/common/types/variant.hpp"
+#include "duckdb/function/scalar/variant_utils.hpp"
+
+#include "duckdb/common/enum_util.hpp"
+#include "duckdb/common/exception/conversion_exception.hpp"
+
+#include "duckdb/function/cast/variant/to_variant.hpp"
+
+namespace duckdb {
+
+namespace variant {
+
+static void InitializeOffsets(DataChunk &offsets, idx_t count) {
+	auto keys = OffsetData::GetKeys(offsets);
+	auto children = OffsetData::GetChildren(offsets);
+	auto values = OffsetData::GetValues(offsets);
+	auto blob = OffsetData::GetBlob(offsets);
+	for (idx_t i = 0; i < count; i++) {
+		keys[i] = 0;
+		children[i] = 0;
+		values[i] = 0;
+		blob[i] = 0;
+	}
+}
+
+static void InitializeVariants(DataChunk &offsets, Vector &result, SelectionVector &keys_selvec, idx_t &selvec_size,
+                               OrderedOwningStringMap<uint32_t> &dictionary) {
+	auto &keys = VariantVector::GetKeys(result);
+	auto keys_data = ListVector::GetData(keys);
+
+	auto &children = VariantVector::GetChildren(result);
+	auto children_data = ListVector::GetData(children);
+
+	auto &values = VariantVector::GetValues(result);
+	auto values_data = ListVector::GetData(values);
+
+	auto &blob = VariantVector::GetData(result);
+	auto blob_data = FlatVector::GetData<string_t>(blob);
+
+	idx_t keys_offset = 0;
+	idx_t children_offset = 0;
+	idx_t values_offset = 0;
+
+	auto keys_sizes = OffsetData::GetKeys(offsets);
+	auto children_sizes = OffsetData::GetChildren(offsets);
+	auto values_sizes = OffsetData::GetValues(offsets);
+	auto blob_sizes = OffsetData::GetBlob(offsets);
+	for (idx_t i = 0; i < offsets.size(); i++) {
+		auto &keys_entry = keys_data[i];
+		auto &children_entry = children_data[i];
+		auto &values_entry = values_data[i];
+
+		//! keys
+		keys_entry.length = keys_sizes[i];
+		keys_entry.offset = keys_offset;
+		keys_offset += keys_entry.length;
+
+		//! children
+		children_entry.length = children_sizes[i];
+		children_entry.offset = children_offset;
+		children_offset += children_entry.length;
+
+		//! values
+		values_entry.length = values_sizes[i];
+		values_entry.offset = values_offset;
+		values_offset += values_entry.length;
+
+		//! value
+		blob_data[i] = StringVector::EmptyString(blob, blob_sizes[i]);
+	}
+
+	//! Reserve for the children of the lists
+	ListVector::Reserve(keys, keys_offset);
+	ListVector::Reserve(children, children_offset);
+	ListVector::Reserve(values, values_offset);
+
+	//! Set list sizes
+	ListVector::SetListSize(keys, keys_offset);
+	ListVector::SetListSize(children, children_offset);
+	ListVector::SetListSize(values, values_offset);
+
+	keys_selvec.Initialize(keys_offset);
+	selvec_size = keys_offset;
+}
+
+static void FinalizeVariantKeys(Vector &variant, OrderedOwningStringMap<uint32_t> &dictionary, SelectionVector &sel,
+                                idx_t sel_size) {
+	auto &keys = VariantVector::GetKeys(variant);
+	auto &keys_entry = ListVector::GetEntry(keys);
+	auto keys_entry_data = FlatVector::GetData<string_t>(keys_entry);
+
+	bool already_sorted = true;
+
+	vector<uint32_t> unsorted_to_sorted(dictionary.size());
+	auto it = dictionary.begin();
+	for (uint32_t sorted_idx = 0; sorted_idx < dictionary.size(); sorted_idx++) {
+		auto unsorted_idx = it->second;
+		if (unsorted_idx != sorted_idx) {
+			already_sorted = false;
+		}
+		unsorted_to_sorted[unsorted_idx] = sorted_idx;
+		D_ASSERT(sorted_idx < ListVector::GetListSize(keys));
+		keys_entry_data[sorted_idx] = it->first;
+		auto size = static_cast<uint32_t>(keys_entry_data[sorted_idx].GetSize());
+		keys_entry_data[sorted_idx].SetSizeAndFinalize(size, size);
+		it++;
+	}
+
+	if (!already_sorted) {
+		//! Adjust the selection vector to point to the right dictionary index
+		for (idx_t i = 0; i < sel_size; i++) {
+			auto &entry = sel[i];
+			auto sorted_idx = unsorted_to_sorted[entry];
+			entry = sorted_idx;
+		}
+	}
+}
+
+static bool GatherOffsetsAndSizes(ToVariantSourceData &source, ToVariantGlobalResultData &result, idx_t count) {
+	InitializeOffsets(result.offsets, count);
+	//! First pass - collect sizes/offsets
+	return ConvertToVariant<false>(source, result, count, nullptr, nullptr, true);
+}
+
+static bool WriteVariantResultData(ToVariantSourceData &source, ToVariantGlobalResultData &result, idx_t count) {
+	InitializeOffsets(result.offsets, count);
+	//! Second pass - actually construct the variants
+	return ConvertToVariant<true>(source, result, count, nullptr, nullptr, true);
+}
+
+static bool CastToVARIANT(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
+	DataChunk offsets;
+	offsets.Initialize(Allocator::DefaultAllocator(),
+	                   {LogicalType::UINTEGER, LogicalType::UINTEGER, LogicalType::UINTEGER, LogicalType::UINTEGER},
+	                   count);
+	offsets.SetCardinality(count);
+	auto &keys = VariantVector::GetKeys(result);
+	auto &keys_entry = ListVector::GetEntry(keys);
+
+	//! Initialize the dictionary
+	OrderedOwningStringMap<uint32_t> dictionary(StringVector::GetStringBuffer(keys_entry).GetStringAllocator());
+	SelectionVector keys_selvec;
+	ToVariantSourceData source_data(source, count);
+
+	{
+		VariantVectorData variant_data(result);
+		ToVariantGlobalResultData result_data(variant_data, offsets, dictionary, keys_selvec);
+		if (!GatherOffsetsAndSizes(source_data, result_data, count)) {
+			return false;
+		}
+	}
+
+	//! This resizes the lists, invalidating the "GetData" results stored in VariantVectorData
+	idx_t keys_selvec_size;
+	InitializeVariants(offsets, result, keys_selvec, keys_selvec_size, dictionary);
+
+	{
+		VariantVectorData variant_data(result);
+		ToVariantGlobalResultData result_data(variant_data, offsets, dictionary, keys_selvec);
+		if (!WriteVariantResultData(source_data, result_data, count)) {
+			return false;
+		}
+	}
+
+	FinalizeVariantKeys(result, dictionary, keys_selvec, keys_selvec_size);
+	//! Finalize the 'data'
+	auto &blob = VariantVector::GetData(result);
+	auto blob_data = FlatVector::GetData<string_t>(blob);
+	auto blob_offsets = OffsetData::GetBlob(offsets);
+	for (idx_t i = 0; i < count; i++) {
+		auto size = blob_offsets[i];
+		blob_data[i].SetSizeAndFinalize(size, size);
+	}
+
+	keys_entry.Slice(keys_selvec, keys_selvec_size);
+	keys_entry.Flatten(keys_selvec_size);
+
+	if (source.GetVectorType() == VectorType::CONSTANT_VECTOR) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+	result.Verify(count);
+	return true;
+}
+
+} // namespace variant
+
+BoundCastInfo DefaultCasts::ImplicitToVariantCast(BindCastInput &input, const LogicalType &source,
+                                                  const LogicalType &target) {
+	return BoundCastInfo(variant::CastToVARIANT);
+}
+
+} // namespace duckdb

package/src/duckdb/src/function/cast_rules.cpp

@@ -18,6 +18,8 @@ static int64_t TargetTypeCost(const LogicalType &type) {
 		return 104;
 	case LogicalTypeId::DECIMAL:
 		return 105;
+	case LogicalTypeId::BIGNUM:
+		return 106;
 	case LogicalTypeId::TIMESTAMP_NS:
 		return 119;
 	case LogicalTypeId::TIMESTAMP:
@@ -38,6 +40,9 @@ static int64_t TargetTypeCost(const LogicalType &type) {
 		return 160;
 	case LogicalTypeId::ANY:
 		return int64_t(AnyType::GetCastScore(type));
+	case LogicalTypeId::TEMPLATE:
+		// we can cast anything to a template type, but prefer to cast to anything else!
+		return 1000000;
 	default:
 		return 110;
 	}
@@ -52,6 +57,7 @@ static int64_t ImplicitCastTinyint(const LogicalType &to) {
 	case LogicalTypeId::FLOAT:
 	case LogicalTypeId::DOUBLE:
 	case LogicalTypeId::DECIMAL:
+	case LogicalTypeId::BIGNUM:
 		return TargetTypeCost(to);
 	default:
 		return -1;
@@ -66,6 +72,7 @@ static int64_t ImplicitCastSmallint(const LogicalType &to) {
 	case LogicalTypeId::FLOAT:
 	case LogicalTypeId::DOUBLE:
 	case LogicalTypeId::DECIMAL:
+	case LogicalTypeId::BIGNUM:
 		return TargetTypeCost(to);
 	default:
 		return -1;
@@ -79,6 +86,7 @@ static int64_t ImplicitCastInteger(const LogicalType &to) {
 	case LogicalTypeId::FLOAT:
 	case LogicalTypeId::DOUBLE:
 	case LogicalTypeId::DECIMAL:
+	case LogicalTypeId::BIGNUM:
 		return TargetTypeCost(to);
 	default:
 		return -1;
@@ -91,6 +99,7 @@ static int64_t ImplicitCastBigint(const LogicalType &to) {
 	case LogicalTypeId::DOUBLE:
 	case LogicalTypeId::HUGEINT:
 	case LogicalTypeId::DECIMAL:
+	case LogicalTypeId::BIGNUM:
 		return TargetTypeCost(to);
 	default:
 		return -1;
@@ -110,6 +119,7 @@ static int64_t ImplicitCastUTinyint(const LogicalType &to) {
 	case LogicalTypeId::FLOAT:
 	case LogicalTypeId::DOUBLE:
 	case LogicalTypeId::DECIMAL:
+	case LogicalTypeId::BIGNUM:
 		return TargetTypeCost(to);
 	default:
 		return -1;
@@ -127,6 +137,7 @@ static int64_t ImplicitCastUSmallint(const LogicalType &to) {
 	case LogicalTypeId::FLOAT:
 	case LogicalTypeId::DOUBLE:
 	case LogicalTypeId::DECIMAL:
+	case LogicalTypeId::BIGNUM:
 		return TargetTypeCost(to);
 	default:
 		return -1;
@@ -143,6 +154,7 @@ static int64_t ImplicitCastUInteger(const LogicalType &to) {
 	case LogicalTypeId::FLOAT:
 	case LogicalTypeId::DOUBLE:
 	case LogicalTypeId::DECIMAL:
+	case LogicalTypeId::BIGNUM:
 		return TargetTypeCost(to);
 	default:
 		return -1;
@@ -156,6 +168,7 @@ static int64_t ImplicitCastUBigint(const LogicalType &to) {
 	case LogicalTypeId::UHUGEINT:
 	case LogicalTypeId::HUGEINT:
 	case LogicalTypeId::DECIMAL:
+	case LogicalTypeId::BIGNUM:
 		return TargetTypeCost(to);
 	default:
 		return -1;
@@ -164,6 +177,7 @@ static int64_t ImplicitCastUBigint(const LogicalType &to) {
 
 static int64_t ImplicitCastFloat(const LogicalType &to) {
 	switch (to.id()) {
+	case LogicalTypeId::BIGNUM:
 	case LogicalTypeId::DOUBLE:
 		return TargetTypeCost(to);
 	default:
@@ -173,6 +187,9 @@ static int64_t ImplicitCastFloat(const LogicalType &to) {
 
 static int64_t ImplicitCastDouble(const LogicalType &to) {
 	switch (to.id()) {
+
+	case LogicalTypeId::BIGNUM:
+		return TargetTypeCost(to);
 	default:
 		return -1;
 	}
@@ -193,6 +210,7 @@ static int64_t ImplicitCastHugeint(const LogicalType &to) {
 	case LogicalTypeId::FLOAT:
 	case LogicalTypeId::DOUBLE:
 	case LogicalTypeId::DECIMAL:
+	case LogicalTypeId::BIGNUM:
 		return TargetTypeCost(to);
 	default:
 		return -1;
@@ -204,6 +222,7 @@ static int64_t ImplicitCastUhugeint(const LogicalType &to) {
 	case LogicalTypeId::FLOAT:
 	case LogicalTypeId::DOUBLE:
 	case LogicalTypeId::DECIMAL:
+	case LogicalTypeId::BIGNUM:
 		return TargetTypeCost(to);
 	default:
 		return -1;
@@ -274,7 +293,7 @@ static int64_t ImplicitCastTimestamp(const LogicalType &to) {
 	}
 }
 
-static int64_t ImplicitCastVarint(const LogicalType &to) {
+static int64_t ImplicitCastBignum(const LogicalType &to) {
 	switch (to.id()) {
 	case LogicalTypeId::DOUBLE:
 		return TargetTypeCost(to);
@@ -283,10 +302,15 @@ static int64_t ImplicitCastVarint(const LogicalType &to) {
 	}
 }
 
+static int64_t ImplicitCastVariant(const LogicalType &to) {
+	return TargetTypeCost(to);
+}
+
 bool LogicalTypeIsValid(const LogicalType &type) {
 	switch (type.id()) {
 	case LogicalTypeId::STRUCT:
 	case LogicalTypeId::UNION:
+	case LogicalTypeId::VARIANT:
 	case LogicalTypeId::LIST:
 	case LogicalTypeId::MAP:
 	case LogicalTypeId::ARRAY:
@@ -333,10 +357,18 @@ bool LogicalTypeIsValid(const LogicalType &type) {
 }
 
 int64_t CastRules::ImplicitCast(const LogicalType &from, const LogicalType &to) {
-	if (from.id() == LogicalTypeId::SQLNULL || to.id() == LogicalTypeId::ANY) {
+	if (from.id() == LogicalTypeId::SQLNULL && to.id() == LogicalTypeId::TEMPLATE) {
+		// Prefer the TEMPLATE type for NULL casts, as it is the most generic
+		return 5;
+	}
+	if (from.id() == LogicalTypeId::SQLNULL || to.id() == LogicalTypeId::ANY || to.id() == LogicalTypeId::TEMPLATE) {
 		// NULL expression can be cast to anything
 		return TargetTypeCost(to);
 	}
+	if (from.id() == LogicalTypeId::ANY && to.IsTemplated()) {
+		// This can happen when changing a function from using ANY to using TEMPLATE.
+		return TargetTypeCost(to);
+	}
 	if (from.id() == LogicalTypeId::UNKNOWN) {
 		// parameter expression can be cast to anything for no cost
 		return 0;
@@ -575,8 +607,10 @@ int64_t CastRules::ImplicitCast(const LogicalType &from, const LogicalType &to)
 		return ImplicitCastTimestampNS(to);
 	case LogicalTypeId::TIMESTAMP:
 		return ImplicitCastTimestamp(to);
-	case LogicalTypeId::VARINT:
-		return ImplicitCastVarint(to);
+	case LogicalTypeId::BIGNUM:
+		return ImplicitCastBignum(to);
+	case LogicalTypeId::VARIANT:
+		return ImplicitCastVariant(to);
 	default:
 		return -1;
 	}