duckdb 0.10.1-dev9.0 → 0.10.2-dev0.0

package/src/duckdb/src/common/vector_operations/vector_hash.cpp

@@ -182,13 +182,18 @@ template <bool HAS_RSEL, bool FIRST_HASH>
 static inline void ArrayLoopHash(Vector &input, Vector &hashes, const SelectionVector *rsel, idx_t count) {
 	auto hdata = FlatVector::GetData<hash_t>(hashes);
 
+	if (input.GetVectorType() != VectorType::CONSTANT_VECTOR || input.GetVectorType() != VectorType::FLAT_VECTOR) {
+		input.Flatten(count);
+	}
+
 	UnifiedVectorFormat idata;
 	input.ToUnifiedFormat(count, idata);
 
 	// Hash the children into a temporary
 	auto &child = ArrayVector::GetEntry(input);
 	auto array_size = ArrayType::GetSize(input.GetType());
-	auto child_count = array_size * count;
+	auto is_constant = input.GetVectorType() == VectorType::CONSTANT_VECTOR;
+	auto child_count = array_size * (is_constant ? 1 : count);
 
 	Vector child_hashes(LogicalType::HASH, child_count);
 	if (child_count > 0) {
@@ -197,12 +202,18 @@ static inline void ArrayLoopHash(Vector &input, Vector &hashes, const SelectionV
 	}
 	auto chdata = FlatVector::GetData<hash_t>(child_hashes);
 
-	// Combine hashes for every array
-	// TODO: Branch on FIRST_HASH and HAS_RSEL
-	for (idx_t i = 0; i < count; i++) {
-		for (idx_t j = i * array_size; j < (i + 1) * array_size; j++) {
-			hdata[i] = CombineHashScalar(hdata[i], chdata[j]);
+	for (idx_t i = 0; i < count; ++i) {
+		const auto ridx = HAS_RSEL ? rsel->get_index(i) : i;
+		const auto lidx = idata.sel->get_index(ridx);
+		const auto offset = lidx * array_size;
+		if (idata.validity.RowIsValid(lidx)) {
+			for (idx_t j = 0; j < array_size; j++) {
+				hdata[ridx] = CombineHashScalar(hdata[ridx], chdata[offset + j]);
+			}
+		} else if (FIRST_HASH) {
+			hdata[ridx] = HashOp::NULL_HASH;
 		}
+		// Empty or NULL non-first elements have no effect.
 	}
 }
 

package/src/duckdb/src/core_functions/aggregate/algebraic/ub_duckdb_aggr_algebraic.cpp

@@ -0,0 +1,5 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/core_functions/aggregate/algebraic/avg.cpp>
+#include </Users/carlo/duckdb/src/core_functions/aggregate/algebraic/covar.cpp>
+#include </Users/carlo/duckdb/src/core_functions/aggregate/algebraic/stddev.cpp>
+#include </Users/carlo/duckdb/src/core_functions/aggregate/algebraic/corr.cpp>

package/src/duckdb/src/core_functions/aggregate/distributive/arg_min_max.cpp

@@ -1,6 +1,7 @@
 #include "duckdb/core_functions/aggregate/distributive_functions.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
+#include "duckdb/function/cast/cast_function_set.hpp"
 #include "duckdb/function/function_set.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/planner/expression/bound_comparison_expression.hpp"
@@ -70,7 +71,7 @@ void ArgMinMaxStateBase::AssignValue(string_t &target, string_t new_value) {
 		auto ptr = new char[len];
 		memcpy(ptr, new_value.GetData(), len);
 
-		target = string_t(ptr, len);
+		target = string_t(ptr, UnsafeNumericCast<uint32_t>(len));
 	}
 }
 
@@ -190,7 +191,7 @@ struct VectorArgMinMaxBase : ArgMinMaxBase<COMPARATOR, IGNORE_NULL> {
 		}
 		state.arg_null = arg_null;
 		if (!arg_null) {
-			sel_t selv = idx;
+			sel_t selv = UnsafeNumericCast<sel_t>(idx);
 			SelectionVector sel(&selv);
 			VectorOperations::Copy(arg, *state.arg, sel, 1, 0, 0);
 		}
@@ -284,6 +285,8 @@ AggregateFunction GetVectorArgMinMaxFunctionBy(const LogicalType &by_type, const
 		return GetVectorArgMinMaxFunctionInternal<OP, ARG_TYPE, int32_t>(by_type, type);
 	case PhysicalType::INT64:
 		return GetVectorArgMinMaxFunctionInternal<OP, ARG_TYPE, int64_t>(by_type, type);
+	case PhysicalType::INT128:
+		return GetVectorArgMinMaxFunctionInternal<OP, ARG_TYPE, hugeint_t>(by_type, type);
 	case PhysicalType::DOUBLE:
 		return GetVectorArgMinMaxFunctionInternal<OP, ARG_TYPE, double>(by_type, type);
 	case PhysicalType::VARCHAR:
@@ -294,9 +297,9 @@ AggregateFunction GetVectorArgMinMaxFunctionBy(const LogicalType &by_type, const
 }
 
 static const vector<LogicalType> ArgMaxByTypes() {
-	vector<LogicalType> types = {LogicalType::INTEGER,      LogicalType::BIGINT, LogicalType::DOUBLE,
-	                             LogicalType::VARCHAR,      LogicalType::DATE,   LogicalType::TIMESTAMP,
-	                             LogicalType::TIMESTAMP_TZ, LogicalType::BLOB};
+	vector<LogicalType> types = {LogicalType::INTEGER,   LogicalType::BIGINT,       LogicalType::HUGEINT,
+	                             LogicalType::DOUBLE,    LogicalType::VARCHAR,      LogicalType::DATE,
+	                             LogicalType::TIMESTAMP, LogicalType::TIMESTAMP_TZ, LogicalType::BLOB};
 	return types;
 }
 
@@ -328,12 +331,14 @@ AggregateFunction GetArgMinMaxFunctionBy(const LogicalType &by_type, const Logic
 		return GetArgMinMaxFunctionInternal<OP, ARG_TYPE, int32_t>(by_type, type);
 	case PhysicalType::INT64:
 		return GetArgMinMaxFunctionInternal<OP, ARG_TYPE, int64_t>(by_type, type);
+	case PhysicalType::INT128:
+		return GetArgMinMaxFunctionInternal<OP, ARG_TYPE, hugeint_t>(by_type, type);
 	case PhysicalType::DOUBLE:
 		return GetArgMinMaxFunctionInternal<OP, ARG_TYPE, double>(by_type, type);
 	case PhysicalType::VARCHAR:
 		return GetArgMinMaxFunctionInternal<OP, ARG_TYPE, string_t>(by_type, type);
 	default:
-		throw InternalException("Unimplemented arg_min/arg_max aggregate");
+		throw InternalException("Unimplemented arg_min/arg_max by aggregate");
 	}
 }
 
@@ -365,6 +370,25 @@ static unique_ptr<FunctionData> BindDecimalArgMinMax(ClientContext &context, Agg
                                                      vector<unique_ptr<Expression>> &arguments) {
 	auto decimal_type = arguments[0]->return_type;
 	auto by_type = arguments[1]->return_type;
+
+	// To avoid a combinatorial explosion, cast the ordering argument to one from the list
+	auto by_types = ArgMaxByTypes();
+	idx_t best_target = DConstants::INVALID_INDEX;
+	int64_t lowest_cost = NumericLimits<int64_t>::Maximum();
+	for (idx_t i = 0; i < by_types.size(); ++i) {
+		auto cast_cost = CastFunctionSet::Get(context).ImplicitCastCost(by_type, by_types[i]);
+		if (cast_cost < 0) {
+			continue;
+		}
+		if (cast_cost < lowest_cost) {
+			best_target = i;
+		}
+	}
+
+	if (best_target != DConstants::INVALID_INDEX) {
+		by_type = by_types[best_target];
+	}
+
 	auto name = std::move(function.name);
 	function = GetDecimalArgMinMaxFunction<OP>(by_type, decimal_type);
 	function.name = std::move(name);

package/src/duckdb/src/core_functions/aggregate/distributive/bitagg.cpp

@@ -146,7 +146,7 @@ struct BitStringBitwiseOperation : public BitwiseOperation {
 			auto ptr = new char[len];
 			memcpy(ptr, input.GetData(), len);
 
-			state.value = string_t(ptr, len);
+			state.value = string_t(ptr, UnsafeNumericCast<uint32_t>(len));
 		}
 	}
 

package/src/duckdb/src/core_functions/aggregate/distributive/bitstring_agg.cpp

@@ -64,6 +64,10 @@ struct BitStringAggOperation {
 			}
 			state.min = bind_agg_data.min.GetValue<INPUT_TYPE>();
 			state.max = bind_agg_data.max.GetValue<INPUT_TYPE>();
+			if (state.min > state.max) {
+				throw InvalidInputException("Invalid explicit bitstring range: Minimum (%s) > maximum (%s)",
+				                            NumericHelper::ToString(state.min), NumericHelper::ToString(state.max));
+			}
 			idx_t bit_range =
 			    GetRange(bind_agg_data.min.GetValue<INPUT_TYPE>(), bind_agg_data.max.GetValue<INPUT_TYPE>());
 			if (bit_range > MAX_BIT_RANGE) {
@@ -72,7 +76,8 @@ struct BitStringAggOperation {
 				    NumericHelper::ToString(state.min), NumericHelper::ToString(state.max));
 			}
 			idx_t len = Bit::ComputeBitstringLen(bit_range);
-			auto target = len > string_t::INLINE_LENGTH ? string_t(new char[len], len) : string_t(len);
+			auto target = len > string_t::INLINE_LENGTH ? string_t(new char[len], UnsafeNumericCast<uint32_t>(len))
+			                                            : string_t(UnsafeNumericCast<uint32_t>(len));
 			Bit::SetEmptyBitString(target, bit_range);
 
 			state.value = target;
@@ -95,7 +100,9 @@ struct BitStringAggOperation {
 
 	template <class INPUT_TYPE>
 	static idx_t GetRange(INPUT_TYPE min, INPUT_TYPE max) {
-		D_ASSERT(max >= min);
+		if (min > max) {
+			throw InvalidInputException("Invalid explicit bitstring range: Minimum (%d) > maximum (%d)", min, max);
+		}
 		INPUT_TYPE result;
 		if (!TrySubtractOperator::Operation(max, min, result)) {
 			return NumericLimits<idx_t>::Maximum();
@@ -136,7 +143,7 @@ struct BitStringAggOperation {
 			auto len = input.GetSize();
 			auto ptr = new char[len];
 			memcpy(ptr, input.GetData(), len);
-			state.value = string_t(ptr, len);
+			state.value = string_t(ptr, UnsafeNumericCast<uint32_t>(len));
 		}
 	}
 
@@ -178,7 +185,7 @@ idx_t BitStringAggOperation::GetRange(hugeint_t min, hugeint_t max) {
 		return NumericLimits<idx_t>::Maximum();
 	}
 	idx_t range;
-	if (!Hugeint::TryCast(result + 1, range)) {
+	if (!Hugeint::TryCast(result + 1, range) || result == NumericLimits<hugeint_t>::Maximum()) {
 		return NumericLimits<idx_t>::Maximum();
 	}
 	return range;
@@ -201,7 +208,7 @@ idx_t BitStringAggOperation::GetRange(uhugeint_t min, uhugeint_t max) {
 		return NumericLimits<idx_t>::Maximum();
 	}
 	idx_t range;
-	if (!Uhugeint::TryCast(result + 1, range)) {
+	if (!Uhugeint::TryCast(result + 1, range) || result == NumericLimits<uhugeint_t>::Maximum()) {
 		return NumericLimits<idx_t>::Maximum();
 	}
 	return range;

package/src/duckdb/src/core_functions/aggregate/distributive/minmax.cpp

@@ -166,7 +166,7 @@ struct StringMinMaxBase : public MinMaxBase {
 			auto ptr = new char[len];
 			memcpy(ptr, input.GetData(), len);
 
-			state.value = string_t(ptr, len);
+			state.value = string_t(ptr, UnsafeNumericCast<uint32_t>(len));
 		}
 	}
 
@@ -457,7 +457,7 @@ struct VectorMinMaxBase {
 			state.value = new Vector(input.GetType());
 			state.value->SetVectorType(VectorType::CONSTANT_VECTOR);
 		}
-		sel_t selv = idx;
+		sel_t selv = UnsafeNumericCast<sel_t>(idx);
 		SelectionVector sel(&selv);
 		VectorOperations::Copy(input, *state.value, sel, 1, 0, 0);
 	}

package/src/duckdb/src/core_functions/aggregate/distributive/string_agg.cpp

@@ -113,7 +113,8 @@ struct StringAggFunction {
 			// source is not set: skip combining
 			return;
 		}
-		PerformOperation(target, string_t(source.dataptr, source.size), aggr_input_data.bind_data);
+		PerformOperation(target, string_t(source.dataptr, UnsafeNumericCast<uint32_t>(source.size)),
+		                 aggr_input_data.bind_data);
 	}
 };
 

package/src/duckdb/src/core_functions/aggregate/distributive/ub_duckdb_aggr_distributive.cpp

@@ -0,0 +1,13 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/core_functions/aggregate/distributive/approx_count.cpp>
+#include </Users/carlo/duckdb/src/core_functions/aggregate/distributive/arg_min_max.cpp>
+#include </Users/carlo/duckdb/src/core_functions/aggregate/distributive/bitagg.cpp>
+#include </Users/carlo/duckdb/src/core_functions/aggregate/distributive/bitstring_agg.cpp>
+#include </Users/carlo/duckdb/src/core_functions/aggregate/distributive/bool.cpp>
+#include </Users/carlo/duckdb/src/core_functions/aggregate/distributive/entropy.cpp>
+#include </Users/carlo/duckdb/src/core_functions/aggregate/distributive/kurtosis.cpp>
+#include </Users/carlo/duckdb/src/core_functions/aggregate/distributive/minmax.cpp>
+#include </Users/carlo/duckdb/src/core_functions/aggregate/distributive/product.cpp>
+#include </Users/carlo/duckdb/src/core_functions/aggregate/distributive/skew.cpp>
+#include </Users/carlo/duckdb/src/core_functions/aggregate/distributive/string_agg.cpp>
+#include </Users/carlo/duckdb/src/core_functions/aggregate/distributive/sum.cpp>

package/src/duckdb/src/core_functions/aggregate/holistic/mode.cpp

@@ -19,7 +19,8 @@ struct hash<duckdb::interval_t> {
 	inline size_t operator()(const duckdb::interval_t &val) const {
 		int64_t months, days, micros;
 		val.Normalize(months, days, micros);
-		return hash<int32_t> {}(days) ^ hash<int32_t> {}(months) ^ hash<int64_t> {}(micros);
+		return hash<int32_t> {}(duckdb::UnsafeNumericCast<int32_t>(days)) ^
+		       hash<int32_t> {}(duckdb::UnsafeNumericCast<int32_t>(months)) ^ hash<int64_t> {}(micros);
 	}
 };
 

package/src/duckdb/src/core_functions/aggregate/holistic/quantile.cpp

@@ -21,12 +21,6 @@
 
 namespace duckdb {
 
-// Hugeint arithmetic
-static hugeint_t MultiplyByDouble(const hugeint_t &h, const double &d) {
-	D_ASSERT(d >= 0 && d <= 1);
-	return Hugeint::Convert(Hugeint::Cast<double>(h) * d);
-}
-
 // Interval arithmetic
 static interval_t MultiplyByDouble(const interval_t &i, const double &d) { // NOLINT
 	D_ASSERT(d >= 0 && d <= 1);
@@ -189,8 +183,7 @@ timestamp_t CastInterpolation::Interpolate(const timestamp_t &lo, const double d
 
 template <>
 hugeint_t CastInterpolation::Interpolate(const hugeint_t &lo, const double d, const hugeint_t &hi) {
-	const hugeint_t delta = hi - lo;
-	return lo + MultiplyByDouble(delta, d);
+	return Hugeint::Convert(Interpolate(Hugeint::Cast<double>(lo), d, Hugeint::Cast<double>(hi)));
 }
 
 template <>
@@ -1263,7 +1256,7 @@ struct MadAccessor {
 	}
 
 	inline RESULT_TYPE operator()(const INPUT_TYPE &input) const {
-		const auto delta = input - median;
+		const RESULT_TYPE delta = input - UnsafeNumericCast<RESULT_TYPE>(median);
 		return TryAbsOperator::Operation<RESULT_TYPE, RESULT_TYPE>(delta);
 	}
 };

package/src/duckdb/src/core_functions/aggregate/holistic/ub_duckdb_aggr_holistic.cpp

@@ -0,0 +1,5 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/core_functions/aggregate/holistic/quantile.cpp>
+#include </Users/carlo/duckdb/src/core_functions/aggregate/holistic/mode.cpp>
+#include </Users/carlo/duckdb/src/core_functions/aggregate/holistic/approximate_quantile.cpp>
+#include </Users/carlo/duckdb/src/core_functions/aggregate/holistic/reservoir_quantile.cpp>

package/src/duckdb/src/core_functions/aggregate/nested/ub_duckdb_aggr_nested.cpp

@@ -0,0 +1,3 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/core_functions/aggregate/nested/list.cpp>
+#include </Users/carlo/duckdb/src/core_functions/aggregate/nested/histogram.cpp>

package/src/duckdb/src/core_functions/aggregate/regression/ub_duckdb_aggr_regr.cpp

@@ -0,0 +1,8 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/core_functions/aggregate/regression/regr_avg.cpp>
+#include </Users/carlo/duckdb/src/core_functions/aggregate/regression/regr_count.cpp>
+#include </Users/carlo/duckdb/src/core_functions/aggregate/regression/regr_slope.cpp>
+#include </Users/carlo/duckdb/src/core_functions/aggregate/regression/regr_r2.cpp>
+#include </Users/carlo/duckdb/src/core_functions/aggregate/regression/regr_sxx_syy.cpp>
+#include </Users/carlo/duckdb/src/core_functions/aggregate/regression/regr_sxy.cpp>
+#include </Users/carlo/duckdb/src/core_functions/aggregate/regression/regr_intercept.cpp>

package/src/duckdb/src/core_functions/function_list.cpp

@@ -375,6 +375,7 @@ static StaticFunctionDefinition internal_functions[] = {
 	DUCKDB_SCALAR_FUNCTION(UnionExtractFun),
 	DUCKDB_SCALAR_FUNCTION(UnionTagFun),
 	DUCKDB_SCALAR_FUNCTION(UnionValueFun),
+	DUCKDB_SCALAR_FUNCTION(UnpivotListFun),
 	DUCKDB_SCALAR_FUNCTION(UUIDFun),
 	DUCKDB_AGGREGATE_FUNCTION(VarPopFun),
 	DUCKDB_AGGREGATE_FUNCTION(VarSampFun),

package/src/duckdb/src/core_functions/scalar/bit/bitstring.cpp

@@ -41,7 +41,7 @@ struct GetBitOperator {
 			throw OutOfRangeException("bit index %s out of valid range (0..%s)", NumericHelper::ToString(n),
 			                          NumericHelper::ToString(Bit::BitLength(input) - 1));
 		}
-		return Bit::GetBit(input, n);
+		return UnsafeNumericCast<TR>(Bit::GetBit(input, n));
 	}
 };
 
@@ -85,7 +85,7 @@ struct BitPositionOperator {
 		if (substring.GetSize() > input.GetSize()) {
 			return 0;
 		}
-		return Bit::BitPosition(substring, input);
+		return UnsafeNumericCast<TR>(Bit::BitPosition(substring, input));
 	}
 };
 

package/src/duckdb/src/core_functions/scalar/bit/ub_duckdb_func_bit.cpp

@@ -0,0 +1,2 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/core_functions/scalar/bit/bitstring.cpp>

package/src/duckdb/src/core_functions/scalar/blob/ub_duckdb_func_blob.cpp

@@ -0,0 +1,3 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/core_functions/scalar/blob/base64.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/blob/encode.cpp>

package/src/duckdb/src/core_functions/scalar/date/date_diff.cpp

@@ -202,22 +202,30 @@ int64_t DateDiff::MicrosecondsOperator::Operation(timestamp_t startdate, timesta
 
 template <>
 int64_t DateDiff::MillisecondsOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
+	D_ASSERT(Timestamp::IsFinite(startdate));
+	D_ASSERT(Timestamp::IsFinite(enddate));
 	return Timestamp::GetEpochMs(enddate) - Timestamp::GetEpochMs(startdate);
 }
 
 template <>
 int64_t DateDiff::SecondsOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
+	D_ASSERT(Timestamp::IsFinite(startdate));
+	D_ASSERT(Timestamp::IsFinite(enddate));
 	return Timestamp::GetEpochSeconds(enddate) - Timestamp::GetEpochSeconds(startdate);
 }
 
 template <>
 int64_t DateDiff::MinutesOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
+	D_ASSERT(Timestamp::IsFinite(startdate));
+	D_ASSERT(Timestamp::IsFinite(enddate));
 	return Timestamp::GetEpochSeconds(enddate) / Interval::SECS_PER_MINUTE -
 	       Timestamp::GetEpochSeconds(startdate) / Interval::SECS_PER_MINUTE;
 }
 
 template <>
 int64_t DateDiff::HoursOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
