duckdb 1.3.3-dev4.0 → 1.3.3

package/src/duckdb/src/function/cast/blob_cast.cpp

@@ -9,9 +9,6 @@ BoundCastInfo DefaultCasts::BlobCastSwitch(BindCastInput &input, const LogicalTy
 	case LogicalTypeId::VARCHAR:
 		// blob to varchar
 		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, duckdb::CastFromBlob>);
-	case LogicalTypeId::UUID:
-		// blob to uuid
-		return BoundCastInfo(&VectorCastHelpers::TryCastStrictLoop<string_t, hugeint_t, duckdb::TryCastBlobToUUID>);
 	case LogicalTypeId::AGGREGATE_STATE:
 		return DefaultCasts::ReinterpretCast;
 	case LogicalTypeId::BIT:

package/src/duckdb/src/function/cast/cast_function_set.cpp

@@ -1,7 +1,5 @@
 #include "duckdb/function/cast/cast_function_set.hpp"
 
-#include "duckdb/main/settings.hpp"
-
 #include "duckdb/common/pair.hpp"
 #include "duckdb/common/types/type_map.hpp"
 #include "duckdb/function/cast_rules.hpp"
@@ -109,8 +107,6 @@ static auto RelaxedTypeMatch(type_map_t<MAP_VALUE_TYPE> &map, const LogicalType
 		return map.find(LogicalType::UNION({{"any", LogicalType::ANY}}));
 	case LogicalTypeId::ARRAY:
 		return map.find(LogicalType::ARRAY(LogicalType::ANY, optional_idx()));
-	case LogicalTypeId::DECIMAL:
-		return map.find(LogicalTypeId::DECIMAL);
 	default:
 		return map.find(LogicalType::ANY);
 	}
@@ -165,8 +161,7 @@ private:
 	type_id_map_t<type_map_t<type_id_map_t<type_map_t<MapCastNode>>>> casts;
 };
 
