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

package/src/duckdb/src/function/aggregate/distributive/count.cpp

@@ -65,7 +65,7 @@ struct CountFunction : public BaseCountFunction {
 	}
 
 	static void ConstantOperation(STATE &state, idx_t count) {
-		state += count;
+		state += UnsafeNumericCast<STATE>(count);
 	}
 
 	static bool IgnoreNull() {
@@ -147,7 +147,7 @@ struct CountFunction : public BaseCountFunction {
 			idx_t next = MinValue<idx_t>(base_idx + ValidityMask::BITS_PER_VALUE, count);
 			if (ValidityMask::AllValid(validity_entry)) {
 				// all valid
-				result += next - base_idx;
+				result += UnsafeNumericCast<STATE>(next - base_idx);
 				base_idx = next;
 			} else if (ValidityMask::NoneValid(validity_entry)) {
 				// nothing valid: skip all
@@ -169,7 +169,7 @@ struct CountFunction : public BaseCountFunction {
 	                                   const SelectionVector &sel_vector) {
 		if (mask.AllValid()) {
 			// no NULL values
-			result += count;
+			result += UnsafeNumericCast<STATE>(count);
 			return;
 		}
 		for (idx_t i = 0; i < count; i++) {
@@ -187,7 +187,7 @@ struct CountFunction : public BaseCountFunction {
 		case VectorType::CONSTANT_VECTOR: {
 			if (!ConstantVector::IsNull(input)) {
 				// if the constant is not null increment the state
-				result += count;
+				result += UnsafeNumericCast<STATE>(count);
 			}
 			break;
 		}
@@ -197,7 +197,7 @@ struct CountFunction : public BaseCountFunction {
 		}
 		case VectorType::SEQUENCE_VECTOR: {
 			// sequence vectors cannot have NULL values
-			result += count;
+			result += UnsafeNumericCast<STATE>(count);
 			break;
 		}
 		default: {

package/src/duckdb/src/function/aggregate/distributive/first.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
+#include "duckdb/core_functions/create_sort_key.hpp"
 #include "duckdb/function/aggregate/distributive_functions.hpp"
 #include "duckdb/planner/expression.hpp"
 
@@ -66,7 +67,7 @@ struct FirstFunction : public FirstFunctionBase {
 };
 
 template <bool LAST, bool SKIP_NULLS>
-struct FirstFunctionString : public FirstFunctionBase {
+struct FirstFunctionStringBase : public FirstFunctionBase {
 	template <class STATE>
 	static void SetValue(STATE &state, AggregateInputData &input_data, string_t value, bool is_null) {
 		if (LAST && state.is_set) {
@@ -93,10 +94,28 @@ struct FirstFunctionString : public FirstFunctionBase {
 		}
 	}
 
+	template <class STATE, class OP>
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &input_data) {
+		if (source.is_set && (LAST || !target.is_set)) {
+			SetValue(target, input_data, source.value, source.is_null);
+		}
+	}
+
+	template <class STATE>
+	static void Destroy(STATE &state, AggregateInputData &) {
+		if (state.is_set && !state.is_null && !state.value.IsInlined()) {
+			delete[] state.value.GetData();
+		}
+	}
+};
+
+template <bool LAST, bool SKIP_NULLS>
+struct FirstFunctionString : FirstFunctionStringBase<LAST, SKIP_NULLS> {
 	template <class INPUT_TYPE, class STATE, class OP>
 	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
 		if (LAST || !state.is_set) {
-			SetValue(state, unary_input.input, input, !unary_input.RowIsValid());
+			FirstFunctionStringBase<LAST, SKIP_NULLS>::template SetValue<STATE>(state, unary_input.input, input,
+			                                                                    !unary_input.RowIsValid());
 		}
 	}
 
@@ -106,13 +125,6 @@ struct FirstFunctionString : public FirstFunctionBase {
 		Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
 	}
 
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &input_data) {
-		if (source.is_set && (LAST || !target.is_set)) {
-			SetValue(target, input_data, source.value, source.is_null);
-		}
-	}
-
 	template <class T, class STATE>
 	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
 		if (!state.is_set || state.is_null) {
@@ -121,48 +133,13 @@ struct FirstFunctionString : public FirstFunctionBase {
 			target = StringVector::AddStringOrBlob(finalize_data.result, state.value);
 		}
 	}
-
-	template <class STATE>
-	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
-		if (state.is_set && !state.is_null && !state.value.IsInlined()) {
-			delete[] state.value.GetData();
-		}
-	}
-};
-
-struct FirstStateVector {
-	Vector *value;
 };
 
 template <bool LAST, bool SKIP_NULLS>
-struct FirstVectorFunction {
-	template <class STATE>
-	static void Initialize(STATE &state) {
-		state.value = nullptr;
-	}
+struct FirstVectorFunction : FirstFunctionStringBase<LAST, SKIP_NULLS> {
+	using STATE = FirstState<string_t>;
 
-	template <class STATE>
-	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
-		if (state.value) {
-			delete state.value;
-		}
-	}
-	static bool IgnoreNull() {
-		return SKIP_NULLS;
-	}
-
-	template <class STATE>
-	static void SetValue(STATE &state, Vector &input, const idx_t idx) {
-		if (!state.value) {
-			state.value = new Vector(input.GetType());
-			state.value->SetVectorType(VectorType::CONSTANT_VECTOR);
-		}
-		sel_t selv = UnsafeNumericCast<sel_t>(idx);
-		SelectionVector sel(&selv);
-		VectorOperations::Copy(input, *state.value, sel, 1, 0, 0);
-	}
-
-	static void Update(Vector inputs[], AggregateInputData &, idx_t input_count, Vector &state_vector, idx_t count) {
+	static void Update(Vector inputs[], AggregateInputData &input_data, idx_t, Vector &state_vector, idx_t count) {
 		auto &input = inputs[0];
 		UnifiedVectorFormat idata;
 		input.ToUnifiedFormat(count, idata);
@@ -170,32 +147,61 @@ struct FirstVectorFunction {
 		UnifiedVectorFormat sdata;
 		state_vector.ToUnifiedFormat(count, sdata);
 
-		auto states = UnifiedVectorFormat::GetData<FirstStateVector *>(sdata);
+		sel_t assign_sel[STANDARD_VECTOR_SIZE];
+		idx_t assign_count = 0;
+
+		auto states = UnifiedVectorFormat::GetData<STATE *>(sdata);
 		for (idx_t i = 0; i < count; i++) {
 			const auto idx = idata.sel->get_index(i);
-			if (SKIP_NULLS && !idata.validity.RowIsValid(idx)) {
+			bool is_null = !idata.validity.RowIsValid(idx);
+			if (SKIP_NULLS && is_null) {
 				continue;
 			}
 			auto &state = *states[sdata.sel->get_index(i)];
-			if (LAST || !state.value) {
-				SetValue(state, input, i);
+			if (!LAST && state.is_set) {
+				continue;
 			}
+			assign_sel[assign_count++] = NumericCast<sel_t>(i);
+		}
+		if (assign_count == 0) {
+			// fast path - nothing to set
+			return;
 		}
-	}
 
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
-		if (source.value && (LAST || !target.value)) {
-			SetValue(target, *source.value, 0);
+		Vector sort_key(LogicalType::BLOB);
+		OrderModifiers modifiers(OrderType::ASCENDING, OrderByNullType::NULLS_LAST);
+		// slice with a selection vector and generate sort keys
+		if (assign_count == count) {
+			CreateSortKeyHelpers::CreateSortKey(input, count, modifiers, sort_key);
+		} else {
+			SelectionVector sel(assign_sel);
+			Vector sliced_input(input, sel, assign_count);
+			CreateSortKeyHelpers::CreateSortKey(sliced_input, assign_count, modifiers, sort_key);
+		}
+		auto sort_key_data = FlatVector::GetData<string_t>(sort_key);
+
+		// now assign sort keys
+		for (idx_t i = 0; i < assign_count; i++) {
+			const auto state_idx = sdata.sel->get_index(assign_sel[i]);
+			auto &state = *states[state_idx];
+			if (!LAST && state.is_set) {
+				continue;
+			}
+
+			const auto idx = idata.sel->get_index(assign_sel[i]);
+			bool is_null = !idata.validity.RowIsValid(idx);
+			FirstFunctionStringBase<LAST, SKIP_NULLS>::template SetValue<STATE>(state, input_data, sort_key_data[i],
+			                                                                    is_null);
 		}
 	}
 
 	template <class STATE>
 	static void Finalize(STATE &state, AggregateFinalizeData &finalize_data) {
-		if (!state.value) {
+		if (!state.is_set || state.is_null) {
 			finalize_data.ReturnNull();
 		} else {
-			VectorOperations::Copy(*state.value, finalize_data.result, 1, 0, finalize_data.result_idx);
+			CreateSortKeyHelpers::DecodeSortKey(state.value, finalize_data.result, finalize_data.result_idx,
+			                                    OrderModifiers(OrderType::ASCENDING, OrderByNullType::NULLS_LAST));
 		}
 	}
 
@@ -229,45 +235,44 @@ AggregateFunction GetDecimalFirstFunction(const LogicalType &type) {
 		return GetFirstFunction<LAST, SKIP_NULLS>(LogicalType::HUGEINT);
 	}
 }
-
 template <bool LAST, bool SKIP_NULLS>
 static AggregateFunction GetFirstFunction(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::BOOLEAN:
-		return GetFirstAggregateTemplated<int8_t, LAST, SKIP_NULLS>(type);
-	case LogicalTypeId::TINYINT:
+	if (type.id() == LogicalTypeId::DECIMAL) {
+		type.Verify();
+		AggregateFunction function = GetDecimalFirstFunction<LAST, SKIP_NULLS>(type);
+		function.arguments[0] = type;
+		function.return_type = type;
+		return function;
+	}
+	switch (type.InternalType()) {
+	case PhysicalType::BOOL:
+	case PhysicalType::INT8:
 		return GetFirstAggregateTemplated<int8_t, LAST, SKIP_NULLS>(type);
-	case LogicalTypeId::SMALLINT:
+	case PhysicalType::INT16:
 		return GetFirstAggregateTemplated<int16_t, LAST, SKIP_NULLS>(type);
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::DATE:
+	case PhysicalType::INT32:
 		return GetFirstAggregateTemplated<int32_t, LAST, SKIP_NULLS>(type);
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIME_TZ:
-	case LogicalTypeId::TIMESTAMP_TZ:
+	case PhysicalType::INT64:
 		return GetFirstAggregateTemplated<int64_t, LAST, SKIP_NULLS>(type);
-	case LogicalTypeId::UTINYINT:
+	case PhysicalType::UINT8:
 		return GetFirstAggregateTemplated<uint8_t, LAST, SKIP_NULLS>(type);
-	case LogicalTypeId::USMALLINT:
+	case PhysicalType::UINT16:
 		return GetFirstAggregateTemplated<uint16_t, LAST, SKIP_NULLS>(type);
-	case LogicalTypeId::UINTEGER:
+	case PhysicalType::UINT32:
 		return GetFirstAggregateTemplated<uint32_t, LAST, SKIP_NULLS>(type);
-	case LogicalTypeId::UBIGINT:
+	case PhysicalType::UINT64:
 		return GetFirstAggregateTemplated<uint64_t, LAST, SKIP_NULLS>(type);
-	case LogicalTypeId::HUGEINT:
+	case PhysicalType::INT128:
 		return GetFirstAggregateTemplated<hugeint_t, LAST, SKIP_NULLS>(type);
-	case LogicalTypeId::UHUGEINT:
+	case PhysicalType::UINT128:
 		return GetFirstAggregateTemplated<uhugeint_t, LAST, SKIP_NULLS>(type);
-	case LogicalTypeId::FLOAT:
+	case PhysicalType::FLOAT:
 		return GetFirstAggregateTemplated<float, LAST, SKIP_NULLS>(type);
-	case LogicalTypeId::DOUBLE:
+	case PhysicalType::DOUBLE:
 		return GetFirstAggregateTemplated<double, LAST, SKIP_NULLS>(type);
-	case LogicalTypeId::INTERVAL:
+	case PhysicalType::INTERVAL:
 		return GetFirstAggregateTemplated<interval_t, LAST, SKIP_NULLS>(type);
-	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::BLOB:
+	case PhysicalType::VARCHAR:
 		if (LAST) {
 			return AggregateFunction::UnaryAggregateDestructor<FirstState<string_t>, string_t, string_t,
 			                                                   FirstFunctionString<LAST, SKIP_NULLS>>(type, type);
@@ -275,21 +280,13 @@ static AggregateFunction GetFirstFunction(const LogicalType &type) {
 			return AggregateFunction::UnaryAggregate<FirstState<string_t>, string_t, string_t,
 			                                         FirstFunctionString<LAST, SKIP_NULLS>>(type, type);
 		}
-	case LogicalTypeId::DECIMAL: {
-		type.Verify();
-		AggregateFunction function = GetDecimalFirstFunction<LAST, SKIP_NULLS>(type);
-		function.arguments[0] = type;
-		function.return_type = type;
-		// TODO set_key here?
-		return function;
-	}
 	default: {
 		using OP = FirstVectorFunction<LAST, SKIP_NULLS>;
-		return AggregateFunction({type}, type, AggregateFunction::StateSize<FirstStateVector>,
-		                         AggregateFunction::StateInitialize<FirstStateVector, OP>, OP::Update,
-		                         AggregateFunction::StateCombine<FirstStateVector, OP>,
-		                         AggregateFunction::StateVoidFinalize<FirstStateVector, OP>, nullptr, OP::Bind,
-		                         AggregateFunction::StateDestroy<FirstStateVector, OP>, nullptr, nullptr);
+		using STATE = FirstState<string_t>;
+		return AggregateFunction(
+		    {type}, type, AggregateFunction::StateSize<STATE>, AggregateFunction::StateInitialize<STATE, OP>,
+		    OP::Update, AggregateFunction::StateCombine<STATE, OP>, AggregateFunction::StateVoidFinalize<STATE, OP>,
+		    nullptr, OP::Bind, LAST ? AggregateFunction::StateDestroy<STATE, OP> : nullptr, nullptr, nullptr);
 	}
 	}
 }

package/src/duckdb/src/function/aggregate/sorted_aggregate_function.cpp

@@ -560,7 +560,8 @@ struct SortedAggregateFunction {
 		sliced.Initialize(Allocator::DefaultAllocator(), order_bind.arg_types);
 
 		//	 Reusable inner state
-		vector<data_t> agg_state(order_bind.function.state_size());
+		auto &aggr = order_bind.function;
+		vector<data_t> agg_state(aggr.state_size(aggr));
 		Vector agg_state_vec(Value::POINTER(CastPointerToValue(agg_state.data())));
 
 		// State variables
@@ -568,11 +569,11 @@ struct SortedAggregateFunction {
 		AggregateInputData aggr_bind_info(bind_info, aggr_input_data.allocator);
 
 		// Inner aggregate APIs
-		auto initialize = order_bind.function.initialize;
-		auto destructor = order_bind.function.destructor;
-		auto simple_update = order_bind.function.simple_update;
-		auto update = order_bind.function.update;
-		auto finalize = order_bind.function.finalize;
+		auto initialize = aggr.initialize;
+		auto destructor = aggr.destructor;
+		auto simple_update = aggr.simple_update;
+		auto update = aggr.update;
+		auto finalize = aggr.finalize;
 
 		auto sdata = FlatVector::GetData<SortedAggregateState *>(states);
 
@@ -631,7 +632,7 @@ struct SortedAggregateFunction {
 			}
 
 			auto scanner = make_uniq<PayloadScanner>(*global_sort);
-			initialize(agg_state.data());
+			initialize(aggr, agg_state.data());
 			while (scanner->Remaining()) {
 				chunk.Reset();
 				scanner->Scan(chunk);
@@ -648,7 +649,7 @@ struct SortedAggregateFunction {
 							destructor(agg_state_vec, aggr_bind_info, 1);
 						}
 
-						initialize(agg_state.data());
+						initialize(aggr, agg_state.data());
 					}
 					const auto input_count = MinValue(state_unprocessed[sorted], chunk.size() - consumed);
 					for (column_t col_idx = 0; col_idx < chunk.ColumnCount(); ++col_idx) {
@@ -694,7 +695,7 @@ struct SortedAggregateFunction {
 		}
 
 		for (; sorted < count; ++sorted) {
-			initialize(agg_state.data());
+			initialize(aggr, agg_state.data());
 
 			// Finalize a single value at the next offset
 			agg_state_vec.SetVectorType(states.GetVectorType());

package/src/duckdb/src/function/aggregate_function.cpp

@@ -0,0 +1,8 @@
+#include "duckdb/function/aggregate_function.hpp"
+
+namespace duckdb {
+
+AggregateFunctionInfo::~AggregateFunctionInfo() {
+}
+
+} // namespace duckdb

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

@@ -3,6 +3,7 @@
 #include "duckdb/common/pair.hpp"
 #include "duckdb/common/types/type_map.hpp"
 #include "duckdb/function/cast_rules.hpp"
+#include "duckdb/planner/collation_binding.hpp"
 #include "duckdb/main/config.hpp"
 
 namespace duckdb {
@@ -34,10 +35,18 @@ CastFunctionSet &CastFunctionSet::Get(ClientContext &context) {
 	return DBConfig::GetConfig(context).GetCastFunctions();
 }
 
+CollationBinding &CollationBinding::Get(ClientContext &context) {
+	return DBConfig::GetConfig(context).GetCollationBinding();
+}
+
 CastFunctionSet &CastFunctionSet::Get(DatabaseInstance &db) {
 	return DBConfig::GetConfig(db).GetCastFunctions();
 }
 
+CollationBinding &CollationBinding::Get(DatabaseInstance &db) {
+	return DBConfig::GetConfig(db).GetCollationBinding();
+}
+
 BoundCastInfo CastFunctionSet::GetCastFunction(const LogicalType &source, const LogicalType &target,
                                                GetCastFunctionInput &get_input) {
 	if (source == target) {
@@ -97,7 +106,7 @@ static auto RelaxedTypeMatch(type_map_t<MAP_VALUE_TYPE> &map, const LogicalType
 	case LogicalTypeId::UNION:
 		return map.find(LogicalType::UNION({{"any", LogicalType::ANY}}));
 	case LogicalTypeId::ARRAY:
-		return map.find(LogicalType::ARRAY(LogicalType::ANY));
+		return map.find(LogicalType::ARRAY(LogicalType::ANY, optional_idx()));
 	default:
 		return map.find(LogicalType::ANY);
 	}

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

@@ -100,8 +100,17 @@ bool TemplatedDecimalScaleUp(Vector &source, Vector &result, idx_t count, CastPa
 struct DecimalScaleDownOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
+		//	We need to round here, not truncate.
 		auto data = (DecimalScaleInput<INPUT_TYPE> *)dataptr;
-		return Cast::Operation<INPUT_TYPE, RESULT_TYPE>(input / data->factor);
+		//	Scale first so we don't overflow when rounding.
+		const auto scaling = data->factor / 2;
+		input /= scaling;
+		if (input < 0) {
+			input -= 1;
+		} else {
+			input += 1;
+		}
+		return Cast::Operation<INPUT_TYPE, RESULT_TYPE>(input / 2);
 	}
 };
 

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

@@ -143,6 +143,8 @@ BoundCastInfo DefaultCasts::GetDefaultCastFunction(BindCastInput &input, const L
 		return EnumCastSwitch(input, source, target);
 	case LogicalTypeId::ARRAY:
 		return ArrayCastSwitch(input, source, target);
+	case LogicalTypeId::VARINT:
+		return VarintCastSwitch(input, source, target);
 	case LogicalTypeId::AGGREGATE_STATE:
 		return AggregateStateToBlobCast;
 	default:

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

@@ -2,6 +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/varint.hpp"
 
 namespace duckdb {
 
@@ -41,6 +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::VARINT:
+		return Varint::NumericToVarintCastSwitch(source);
 	default:
 		return DefaultCasts::TryVectorNullCast;
 	}

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

@@ -6,6 +6,7 @@
 #include "duckdb/common/vector.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/function/cast/bound_cast_data.hpp"
+#include "duckdb/common/types/varint.hpp"
 
 namespace duckdb {
 
@@ -477,7 +478,7 @@ BoundCastInfo DefaultCasts::StringCastSwitch(BindCastInput &input, const Logical
 		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, timestamp_t, duckdb::TryCastErrorMessage>);
 	case LogicalTypeId::TIMESTAMP_NS:
 		return BoundCastInfo(
-		    &VectorCastHelpers::TryCastStrictLoop<string_t, timestamp_t, duckdb::TryCastToTimestampNS>);
+		    &VectorCastHelpers::TryCastStrictLoop<string_t, timestamp_ns_t, duckdb::TryCastToTimestampNS>);
 	case LogicalTypeId::TIMESTAMP_SEC:
 		return BoundCastInfo(
 		    &VectorCastHelpers::TryCastStrictLoop<string_t, timestamp_t, duckdb::TryCastToTimestampSec>);
@@ -502,10 +503,10 @@ BoundCastInfo DefaultCasts::StringCastSwitch(BindCastInput &input, const Logical
 		    ListBoundCastData::InitListLocalState);
 	case LogicalTypeId::ARRAY:
 		// the second argument allows for a secondary casting function to be passed in the CastParameters
-		return BoundCastInfo(
-		    &StringToNestedTypeCast<VectorStringToArray>,
-		    ArrayBoundCastData::BindArrayToArrayCast(input, LogicalType::ARRAY(LogicalType::VARCHAR), target),
-		    ArrayBoundCastData::InitArrayLocalState);
+		return BoundCastInfo(&StringToNestedTypeCast<VectorStringToArray>,
+		                     ArrayBoundCastData::BindArrayToArrayCast(
+		                         input, LogicalType::ARRAY(LogicalType::VARCHAR, optional_idx()), target),
+		                     ArrayBoundCastData::InitArrayLocalState);
 	case LogicalTypeId::STRUCT:
 		return BoundCastInfo(&StringToNestedTypeCast<VectorStringToStruct>,
 		                     StructBoundCastData::BindStructToStructCast(input, InitVarcharStructType(target), target),
@@ -515,6 +516,8 @@ BoundCastInfo DefaultCasts::StringCastSwitch(BindCastInput &input, const Logical
 		                     MapBoundCastData::BindMapToMapCast(
 		                         input, LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR), target),
 		                     InitMapCastLocalState);
+	case LogicalTypeId::VARINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastStringLoop<string_t, string_t, TryCastToVarInt>);
 	default:
 		return VectorStringCastNumericSwitch(input, source, target);
 	}

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

@@ -14,7 +14,7 @@ BoundCastInfo DefaultCasts::DateCastSwitch(BindCastInput &input, const LogicalTy
 		// date to timestamp
 		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<date_t, timestamp_t, duckdb::TryCast>);
 	case LogicalTypeId::TIMESTAMP_NS:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<date_t, timestamp_t, duckdb::TryCastToTimestampNS>);
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<date_t, timestamp_ns_t, duckdb::TryCastToTimestampNS>);
 	case LogicalTypeId::TIMESTAMP_SEC:
 		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<date_t, timestamp_t, duckdb::TryCastToTimestampSec>);
 	case LogicalTypeId::TIMESTAMP_MS:
@@ -113,7 +113,7 @@ BoundCastInfo DefaultCasts::TimestampNsCastSwitch(BindCastInput &input, const Lo
 	switch (target.id()) {
 	case LogicalTypeId::VARCHAR:
 		// timestamp (ns) to varchar
-		return BoundCastInfo(&VectorCastHelpers::StringCast<timestamp_t, duckdb::CastFromTimestampNS>);
+		return BoundCastInfo(&VectorCastHelpers::StringCast<timestamp_ns_t, duckdb::StringCast>);
 	case LogicalTypeId::DATE:
 		// timestamp (ns) to date
 		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, date_t, duckdb::CastTimestampNsToDate>);

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

@@ -171,7 +171,7 @@ unique_ptr<BoundCastData> BindUnionToUnionCast(BindCastInput &input, const Logic
 			auto &target_member_name = UnionType::GetMemberName(target, target_idx);
 
 			// found a matching member
-			if (source_member_name == target_member_name) {
+			if (StringUtil::CIEquals(source_member_name, target_member_name)) {
 				auto &target_member_type = UnionType::GetMemberType(target, target_idx);
 				tag_map[source_idx] = target_idx;
 				member_casts.push_back(input.GetCastFunction(source_member_type, target_member_type));