+	D_ASSERT(Timestamp::IsFinite(startdate));
+	D_ASSERT(Timestamp::IsFinite(enddate));
 	return Timestamp::GetEpochSeconds(enddate) / Interval::SECS_PER_HOUR -
 	       Timestamp::GetEpochSeconds(startdate) / Interval::SECS_PER_HOUR;
 }

package/src/duckdb/src/core_functions/scalar/date/date_part.cpp

@@ -395,8 +395,11 @@ struct DatePart {
 		static void Inverse(DataChunk &input, ExpressionState &state, Vector &result) {
 			D_ASSERT(input.ColumnCount() == 1);
 
-			UnaryExecutor::Execute<int64_t, timestamp_t>(input.data[0], result, input.size(),
-			                                             [&](int64_t input) { return Timestamp::FromEpochMs(input); });
+			UnaryExecutor::Execute<int64_t, timestamp_t>(input.data[0], result, input.size(), [&](int64_t input) {
+				// milisecond amounts provided to epoch_ms should never be considered infinite
+				// instead such values will just throw when converted to microseconds
+				return Timestamp::FromEpochMsPossiblyInfinite(input);
+			});
 		}
 	};
 
@@ -501,7 +504,7 @@ struct DatePart {
 			auto time = Time::NormalizeTimeTZ(timetz);
 			date_t date(0);
 			time = Interval::Add(time, interval, date);
-			auto offset = interval.micros / Interval::MICROS_PER_SEC;
+			auto offset = UnsafeNumericCast<int32_t>(interval.micros / Interval::MICROS_PER_SEC);
 			return TR(time, offset);
 		}
 