-int64_t CastFunctionSet::ImplicitCastCost(optional_ptr<ClientContext> context, const LogicalType &source,
-                                          const LogicalType &target) {
+int64_t CastFunctionSet::ImplicitCastCost(const LogicalType &source, const LogicalType &target) {
 	// check if a cast has been registered
 	if (map_info) {
 		auto entry = map_info->GetEntry(source, target);
@@ -176,30 +171,15 @@ int64_t CastFunctionSet::ImplicitCastCost(optional_ptr<ClientContext> context, c
 	}
 	// if not, fallback to the default implicit cast rules
 	auto score = CastRules::ImplicitCast(source, target);
-	if (score < 0 && source.id() != LogicalTypeId::BLOB && target.id() == LogicalTypeId::VARCHAR) {
-		bool old_implicit_casting = false;
-		if (context) {
-			old_implicit_casting = DBConfig::GetSetting<OldImplicitCastingSetting>(*context);
-		} else if (config) {
-			old_implicit_casting = DBConfig::GetSetting<OldImplicitCastingSetting>(*config);
-		}
-		if (old_implicit_casting) {
+	if (score < 0 && config && config->options.old_implicit_casting) {
+		if (source.id() != LogicalTypeId::BLOB && target.id() == LogicalTypeId::VARCHAR) {
 			score = 149;
 		}
 	}
 	return score;
 }
 
-int64_t CastFunctionSet::ImplicitCastCost(ClientContext &context, const LogicalType &source,
-                                          const LogicalType &target) {
-	return CastFunctionSet::Get(context).ImplicitCastCost(&context, source, target);
-}
-
-int64_t CastFunctionSet::ImplicitCastCost(DatabaseInstance &db, const LogicalType &source, const LogicalType &target) {
-	return CastFunctionSet::Get(db).ImplicitCastCost(nullptr, source, target);
-}
-
-static BoundCastInfo MapCastFunction(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
+BoundCastInfo MapCastFunction(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
 	D_ASSERT(input.info);
 	auto &map_info = input.info->Cast<MapCastInfo>();
 	auto entry = map_info.GetEntry(source, target);

package/src/duckdb/src/function/cast/decimal_cast.cpp

@@ -73,7 +73,7 @@ struct DecimalScaleUpCheckOperator {
 };
 
 template <class SOURCE, class DEST, class POWERS_SOURCE, class POWERS_DEST>
-static bool TemplatedDecimalScaleUp(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
+bool TemplatedDecimalScaleUp(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	auto source_scale = DecimalType::GetScale(source.GetType());
 	auto source_width = DecimalType::GetWidth(source.GetType());
 	auto result_scale = DecimalType::GetScale(result.GetType());
@@ -116,7 +116,7 @@ struct DecimalScaleDownOperator {
 
 // This function detects if we can scale a decimal down to another.
 template <class INPUT_TYPE>
-static bool CanScaleDownDecimal(INPUT_TYPE input, DecimalScaleInput<INPUT_TYPE> &data) {
+bool CanScaleDownDecimal(INPUT_TYPE input, DecimalScaleInput<INPUT_TYPE> &data) {
 	int64_t divisor = UnsafeNumericCast<int64_t>(NumericHelper::POWERS_OF_TEN[data.source_scale]);
 	auto value = input % divisor;
 	auto rounded_input = input;
@@ -160,7 +160,7 @@ struct DecimalScaleDownCheckOperator {
 };
 
 template <class SOURCE, class DEST, class POWERS_SOURCE>
-static bool TemplatedDecimalScaleDown(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
+bool TemplatedDecimalScaleDown(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	auto source_scale = DecimalType::GetScale(source.GetType());
 	auto source_width = DecimalType::GetWidth(source.GetType());
 	auto result_scale = DecimalType::GetScale(result.GetType());

package/src/duckdb/src/function/cast/default_casts.cpp

@@ -88,13 +88,9 @@ BoundCastInfo DefaultCasts::GetDefaultCastFunction(BindCastInput &input, const L
                                                    const LogicalType &target) {
 	D_ASSERT(source != target);
 
-	if (target.id() == LogicalTypeId::VARIANT) {
-		return ImplicitToVariantCast(input, source, target);
-	}
-
-	// then check if were casting to a union
+	// first check if were casting to a union
 	if (source.id() != LogicalTypeId::UNION && source.id() != LogicalTypeId::SQLNULL &&
-	    source.id() != LogicalTypeId::VARIANT && target.id() == LogicalTypeId::UNION) {
+	    target.id() == LogicalTypeId::UNION) {
 		return ImplicitToUnionCast(input, source, target);
 	}
 
@@ -124,8 +120,6 @@ BoundCastInfo DefaultCasts::GetDefaultCastFunction(BindCastInput &input, const L
 		return DateCastSwitch(input, source, target);
 	case LogicalTypeId::TIME:
 		return TimeCastSwitch(input, source, target);
-	case LogicalTypeId::TIME_NS:
-		return TimeNsCastSwitch(input, source, target);
 	case LogicalTypeId::TIME_TZ:
 		return TimeTzCastSwitch(input, source, target);
 	case LogicalTypeId::TIMESTAMP:
@@ -156,14 +150,12 @@ BoundCastInfo DefaultCasts::GetDefaultCastFunction(BindCastInput &input, const L
 		return ListCastSwitch(input, source, target);
 	case LogicalTypeId::UNION:
 		return UnionCastSwitch(input, source, target);
-	case LogicalTypeId::VARIANT:
-		return VariantCastSwitch(input, source, target);
 	case LogicalTypeId::ENUM:
 		return EnumCastSwitch(input, source, target);
 	case LogicalTypeId::ARRAY:
 		return ArrayCastSwitch(input, source, target);
-	case LogicalTypeId::BIGNUM:
-		return BignumCastSwitch(input, source, target);
+	case LogicalTypeId::VARINT:
+		return VarintCastSwitch(input, source, target);
 	case LogicalTypeId::AGGREGATE_STATE:
 		return AggregateStateToBlobCast;
 	default:

package/src/duckdb/src/function/cast/enum_casts.cpp

@@ -6,7 +6,7 @@
 namespace duckdb {
 
 template <class SRC_TYPE, class RES_TYPE>
-static bool EnumEnumCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
+bool EnumEnumCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	auto &enum_dictionary = EnumType::GetValuesInsertOrder(source.GetType());
 	auto dictionary_data = FlatVector::GetData<string_t>(enum_dictionary);
 	auto res_enum_type = result.GetType();
@@ -31,7 +31,7 @@ static bool EnumEnumCast(Vector &source, Vector &result, idx_t count, CastParame
 }
 
 template <class SRC_TYPE>
-static BoundCastInfo EnumEnumCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
+BoundCastInfo EnumEnumCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
 	switch (target.InternalType()) {
 	case PhysicalType::UINT8:
 		return EnumEnumCast<SRC_TYPE, uint8_t>;
@@ -68,8 +68,7 @@ public:
 	}
 };
 
-static unique_ptr<BoundCastData> BindEnumCast(BindCastInput &input, const LogicalType &source,
-                                              const LogicalType &target) {
+unique_ptr<BoundCastData> BindEnumCast(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
 	auto to_varchar_cast = input.GetCastFunction(source, LogicalType::VARCHAR);
 	auto from_varchar_cast = input.GetCastFunction(LogicalType::VARCHAR, target);
 	return make_uniq<EnumBoundCastData>(std::move(to_varchar_cast), std::move(from_varchar_cast));

package/src/duckdb/src/function/cast/numeric_casts.cpp

@@ -2,7 +2,7 @@
 #include "duckdb/function/cast/vector_cast_helpers.hpp"
 #include "duckdb/common/operator/string_cast.hpp"
 #include "duckdb/common/operator/numeric_cast.hpp"
-#include "duckdb/common/types/bignum.hpp"
+#include "duckdb/common/types/varint.hpp"
 
 namespace duckdb {
 
@@ -42,8 +42,8 @@ static BoundCastInfo InternalNumericCastSwitch(const LogicalType &source, const
 		return BoundCastInfo(&VectorCastHelpers::StringCast<SRC, duckdb::StringCast>);
 	case LogicalTypeId::BIT:
 		return BoundCastInfo(&VectorCastHelpers::StringCast<SRC, duckdb::NumericTryCastToBit>);
-	case LogicalTypeId::BIGNUM:
-		return Bignum::NumericToBignumCastSwitch(source);
+	case LogicalTypeId::VARINT:
+		return Varint::NumericToVarintCastSwitch(source);
 	default:
 		return DefaultCasts::TryVectorNullCast;
 	}

package/src/duckdb/src/function/cast/string_cast.cpp

@@ -4,15 +4,16 @@
 #include "duckdb/common/numeric_utils.hpp"
 #include "duckdb/common/pair.hpp"
 #include "duckdb/common/vector.hpp"
+#include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/function/cast/bound_cast_data.hpp"
-#include "duckdb/common/types/bignum.hpp"
+#include "duckdb/common/types/varint.hpp"
 
 namespace duckdb {
 
 template <class T>
-static bool StringEnumCastLoop(const string_t *source_data, ValidityMask &source_mask, const LogicalType &source_type,
-                               T *result_data, ValidityMask &result_mask, const LogicalType &result_type, idx_t count,
-                               VectorTryCastData &vector_cast_data, const SelectionVector *sel) {
+bool StringEnumCastLoop(const string_t *source_data, ValidityMask &source_mask, const LogicalType &source_type,
+                        T *result_data, ValidityMask &result_mask, const LogicalType &result_type, idx_t count,
+                        VectorTryCastData &vector_cast_data, const SelectionVector *sel) {
 	for (idx_t i = 0; i < count; i++) {
 		idx_t source_idx = i;
 		if (sel) {
@@ -34,7 +35,7 @@ static bool StringEnumCastLoop(const string_t *source_data, ValidityMask &source
 }
 
 template <class T>
-static bool StringEnumCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
+bool StringEnumCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	D_ASSERT(source.GetType().id() == LogicalTypeId::VARCHAR);
 	switch (source.GetVectorType()) {
 	case VectorType::CONSTANT_VECTOR: {
@@ -261,7 +262,7 @@ bool VectorStringToStruct::StringToNestedTypeCastLoop(const string_t *source_dat
 //===--------------------------------------------------------------------===//
 // string -> map casting
 //===--------------------------------------------------------------------===//
-static unique_ptr<FunctionLocalState> InitMapCastLocalState(CastLocalStateParameters &parameters) {
+unique_ptr<FunctionLocalState> InitMapCastLocalState(CastLocalStateParameters &parameters) {
 	auto &cast_data = parameters.cast_data->Cast<MapBoundCastData>();
 	auto result = make_uniq<MapCastLocalState>();
 
@@ -432,7 +433,7 @@ bool VectorStringToArray::StringToNestedTypeCastLoop(const string_t *source_data
 }
 
 template <class T>
-static bool StringToNestedTypeCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
+bool StringToNestedTypeCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	D_ASSERT(source.GetType().id() == LogicalTypeId::VARCHAR);
 
 	switch (source.GetVectorType()) {
@@ -466,15 +467,11 @@ BoundCastInfo DefaultCasts::StringCastSwitch(BindCastInput &input, const Logical
 		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, date_t, duckdb::TryCastErrorMessage>);
 	case LogicalTypeId::TIME:
 		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, dtime_t, duckdb::TryCastErrorMessage>);
-	case LogicalTypeId::TIME_NS:
-		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, dtime_ns_t, duckdb::TryCastErrorMessage>);
 	case LogicalTypeId::TIME_TZ:
 		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, dtime_tz_t, duckdb::TryCastErrorMessage>);
 	case LogicalTypeId::TIMESTAMP:
-		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, timestamp_t, duckdb::TryCastErrorMessage>);
 	case LogicalTypeId::TIMESTAMP_TZ:
-		return BoundCastInfo(
-		    &VectorCastHelpers::TryCastErrorLoop<string_t, timestamp_tz_t, duckdb::TryCastErrorMessage>);
+		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, timestamp_t, duckdb::TryCastErrorMessage>);
 	case LogicalTypeId::TIMESTAMP_NS:
 		return BoundCastInfo(
 		    &VectorCastHelpers::TryCastStrictLoop<string_t, timestamp_ns_t, duckdb::TryCastToTimestampNS>);
@@ -515,8 +512,8 @@ BoundCastInfo DefaultCasts::StringCastSwitch(BindCastInput &input, const Logical
 		                     MapBoundCastData::BindMapToMapCast(
 		                         input, LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR), target),
 		                     InitMapCastLocalState);
-	case LogicalTypeId::BIGNUM:
-		return BoundCastInfo(&VectorCastHelpers::TryCastStringLoop<string_t, bignum_t, TryCastToBignum>);
+	case LogicalTypeId::VARINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastStringLoop<string_t, string_t, TryCastToVarInt>);
 	default:
 		return VectorStringCastNumericSwitch(input, source, target);
 	}

package/src/duckdb/src/function/cast/struct_cast.cpp

@@ -1,6 +1,6 @@
 #include "duckdb/common/exception/binder_exception.hpp"
-#include "duckdb/common/insertion_order_preserving_map.hpp"
 #include "duckdb/function/cast/default_casts.hpp"
+#include "duckdb/function/cast/cast_function_set.hpp"
 #include "duckdb/function/cast/bound_cast_data.hpp"
 #include "duckdb/function/cast/vector_cast_helpers.hpp"
 
@@ -20,7 +20,7 @@ unique_ptr<BoundCastData> StructBoundCastData::BindStructToStructCast(BindCastIn
 		throw TypeMismatchException(input.query_location, source, target, "Cannot cast STRUCTs of different size");
 	}
 
-	InsertionOrderPreservingMap<idx_t> target_children_map;
+	case_insensitive_map_t<idx_t> target_children_map;
 	if (!is_unnamed) {
 		for (idx_t i = 0; i < target_children.size(); i++) {
 			auto &name = target_children[i].first;
@@ -229,127 +229,6 @@ static bool StructToVarcharCast(Vector &source, Vector &result, idx_t count, Cas
 	return true;
 }
 
-unique_ptr<BoundCastData> StructToMapBoundCastData::BindStructToMapCast(BindCastInput &input, const LogicalType &source,
-                                                                        const LogicalType &target) {
-	if (StructType::IsUnnamed(source)) {
-		throw TypeMismatchException(input.query_location, source, target, "Cannot cast unnamed STRUCTs to MAP");
-	}
-	// Get a cast function for the keys (struct has varchar keys, map has single-type keys)
-	auto key_cast = input.GetCastFunction(LogicalType::VARCHAR, MapType::KeyType(target));
-	// Get cast function for the values (struct may have different value types per key, map has single-type values)
-	vector<BoundCastInfo> value_casts;
-	auto target_value_type = MapType::ValueType(target);
-	for (idx_t i = 0; i < StructType::GetChildCount(source); i++) {
-		auto value_cast = input.GetCastFunction(StructType::GetChildType(source, i), target_value_type);
-		value_casts.push_back(std::move(value_cast));
-	}
-	return make_uniq<StructToMapBoundCastData>(std::move(key_cast), std::move(value_casts));
-}
-
-unique_ptr<FunctionLocalState>
-StructToMapBoundCastData::InitStructToMapCastLocalState(CastLocalStateParameters &parameters) {
-	auto &cast_data = parameters.cast_data->Cast<StructToMapBoundCastData>();
-	auto result = make_uniq<StructToMapCastLocalState>();
-
-	if (cast_data.key_cast.init_local_state) {
-		CastLocalStateParameters child_params(parameters, cast_data.key_cast.cast_data);
-		result->key_state = cast_data.key_cast.init_local_state(child_params);
-	}
-
-	for (auto &entry : cast_data.value_casts) {
-		unique_ptr<FunctionLocalState> child_state;
-		if (entry.init_local_state) {
-			CastLocalStateParameters child_params(parameters, entry.cast_data);
-			child_state = entry.init_local_state(child_params);
-		}
-		result->value_states.push_back(std::move(child_state));
-	}
-	return std::move(result);
-}
-
-static bool StructToMapCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-
-	if (source.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		// Optimization: if the source vector is constant, we only have a single physical element, so we can set the
-		// result vectortype to ConstantVector as well and set the (logical) count to 1
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		count = 1;
-		if (ConstantVector::IsNull(source)) {
-			// If there's only a null in there we don't need to cast anything
-			ConstantVector::SetNull(result, true);
-			return true;
-		}
-	}
-
-	auto &cast_data = parameters.cast_data->Cast<StructToMapBoundCastData>();
-	auto &local_state = parameters.local_state->Cast<StructToMapCastLocalState>();
-
-	// Grab all struct columns
-	auto &source_children = StructVector::GetEntries(source);
-	idx_t field_count = source_children.size();
-	idx_t total_count = count * field_count;
-
-	// Allocate result
-	ListVector::Reserve(result, total_count);
-
-	// Create key vector with VARCHAR keys (could make this a dictionary vector as optimization)
-	Vector varchar_keys(LogicalType::VARCHAR, total_count);
-	auto key_data = FlatVector::GetData<string_t>(varchar_keys);
-	auto &field_types = StructType::GetChildTypes(source.GetType());
-	for (idx_t row_idx = 0; row_idx < count; row_idx++) {
-		for (idx_t field_idx = 0; field_idx < field_count; field_idx++) {
-			auto global_idx = row_idx * field_count + field_idx;
-			auto &field_name = field_types[field_idx].first;
-			key_data[global_idx] = StringVector::AddString(varchar_keys, field_name);
-		}
-	}
-
-	// Cast keys to result
-	auto &map_keys = MapVector::GetKeys(result);
-	CastParameters key_parameters(parameters, cast_data.key_cast.cast_data, local_state.key_state);
-	auto keys_converted = cast_data.key_cast.function(varchar_keys, map_keys, total_count, key_parameters);
-
-	// Fill the values vector
-	bool values_converted = true;
-	auto &map_values = MapVector::GetValues(result);
-	for (idx_t field_idx = 0; field_idx < field_count; field_idx++) {
-		auto &source_field = *source_children[field_idx];
-		Vector temp_converted(MapType::ValueType(result.GetType()), count);
-		CastParameters child_params(parameters, cast_data.value_casts[field_idx].cast_data,
-		                            local_state.value_states[field_idx]);
-		auto success = cast_data.value_casts[field_idx].function(source_field, temp_converted, count, child_params);
-		if (!success) {
-			values_converted = false;
-		}
-
-		// Interleave results
-		for (idx_t row_idx = 0; row_idx < count; row_idx++) {
-			auto target_idx = row_idx * field_count + field_idx;
-			// Copy also does a validity check
-			VectorOperations::Copy(temp_converted, map_values, row_idx + 1, row_idx, target_idx);
-		}
-	}
-
-	// Check for nulls in the source rows, and set the list data
-	UnifiedVectorFormat format;
-	source.ToUnifiedFormat(count, format);
-	auto &validity = format.validity;
-	auto list_data = ListVector::GetData(result);
-	for (idx_t i = 0; i < count; i++) {
-		if (!validity.RowIsValid(format.sel->get_index(i))) { // is row null?
-			// Note: this must be a FlatVector because if we set it to be a ConstantVector and that was null then we've
-			// already returned
-			FlatVector::SetNull(result, i, true);
-		} else {
-			list_data[i] = list_entry_t(i * field_count, field_count);
-		}
-	}
-	// Set the size
-	ListVector::SetListSize(result, total_count);
-
-	return keys_converted && values_converted;
-}
-
 BoundCastInfo DefaultCasts::StructCastSwitch(BindCastInput &input, const LogicalType &source,
                                              const LogicalType &target) {
 	switch (target.id()) {
@@ -368,10 +247,6 @@ BoundCastInfo DefaultCasts::StructCastSwitch(BindCastInput &input, const Logical
 		                     StructBoundCastData::BindStructToStructCast(input, source, varchar_type),
 		                     StructBoundCastData::InitStructCastLocalState);
 	}
-	case LogicalTypeId::MAP: {
-		return BoundCastInfo(StructToMapCast, StructToMapBoundCastData::BindStructToMapCast(input, source, target),
-		                     StructToMapBoundCastData::InitStructToMapCastLocalState);
-	}
 	default:
 		return TryVectorNullCast;
 	}

package/src/duckdb/src/function/cast/time_casts.cpp

@@ -38,20 +38,6 @@ BoundCastInfo DefaultCasts::TimeCastSwitch(BindCastInput &input, const LogicalTy
 	}
 }
 
-BoundCastInfo DefaultCasts::TimeNsCastSwitch(BindCastInput &input, const LogicalType &src, const LogicalType &target) {
-	// now switch on the result type
-	switch (target.id()) {
-	case LogicalTypeId::VARCHAR:
-		// time (ns) to varchar
-		return BoundCastInfo(&VectorCastHelpers::StringCast<dtime_ns_t, duckdb::StringCast>);
-	case LogicalTypeId::TIME:
-		// time (ns) to time (µs)
-		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<dtime_ns_t, dtime_t, duckdb::Cast>);
-	default:
-		return TryVectorNullCast;
-	}
-}
-
 BoundCastInfo DefaultCasts::TimeTzCastSwitch(BindCastInput &input, const LogicalType &source,
                                              const LogicalType &target) {
 	// now switch on the result type
@@ -135,10 +121,6 @@ BoundCastInfo DefaultCasts::TimestampNsCastSwitch(BindCastInput &input, const Lo
 		// timestamp (ns) to time
 		return BoundCastInfo(
 		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_t, duckdb::CastTimestampNsToTime>);
-	case LogicalTypeId::TIME_NS:
-		// timestamp (ns) to time (ns)
-		return BoundCastInfo(
-		    &VectorCastHelpers::TemplatedCastLoop<timestamp_ns_t, dtime_ns_t, duckdb::CastTimestampNsToTimeNs>);
 	case LogicalTypeId::TIMESTAMP:
 		// timestamp (ns) to timestamp (us)
 		return BoundCastInfo(

package/src/duckdb/src/function/cast/union_casts.cpp

@@ -13,8 +13,7 @@ namespace duckdb {
 //--------------------------------------------------------------------------------------------------
 // if the source can be implicitly cast to a member of the target union, the cast is valid
 
-static unique_ptr<BoundCastData> BindToUnionCast(BindCastInput &input, const LogicalType &source,
-                                                 const LogicalType &target) {
+unique_ptr<BoundCastData> BindToUnionCast(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
 	D_ASSERT(target.id() == LogicalTypeId::UNION);
 
 	vector<UnionBoundCastData> candidates;
@@ -22,7 +21,7 @@ static unique_ptr<BoundCastData> BindToUnionCast(BindCastInput &input, const Log
 	for (idx_t member_idx = 0; member_idx < UnionType::GetMemberCount(target); member_idx++) {
 		auto member_type = UnionType::GetMemberType(target, member_idx);
 		auto member_name = UnionType::GetMemberName(target, member_idx);
-		auto member_cast_cost = input.function_set.ImplicitCastCost(nullptr, source, member_type);
+		auto member_cast_cost = input.function_set.ImplicitCastCost(source, member_type);
 		if (member_cast_cost != -1) {
 			auto member_cast_info = input.GetCastFunction(source, member_type);
 			candidates.emplace_back(member_idx, member_name, member_type, member_cast_cost,
@@ -78,7 +77,7 @@ static unique_ptr<BoundCastData> BindToUnionCast(BindCastInput &input, const Log
 	return make_uniq<UnionBoundCastData>(std::move(selected_cast));
 }
 
-static unique_ptr<FunctionLocalState> InitToUnionLocalState(CastLocalStateParameters &parameters) {
+unique_ptr<FunctionLocalState> InitToUnionLocalState(CastLocalStateParameters &parameters) {
 	auto &cast_data = parameters.cast_data->Cast<UnionBoundCastData>();
 	if (!cast_data.member_cast_info.init_local_state) {
 		return nullptr;
@@ -153,8 +152,8 @@ public:
 	}
 };
 
-static unique_ptr<BoundCastData> BindUnionToUnionCast(BindCastInput &input, const LogicalType &source,
-                                                      const LogicalType &target) {
+unique_ptr<BoundCastData> BindUnionToUnionCast(BindCastInput &input, const LogicalType &source,
+                                               const LogicalType &target) {
 	D_ASSERT(source.id() == LogicalTypeId::UNION);
 	D_ASSERT(target.id() == LogicalTypeId::UNION);
 
@@ -192,7 +191,7 @@ static unique_ptr<BoundCastData> BindUnionToUnionCast(BindCastInput &input, cons
 	return make_uniq<UnionUnionBoundCastData>(tag_map, std::move(member_casts), target);
 }
 
-static unique_ptr<FunctionLocalState> InitUnionToUnionLocalState(CastLocalStateParameters &parameters) {
+unique_ptr<FunctionLocalState> InitUnionToUnionLocalState(CastLocalStateParameters &parameters) {
 	auto &cast_data = parameters.cast_data->Cast<UnionUnionBoundCastData>();
 	auto result = make_uniq<StructCastLocalState>();
 

package/src/duckdb/src/function/cast/uuid_casts.cpp

@@ -10,9 +10,6 @@ BoundCastInfo DefaultCasts::UUIDCastSwitch(BindCastInput &input, const LogicalTy
 	case LogicalTypeId::VARCHAR:
 		// uuid to varchar
 		return BoundCastInfo(&VectorCastHelpers::StringCast<hugeint_t, duckdb::CastFromUUID>);
-	case LogicalTypeId::BLOB:
-		// uuid to blob
-		return BoundCastInfo(&VectorCastHelpers::StringCast<hugeint_t, duckdb::CastFromUUIDToBlob>);
 	default:
 		return TryVectorNullCast;
 	}