@@ -999,11 +1002,13 @@ int64_t DatePart::YearWeekOperator::Operation(dtime_tz_t input) {
 
 template <>
 int64_t DatePart::EpochNanosecondsOperator::Operation(timestamp_t input) {
+	D_ASSERT(Timestamp::IsFinite(input));
 	return Timestamp::GetEpochNanoSeconds(input);
 }
 
 template <>
 int64_t DatePart::EpochNanosecondsOperator::Operation(date_t input) {
+	D_ASSERT(Date::IsFinite(input));
 	return Date::EpochNanoseconds(input);
 }
 
@@ -1032,6 +1037,12 @@ int64_t DatePart::EpochMicrosecondsOperator::Operation(interval_t input) {
 	return Interval::GetMicro(input);
 }
 
+template <>
+int64_t DatePart::EpochMillisOperator::Operation(timestamp_t input) {
+	D_ASSERT(Timestamp::IsFinite(input));
+	return Timestamp::GetEpochMs(input);
+}
+
 template <>
 int64_t DatePart::EpochMicrosecondsOperator::Operation(dtime_t input) {
 	return input.micros;
@@ -1064,6 +1075,7 @@ int64_t DatePart::EpochMillisOperator::Operation(dtime_tz_t input) {
 
 template <>
 int64_t DatePart::MicrosecondsOperator::Operation(timestamp_t input) {
+	D_ASSERT(Timestamp::IsFinite(input));
 	auto time = Timestamp::GetTime(input);
 	// remove everything but the second & microsecond part
 	return time.micros % Interval::MICROS_PER_MINUTE;
@@ -1088,6 +1100,7 @@ int64_t DatePart::MicrosecondsOperator::Operation(dtime_tz_t input) {
 
 template <>
 int64_t DatePart::MillisecondsOperator::Operation(timestamp_t input) {
+	D_ASSERT(Timestamp::IsFinite(input));
 	return MicrosecondsOperator::Operation<timestamp_t, int64_t>(input) / Interval::MICROS_PER_MSEC;
 }
 
@@ -1108,6 +1121,7 @@ int64_t DatePart::MillisecondsOperator::Operation(dtime_tz_t input) {
 
 template <>
 int64_t DatePart::SecondsOperator::Operation(timestamp_t input) {
+	D_ASSERT(Timestamp::IsFinite(input));
 	return MicrosecondsOperator::Operation<timestamp_t, int64_t>(input) / Interval::MICROS_PER_SEC;
 }
 
@@ -1128,6 +1142,7 @@ int64_t DatePart::SecondsOperator::Operation(dtime_tz_t input) {
 
 template <>
 int64_t DatePart::MinutesOperator::Operation(timestamp_t input) {
+	D_ASSERT(Timestamp::IsFinite(input));
 	auto time = Timestamp::GetTime(input);
 	// remove the hour part, and truncate to minutes
 	return (time.micros % Interval::MICROS_PER_HOUR) / Interval::MICROS_PER_MINUTE;
@@ -1152,6 +1167,7 @@ int64_t DatePart::MinutesOperator::Operation(dtime_tz_t input) {
 
 template <>
 int64_t DatePart::HoursOperator::Operation(timestamp_t input) {
+	D_ASSERT(Timestamp::IsFinite(input));
 	return Timestamp::GetTime(input).micros / Interval::MICROS_PER_HOUR;
 }
 
@@ -1172,6 +1188,7 @@ int64_t DatePart::HoursOperator::Operation(dtime_tz_t input) {
 
 template <>
 double DatePart::EpochOperator::Operation(timestamp_t input) {
+	D_ASSERT(Timestamp::IsFinite(input));
 	return Timestamp::GetEpochMicroSeconds(input) / double(Interval::MICROS_PER_SEC);
 }
 
@@ -1218,6 +1235,7 @@ unique_ptr<BaseStatistics> DatePart::EpochOperator::PropagateStatistics<dtime_t>
 
 template <>
 int64_t DatePart::EraOperator::Operation(timestamp_t input) {
+	D_ASSERT(Timestamp::IsFinite(input));
 	return EraOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
 }
 
@@ -1407,6 +1425,7 @@ void DatePart::StructOperator::Operation(bigint_vec &bigint_values, double_vec &
 template <>
 void DatePart::StructOperator::Operation(bigint_vec &bigint_values, double_vec &double_values, const timestamp_t &input,
                                          const idx_t idx, const part_mask_t mask) {
+	D_ASSERT(Timestamp::IsFinite(input));
 	date_t d;
 	dtime_t t;
 	Timestamp::Convert(input, d, t);

package/src/duckdb/src/core_functions/scalar/date/make_date.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/core_functions/scalar/date_functions.hpp"
+#include "duckdb/common/operator/cast_operators.hpp"
 #include "duckdb/common/types/date.hpp"
 #include "duckdb/common/types/time.hpp"
 #include "duckdb/common/types/timestamp.hpp"
@@ -13,7 +14,8 @@ namespace duckdb {
 struct MakeDateOperator {
 	template <typename YYYY, typename MM, typename DD, typename RESULT_TYPE>
 	static RESULT_TYPE Operation(YYYY yyyy, MM mm, DD dd) {
-		return Date::FromDate(yyyy, mm, dd);
+		return Date::FromDate(Cast::Operation<YYYY, int32_t>(yyyy), Cast::Operation<MM, int32_t>(mm),
+		                      Cast::Operation<DD, int32_t>(dd));
 	}
 };
 
@@ -28,6 +30,16 @@ static void ExecuteMakeDate(DataChunk &input, ExpressionState &state, Vector &re
 	                                          MakeDateOperator::Operation<T, T, T, date_t>);
 }
 
+template <typename T>
+static date_t FromDateCast(T year, T month, T day) {
+	date_t result;
+	if (!Date::TryFromDate(Cast::Operation<T, int32_t>(year), Cast::Operation<T, int32_t>(month),
+	                       Cast::Operation<T, int32_t>(day), result)) {
+		throw ConversionException("Date out of range: %d-%d-%d", year, month, day);
+	}
+	return result;
+}
+
 template <typename T>
 static void ExecuteStructMakeDate(DataChunk &input, ExpressionState &state, Vector &result) {
 	// this should be guaranteed by the binder
@@ -40,18 +52,28 @@ static void ExecuteStructMakeDate(DataChunk &input, ExpressionState &state, Vect
 	auto &mm = *children[1];
 	auto &dd = *children[2];
 
-	TernaryExecutor::Execute<T, T, T, date_t>(yyyy, mm, dd, result, input.size(), Date::FromDate);
+	TernaryExecutor::Execute<T, T, T, date_t>(yyyy, mm, dd, result, input.size(), FromDateCast<T>);
 }
 
 struct MakeTimeOperator {
 	template <typename HH, typename MM, typename SS, typename RESULT_TYPE>
 	static RESULT_TYPE Operation(HH hh, MM mm, SS ss) {
-		int64_t secs = ss;
-		int64_t micros = std::round((ss - secs) * Interval::MICROS_PER_SEC);
-		if (!Time::IsValidTime(hh, mm, secs, micros)) {
-			throw ConversionException("Time out of range: %d:%d:%d.%d", hh, mm, secs, micros);
+
+		auto hh_32 = Cast::Operation<HH, int32_t>(hh);
+		auto mm_32 = Cast::Operation<MM, int32_t>(mm);
+		// Have to check this separately because safe casting of DOUBLE => INT32 can round.
+		int32_t ss_32 = 0;
+		if (ss < 0 || ss > Interval::SECS_PER_MINUTE) {
+			ss_32 = Cast::Operation<SS, int32_t>(ss);
+		} else {
+			ss_32 = UnsafeNumericCast<int32_t>(ss);
+		}
+		auto micros = UnsafeNumericCast<int32_t>(std::round((ss - ss_32) * Interval::MICROS_PER_SEC));
+
+		if (!Time::IsValidTime(hh_32, mm_32, ss_32, micros)) {
+			throw ConversionException("Time out of range: %d:%d:%d.%d", hh_32, mm_32, ss_32, micros);
 		}
-		return Time::FromTime(hh, mm, secs, micros);
+		return Time::FromTime(hh_32, mm_32, ss_32, micros);
 	}
 };
 

package/src/duckdb/src/core_functions/scalar/date/to_interval.cpp

@@ -81,7 +81,9 @@ struct ToWeeksOperator {
 	static inline TR Operation(TA input) {
 		interval_t result;
 		result.months = 0;
-		result.days = input * 7;
+		if (!TryMultiplyOperator::Operation<int32_t, int32_t, int32_t>(input, Interval::DAYS_PER_WEEK, result.days)) {
+			throw OutOfRangeException("Interval value %d weeks out of range", input);
+		}
 		result.micros = 0;
 		return result;
 	}

package/src/duckdb/src/core_functions/scalar/date/ub_duckdb_func_date.cpp

@@ -0,0 +1,12 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/core_functions/scalar/date/age.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/date/current.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/date/epoch.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/date/date_diff.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/date/date_part.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/date/date_sub.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/date/date_trunc.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/date/make_date.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/date/strftime.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/date/time_bucket.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/date/to_interval.cpp>

package/src/duckdb/src/core_functions/scalar/debug/ub_duckdb_func_debug.cpp

@@ -0,0 +1,2 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/core_functions/scalar/debug/vector_type.cpp>

package/src/duckdb/src/core_functions/scalar/enum/ub_duckdb_func_enum.cpp

@@ -0,0 +1,2 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/core_functions/scalar/enum/enum_functions.cpp>

package/src/duckdb/src/core_functions/scalar/generic/ub_duckdb_func_generic.cpp

@@ -0,0 +1,9 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/core_functions/scalar/generic/alias.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/generic/current_setting.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/generic/error.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/generic/hash.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/generic/least.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/generic/stats.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/generic/typeof.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/generic/system_functions.cpp>