duckdb 0.10.3-dev3.0 → 0.10.3-dev8.0

package/src/duckdb/src/common/operator/cast_operators.cpp

@@ -1142,7 +1142,7 @@ timestamp_t CastTimestampUsToMs::Operation(timestamp_t input) {
 	if (!Timestamp::IsFinite(input)) {
 		return input;
 	}
-	timestamp_t cast_timestamp(Timestamp::GetEpochMs(input));
+	timestamp_t cast_timestamp(Timestamp::GetEpochRounded(input, Interval::MICROS_PER_MSEC));
 	return cast_timestamp;
 }
 
@@ -1160,7 +1160,7 @@ timestamp_t CastTimestampUsToSec::Operation(timestamp_t input) {
 	if (!Timestamp::IsFinite(input)) {
 		return input;
 	}
-	timestamp_t cast_timestamp(Timestamp::GetEpochSeconds(input));
+	timestamp_t cast_timestamp(Timestamp::GetEpochRounded(input, Interval::MICROS_PER_SEC));
 	return cast_timestamp;
 }
 
@@ -1279,10 +1279,7 @@ bool TryCastToTimestampMS::Operation(string_t input, timestamp_t &result, bool s
 	if (!TryCast::Operation<string_t, timestamp_t>(input, result, strict)) {
 		return false;
 	}
-	if (!Timestamp::IsFinite(result)) {
-		return true;
-	}
-	result = Timestamp::GetEpochMs(result);
+	result = CastTimestampUsToMs::Operation<timestamp_t, timestamp_t>(result);
 	return true;
 }
 
@@ -1291,10 +1288,7 @@ bool TryCastToTimestampSec::Operation(string_t input, timestamp_t &result, bool
 	if (!TryCast::Operation<string_t, timestamp_t>(input, result, strict)) {
 		return false;
 	}
-	if (!Timestamp::IsFinite(result)) {
-		return true;
-	}
-	result = Timestamp::GetEpochSeconds(result);
+	result = CastTimestampUsToSec::Operation<timestamp_t, timestamp_t>(result);
 	return true;
 }
 
@@ -1588,17 +1582,18 @@ bool TryCastErrorMessage::Operation(string_t input, interval_t &result, CastPara
 // when that value is full, we perform a HUGEINT multiplication to flush it into the hugeint
 // this takes the number of HUGEINT multiplications down from [0-38] to [0-2]
 
-template <typename T, typename OP>
+template <typename T, typename OP, typename INTERMEDIATE_T>
 struct HugeIntCastData {
 	using ResultType = T;
+	using IntermediateType = INTERMEDIATE_T;
 	using Operation = OP;
 	ResultType result;
-	int64_t intermediate;
+	IntermediateType intermediate;
 	uint8_t digits;
 
 	ResultType decimal;
 	uint16_t decimal_total_digits;
-	int64_t decimal_intermediate;
+	ResultType decimal_intermediate;
 	uint16_t decimal_intermediate_digits;
 
 	bool Flush() {
@@ -1647,7 +1642,8 @@ struct HugeIntegerCastOperation {
 	template <class T, bool NEGATIVE>
 	static bool HandleDigit(T &state, uint8_t digit) {
 		if (NEGATIVE) {
-			if (DUCKDB_UNLIKELY(state.intermediate < (NumericLimits<int64_t>::Minimum() + digit) / 10)) {
+			if (DUCKDB_UNLIKELY(state.intermediate <
+			                    (NumericLimits<typename T::IntermediateType>::Minimum() + digit) / 10)) {
 				// intermediate is full: need to flush it
 				if (!state.Flush()) {
 					return false;
@@ -1655,7 +1651,8 @@ struct HugeIntegerCastOperation {
 			}
 			state.intermediate = state.intermediate * 10 - digit;
 		} else {
-			if (DUCKDB_UNLIKELY(state.intermediate > (NumericLimits<int64_t>::Maximum() - digit) / 10)) {
+			if (DUCKDB_UNLIKELY(state.intermediate >
+			                    (NumericLimits<typename T::IntermediateType>::Maximum() - digit) / 10)) {
 				if (!state.Flush()) {
 					return false;
 				}
@@ -1694,10 +1691,14 @@ struct HugeIntegerCastOperation {
 		if (e < 0) {
 			state.result = T::Operation::DivMod(state.result, T::Operation::POWERS_OF_TEN[-e], remainder);
 			if (remainder < 0) {
-				remainder *= -1;
+				result_t negate_result;
+				if (!T::Operation::TryNegate(remainder, negate_result)) {
+					return false;
+				}
+				remainder = negate_result;
 			}
 			state.decimal = remainder;
-			state.decimal_total_digits = UnsafeNumericCast<uint16_t>(-e);
+			state.decimal_total_digits = static_cast<uint16_t>(-e);
 			state.decimal_intermediate = 0;
 			state.decimal_intermediate_digits = 0;
 			return Finalize<T, NEGATIVE>(state);
@@ -1785,8 +1786,8 @@ struct HugeIntegerCastOperation {
 
 template <>
 bool TryCast::Operation(string_t input, hugeint_t &result, bool strict) {
-	HugeIntCastData<hugeint_t, Hugeint> state {};
-	if (!TryIntegerCast<HugeIntCastData<hugeint_t, Hugeint>, true, true, HugeIntegerCastOperation>(
+	HugeIntCastData<hugeint_t, Hugeint, int64_t> state {};
+	if (!TryIntegerCast<HugeIntCastData<hugeint_t, Hugeint, int64_t>, true, true, HugeIntegerCastOperation>(
 	        input.GetData(), input.GetSize(), state, strict)) {
 		return false;
 	}
@@ -1796,8 +1797,8 @@ bool TryCast::Operation(string_t input, hugeint_t &result, bool strict) {
 
 template <>
 bool TryCast::Operation(string_t input, uhugeint_t &result, bool strict) {
-	HugeIntCastData<uhugeint_t, Uhugeint> state {};
-	if (!TryIntegerCast<HugeIntCastData<uhugeint_t, Uhugeint>, false, true, HugeIntegerCastOperation>(
+	HugeIntCastData<uhugeint_t, Uhugeint, uint64_t> state {};
+	if (!TryIntegerCast<HugeIntCastData<uhugeint_t, Uhugeint, uint64_t>, false, true, HugeIntegerCastOperation>(
 	        input.GetData(), input.GetSize(), state, strict)) {
 		return false;
 	}
@@ -1809,205 +1810,6 @@ bool TryCast::Operation(string_t input, uhugeint_t &result, bool strict) {
 // Decimal String Cast
 //===--------------------------------------------------------------------===//
 
-template <class T>
-struct DecimalCastData {
-	using StoreType = T;
-	StoreType result;
-	uint8_t width;
-	uint8_t scale;
-	uint8_t digit_count;
-	uint8_t decimal_count;
-	//! Whether we have determined if the result should be rounded
-	bool round_set;
-	//! If the result should be rounded
-	bool should_round;
-	//! Only set when ALLOW_EXPONENT is enabled
-	enum class ExponentType : uint8_t { NONE, POSITIVE, NEGATIVE };
-	uint8_t excessive_decimals;
-	ExponentType exponent_type;
-};
-
-struct DecimalCastOperation {
-	template <class T, bool NEGATIVE>
-	static bool HandleDigit(T &state, uint8_t digit) {
-		if (state.result == 0 && digit == 0) {
-			// leading zero's don't count towards the digit count
-			return true;
-		}
-		if (state.digit_count == state.width - state.scale) {
-			// width of decimal type is exceeded!
-			return false;
-		}
-		state.digit_count++;
-		if (NEGATIVE) {
-			if (state.result < (NumericLimits<typename T::StoreType>::Minimum() / 10)) {
-				return false;
-			}
-			state.result = state.result * 10 - digit;
-		} else {
-			if (state.result > (NumericLimits<typename T::StoreType>::Maximum() / 10)) {
-				return false;
-			}
-			state.result = state.result * 10 + digit;
-		}
-		return true;
-	}
-
-	template <class T, bool NEGATIVE>
-	static bool HandleHexDigit(T &state, uint8_t digit) {
-		return false;
-	}
-
-	template <class T, bool NEGATIVE>
-	static bool HandleBinaryDigit(T &state, uint8_t digit) {
-		return false;
-	}
-
-	template <class T, bool NEGATIVE>
-	static void RoundUpResult(T &state) {
-		if (NEGATIVE) {
-			state.result -= 1;
-		} else {
-			state.result += 1;
-		}
-	}
-
-	template <class T, bool NEGATIVE>
-	static bool HandleExponent(T &state, int32_t exponent) {
-		auto decimal_excess = (state.decimal_count > state.scale) ? state.decimal_count - state.scale : 0;
-		if (exponent > 0) {
-			state.exponent_type = T::ExponentType::POSITIVE;
-			// Positive exponents need up to 'exponent' amount of digits
-			// Everything beyond that amount needs to be truncated
-			if (decimal_excess > exponent) {
-				// We've allowed too many decimals
-				state.excessive_decimals = UnsafeNumericCast<uint8_t>(decimal_excess - exponent);
-				exponent = 0;
-			} else {
-				exponent -= decimal_excess;
-			}
-			D_ASSERT(exponent >= 0);
-		} else if (exponent < 0) {
-			state.exponent_type = T::ExponentType::NEGATIVE;
-		}
-		if (!Finalize<T, NEGATIVE>(state)) {
-			return false;
-		}
-		if (exponent < 0) {
-			bool round_up = false;
-			for (idx_t i = 0; i < idx_t(-int64_t(exponent)); i++) {
-				auto mod = state.result % 10;
-				round_up = NEGATIVE ? mod <= -5 : mod >= 5;
-				state.result /= 10;
-				if (state.result == 0) {
-					break;
-				}
-			}
-			if (round_up) {
-				RoundUpResult<T, NEGATIVE>(state);
-			}
-			return true;
-		} else {
-			// positive exponent: append 0's
-			for (idx_t i = 0; i < idx_t(exponent); i++) {
-				if (!HandleDigit<T, NEGATIVE>(state, 0)) {
-					return false;
-				}
-			}
-			return true;
-		}
-	}
-
-	template <class T, bool NEGATIVE, bool ALLOW_EXPONENT>
-	static bool HandleDecimal(T &state, uint8_t digit) {
-		if (state.decimal_count == state.scale && !state.round_set) {
-			// Determine whether the last registered decimal should be rounded or not
-			state.round_set = true;
-			state.should_round = digit >= 5;
-		}
-		if (!ALLOW_EXPONENT && state.decimal_count == state.scale) {
-			// we exceeded the amount of supported decimals
-			// however, we don't throw an error here
-			// we just truncate the decimal
-			return true;
-		}
-		//! If we expect an exponent, we need to preserve the decimals
-		//! But we don't want to overflow, so we prevent overflowing the result with this check
-		if (state.digit_count + state.decimal_count >= DecimalWidth<decltype(state.result)>::max) {
-			return true;
-		}
-		state.decimal_count++;
-		if (NEGATIVE) {
-			state.result = state.result * 10 - digit;
-		} else {
-			state.result = state.result * 10 + digit;
-		}
-		return true;
-	}
-
-	template <class T, bool NEGATIVE>
-	static bool TruncateExcessiveDecimals(T &state) {
-		D_ASSERT(state.excessive_decimals);
-		bool round_up = false;
-		for (idx_t i = 0; i < state.excessive_decimals; i++) {
-			auto mod = state.result % 10;
-			round_up = NEGATIVE ? mod <= -5 : mod >= 5;
-			state.result /= 10.0;
-		}
-		//! Only round up when exponents are involved
-		if (state.exponent_type == T::ExponentType::POSITIVE && round_up) {
-			RoundUpResult<T, NEGATIVE>(state);
-		}
-		D_ASSERT(state.decimal_count > state.scale);
-		state.decimal_count = state.scale;
-		return true;
-	}
-
-	template <class T, bool NEGATIVE>
-	static bool Finalize(T &state) {
-		if (state.exponent_type != T::ExponentType::POSITIVE && state.decimal_count > state.scale) {
-			//! Did not encounter an exponent, but ALLOW_EXPONENT was on
-			state.excessive_decimals = state.decimal_count - state.scale;
-		}
-		if (state.excessive_decimals && !TruncateExcessiveDecimals<T, NEGATIVE>(state)) {
-			return false;
-		}
-		if (state.exponent_type == T::ExponentType::NONE && state.round_set && state.should_round) {
-			RoundUpResult<T, NEGATIVE>(state);
-		}
-		//  if we have not gotten exactly "scale" decimals, we need to multiply the result
-		//  e.g. if we have a string "1.0" that is cast to a DECIMAL(9,3), the value needs to be 1000
-		//  but we have only gotten the value "10" so far, so we multiply by 1000
-		for (uint8_t i = state.decimal_count; i < state.scale; i++) {
-			state.result *= 10;
-		}
-		return true;
-	}
-};
-
-template <class T, char decimal_separator = '.'>
-bool TryDecimalStringCast(string_t input, T &result, CastParameters &parameters, uint8_t width, uint8_t scale) {
-	DecimalCastData<T> state;
-	state.result = 0;
-	state.width = width;
-	state.scale = scale;
-	state.digit_count = 0;
-	state.decimal_count = 0;
-	state.excessive_decimals = 0;
-	state.exponent_type = DecimalCastData<T>::ExponentType::NONE;
-	state.round_set = false;
-	state.should_round = false;
-	if (!TryIntegerCast<DecimalCastData<T>, true, true, DecimalCastOperation, false, decimal_separator>(
-	        input.GetData(), input.GetSize(), state, false)) {
-		string error = StringUtil::Format("Could not convert string \"%s\" to DECIMAL(%d,%d)", input.GetString(),
-		                                  (int)width, (int)scale);
-		HandleCastError::AssignError(error, parameters);
-		return false;
-	}
-	result = state.result;
-	return true;
-}
-
 template <>
 bool TryCastToDecimal::Operation(string_t input, int16_t &result, CastParameters &parameters, uint8_t width,
                                  uint8_t scale) {
@@ -2058,22 +1860,22 @@ bool TryCastToDecimalCommaSeparated::Operation(string_t input, hugeint_t &result
 
 template <>
 string_t StringCastFromDecimal::Operation(int16_t input, uint8_t width, uint8_t scale, Vector &result) {
-	return DecimalToString::Format<int16_t, uint16_t>(input, width, scale, result);
+	return DecimalToString::Format<int16_t>(input, width, scale, result);
 }
 
 template <>
 string_t StringCastFromDecimal::Operation(int32_t input, uint8_t width, uint8_t scale, Vector &result) {
-	return DecimalToString::Format<int32_t, uint32_t>(input, width, scale, result);
+	return DecimalToString::Format<int32_t>(input, width, scale, result);
 }
 
 template <>
 string_t StringCastFromDecimal::Operation(int64_t input, uint8_t width, uint8_t scale, Vector &result) {
-	return DecimalToString::Format<int64_t, uint64_t>(input, width, scale, result);
+	return DecimalToString::Format<int64_t>(input, width, scale, result);
 }
 
 template <>
 string_t StringCastFromDecimal::Operation(hugeint_t input, uint8_t width, uint8_t scale, Vector &result) {
-	return HugeintToStringCast::FormatDecimal(input, width, scale, result);
+	return DecimalToString::Format<hugeint_t>(input, width, scale, result);
 }
 
 //===--------------------------------------------------------------------===//
@@ -2481,7 +2283,7 @@ bool DoubleToDecimalCast(SRC input, DST &result, CastParameters &parameters, uin
 		HandleCastError::AssignError(error, parameters);
 		return false;
 	}
-	result = Cast::Operation<SRC, DST>(value);
+	result = Cast::Operation<SRC, DST>(static_cast<SRC>(value));
 	return true;
 }
 

package/src/duckdb/src/common/operator/string_cast.cpp

@@ -24,37 +24,41 @@ string_t StringCast::Operation(bool input, Vector &vector) {
 
 template <>
 string_t StringCast::Operation(int8_t input, Vector &vector) {
-	return NumericHelper::FormatSigned<int8_t, uint8_t>(input, vector);
+	return NumericHelper::FormatSigned<int8_t>(input, vector);
 }
 
 template <>
 string_t StringCast::Operation(int16_t input, Vector &vector) {
-	return NumericHelper::FormatSigned<int16_t, uint16_t>(input, vector);
+	return NumericHelper::FormatSigned<int16_t>(input, vector);
 }
 template <>
 string_t StringCast::Operation(int32_t input, Vector &vector) {
-	return NumericHelper::FormatSigned<int32_t, uint32_t>(input, vector);
+	return NumericHelper::FormatSigned<int32_t>(input, vector);
 }
 
 template <>
 string_t StringCast::Operation(int64_t input, Vector &vector) {
-	return NumericHelper::FormatSigned<int64_t, uint64_t>(input, vector);
+	return NumericHelper::FormatSigned<int64_t>(input, vector);
 }
 template <>
 duckdb::string_t StringCast::Operation(uint8_t input, Vector &vector) {
-	return NumericHelper::FormatSigned<uint8_t, uint64_t>(input, vector);
+	return NumericHelper::FormatSigned<uint8_t>(input, vector);
 }
 template <>
 duckdb::string_t StringCast::Operation(uint16_t input, Vector &vector) {
-	return NumericHelper::FormatSigned<uint16_t, uint64_t>(input, vector);
+	return NumericHelper::FormatSigned<uint16_t>(input, vector);
 }
 template <>
 duckdb::string_t StringCast::Operation(uint32_t input, Vector &vector) {
-	return NumericHelper::FormatSigned<uint32_t, uint64_t>(input, vector);
+	return NumericHelper::FormatSigned<uint32_t>(input, vector);
 }
 template <>
 duckdb::string_t StringCast::Operation(uint64_t input, Vector &vector) {
-	return NumericHelper::FormatSigned<uint64_t, uint64_t>(input, vector);
+	return NumericHelper::FormatSigned<uint64_t>(input, vector);
+}
+template <>
+duckdb::string_t StringCast::Operation(hugeint_t input, Vector &vector) {
+	return NumericHelper::FormatSigned<hugeint_t>(input, vector);
 }
 
 template <>
@@ -76,11 +80,6 @@ string_t StringCast::Operation(interval_t input, Vector &vector) {
 	return StringVector::AddString(vector, buffer, length);
 }
 
-template <>
-duckdb::string_t StringCast::Operation(hugeint_t input, Vector &vector) {
-	return HugeintToStringCast::FormatSigned(input, vector);
-}
-
 template <>
 duckdb::string_t StringCast::Operation(uhugeint_t input, Vector &vector) {
 	return UhugeintToStringCast::Format(input, vector);
@@ -181,7 +180,7 @@ string_t StringCastTZ::Operation(dtime_tz_t input, Vector &vector) {
 	auto ss = std::abs(offset);
 	const auto hh = ss / Interval::SECS_PER_HOUR;
 
-	const auto hh_length = (hh < 100) ? 2 : NumericHelper::UnsignedLength(uint32_t(hh));
+	const auto hh_length = UnsafeNumericCast<idx_t>((hh < 100) ? 2 : NumericHelper::UnsignedLength(uint32_t(hh)));
 	length += hh_length;
 
 	ss %= Interval::SECS_PER_HOUR;

package/src/duckdb/src/common/pipe_file_system.cpp

@@ -2,6 +2,7 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/file_system.hpp"
 #include "duckdb/common/helper.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 
 namespace duckdb {
 class PipeFile : public FileHandle {
@@ -22,10 +23,10 @@ public:
 };
 
 int64_t PipeFile::ReadChunk(void *buffer, int64_t nr_bytes) {
-	return child_handle->Read(buffer, nr_bytes);
+	return child_handle->Read(buffer, UnsafeNumericCast<idx_t>(nr_bytes));
 }
 int64_t PipeFile::WriteChunk(void *buffer, int64_t nr_bytes) {
-	return child_handle->Write(buffer, nr_bytes);
+	return child_handle->Write(buffer, UnsafeNumericCast<idx_t>(nr_bytes));
 }
 
 void PipeFileSystem::Reset(FileHandle &handle) {

package/src/duckdb/src/common/progress_bar/progress_bar.cpp

@@ -121,7 +121,7 @@ void ProgressBar::Update(bool final) {
 		if (final) {
 			FinishProgressBarPrint();
 		} else {
-			PrintProgress(query_progress.percentage);
+			PrintProgress(NumericCast<int>(query_progress.percentage.load()));
 		}
 #endif
 	}

package/src/duckdb/src/common/random_engine.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/common/random_engine.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 #include "pcg_random.hpp"
 #include <random>
 
@@ -15,7 +16,7 @@ RandomEngine::RandomEngine(int64_t seed) : random_state(make_uniq<RandomState>()
 	if (seed < 0) {
 		random_state->pcg.seed(pcg_extras::seed_seq_from<std::random_device>());
 	} else {
-		random_state->pcg.seed(seed);
+		random_state->pcg.seed(NumericCast<uint64_t>(seed));
 	}
 }
 

package/src/duckdb/src/common/re2_regex.cpp

@@ -10,17 +10,18 @@ namespace duckdb_re2 {
 Regex::Regex(const std::string &pattern, RegexOptions options) {
 	RE2::Options o;
 	o.set_case_sensitive(options == RegexOptions::CASE_INSENSITIVE);
-	regex = std::make_shared<duckdb_re2::RE2>(StringPiece(pattern), o);
+	regex = duckdb::make_shared_ptr<duckdb_re2::RE2>(StringPiece(pattern), o);
 }
 
 bool RegexSearchInternal(const char *input, Match &match, const Regex &r, RE2::Anchor anchor, size_t start,
                          size_t end) {
 	auto &regex = r.GetRegex();
 	duckdb::vector<StringPiece> target_groups;
-	auto group_count = regex.NumberOfCapturingGroups() + 1;
+	auto group_count = duckdb::UnsafeNumericCast<size_t>(regex.NumberOfCapturingGroups() + 1);
 	target_groups.resize(group_count);
 	match.groups.clear();
-	if (!regex.Match(StringPiece(input), start, end, anchor, target_groups.data(), group_count)) {
+	if (!regex.Match(StringPiece(input), start, end, anchor, target_groups.data(),
+	                 duckdb::UnsafeNumericCast<int>(group_count))) {
 		return false;
 	}
 	for (auto &group : target_groups) {
@@ -41,7 +42,8 @@ bool RegexMatch(const std::string &input, Match &match, const Regex &regex) {
 }
 
 bool RegexMatch(const char *start, const char *end, Match &match, const Regex &regex) {
-	return RegexSearchInternal(start, match, regex, RE2::ANCHOR_BOTH, 0, end - start);
+	return RegexSearchInternal(start, match, regex, RE2::ANCHOR_BOTH, 0,
+	                           duckdb::UnsafeNumericCast<size_t>(end - start));
 }
 
 bool RegexMatch(const std::string &input, const Regex &regex) {

package/src/duckdb/src/common/row_operations/row_aggregate.cpp

@@ -36,14 +36,14 @@ void RowOperations::DestroyStates(RowOperationsState &state, TupleDataLayout &la
 		return;
 	}
 	//	Move to the first aggregate state
-	VectorOperations::AddInPlace(addresses, layout.GetAggrOffset(), count);
+	VectorOperations::AddInPlace(addresses, UnsafeNumericCast<int64_t>(layout.GetAggrOffset()), count);
 	for (const auto &aggr : layout.GetAggregates()) {
 		if (aggr.function.destructor) {
 			AggregateInputData aggr_input_data(aggr.GetFunctionData(), state.allocator);
 			aggr.function.destructor(addresses, aggr_input_data, count);
 		}
 		// Move to the next aggregate state
-		VectorOperations::AddInPlace(addresses, aggr.payload_size, count);
+		VectorOperations::AddInPlace(addresses, UnsafeNumericCast<int64_t>(aggr.payload_size), count);
 	}
 }
 
@@ -74,8 +74,8 @@ void RowOperations::CombineStates(RowOperationsState &state, TupleDataLayout &la
 	}
 
 	//	Move to the first aggregate states
-	VectorOperations::AddInPlace(sources, layout.GetAggrOffset(), count);
-	VectorOperations::AddInPlace(targets, layout.GetAggrOffset(), count);
+	VectorOperations::AddInPlace(sources, UnsafeNumericCast<int64_t>(layout.GetAggrOffset()), count);
+	VectorOperations::AddInPlace(targets, UnsafeNumericCast<int64_t>(layout.GetAggrOffset()), count);
 
 	// Keep track of the offset
 	idx_t offset = layout.GetAggrOffset();
@@ -87,16 +87,16 @@ void RowOperations::CombineStates(RowOperationsState &state, TupleDataLayout &la
 		aggr.function.combine(sources, targets, aggr_input_data, count);
 
 		// Move to the next aggregate states
-		VectorOperations::AddInPlace(sources, aggr.payload_size, count);
-		VectorOperations::AddInPlace(targets, aggr.payload_size, count);
+		VectorOperations::AddInPlace(sources, UnsafeNumericCast<int64_t>(aggr.payload_size), count);
+		VectorOperations::AddInPlace(targets, UnsafeNumericCast<int64_t>(aggr.payload_size), count);
 
 		// Increment the offset
 		offset += aggr.payload_size;
 	}
 
 	// Now subtract the offset to get back to the original position
-	VectorOperations::AddInPlace(sources, -offset, count);
-	VectorOperations::AddInPlace(targets, -offset, count);
+	VectorOperations::AddInPlace(sources, -UnsafeNumericCast<int64_t>(offset), count);
+	VectorOperations::AddInPlace(targets, -UnsafeNumericCast<int64_t>(offset), count);
 }
 
 void RowOperations::FinalizeStates(RowOperationsState &state, TupleDataLayout &layout, Vector &addresses,
@@ -106,7 +106,7 @@ void RowOperations::FinalizeStates(RowOperationsState &state, TupleDataLayout &l
 	VectorOperations::Copy(addresses, addresses_copy, result.size(), 0, 0);
 
 	//	Move to the first aggregate state
-	VectorOperations::AddInPlace(addresses_copy, layout.GetAggrOffset(), result.size());
+	VectorOperations::AddInPlace(addresses_copy, UnsafeNumericCast<int64_t>(layout.GetAggrOffset()), result.size());
 
 	auto &aggregates = layout.GetAggregates();
 	for (idx_t i = 0; i < aggregates.size(); i++) {
@@ -116,7 +116,7 @@ void RowOperations::FinalizeStates(RowOperationsState &state, TupleDataLayout &l
 		aggr.function.finalize(addresses_copy, aggr_input_data, target, result.size(), 0);
 
 		// Move to the next aggregate state
-		VectorOperations::AddInPlace(addresses_copy, aggr.payload_size, result.size());
+		VectorOperations::AddInPlace(addresses_copy, UnsafeNumericCast<int64_t>(aggr.payload_size), result.size());
 	}
 }
 

package/src/duckdb/src/common/row_operations/row_external.cpp

@@ -37,7 +37,8 @@ void RowOperations::SwizzleColumns(const RowLayout &layout, const data_ptr_t bas
 				for (idx_t i = 0; i < next; i++) {
 					if (Load<uint32_t>(col_ptr) > string_t::INLINE_LENGTH) {
 						// Overwrite the string pointer with the within-row offset (if not inlined)
-						Store<idx_t>(Load<data_ptr_t>(string_ptr) - heap_row_ptrs[i], string_ptr);
+						Store<idx_t>(UnsafeNumericCast<idx_t>(Load<data_ptr_t>(string_ptr) - heap_row_ptrs[i]),
+						             string_ptr);
 					}
 					col_ptr += row_width;
 					string_ptr += row_width;
@@ -46,7 +47,7 @@ void RowOperations::SwizzleColumns(const RowLayout &layout, const data_ptr_t bas
 				// Non-varchar blob columns
 				for (idx_t i = 0; i < next; i++) {
 					// Overwrite the column data pointer with the within-row offset
-					Store<idx_t>(Load<data_ptr_t>(col_ptr) - heap_row_ptrs[i], col_ptr);
+					Store<idx_t>(UnsafeNumericCast<idx_t>(Load<data_ptr_t>(col_ptr) - heap_row_ptrs[i]), col_ptr);
 					col_ptr += row_width;
 				}
 			}
@@ -79,7 +80,7 @@ void RowOperations::CopyHeapAndSwizzle(const RowLayout &layout, data_ptr_t row_p
 
 		// Copy and swizzle
 		memcpy(heap_ptr, source_heap_ptr, size);
-		Store<idx_t>(heap_ptr - heap_base_ptr, row_ptr + heap_offset);
+		Store<idx_t>(UnsafeNumericCast<idx_t>(heap_ptr - heap_base_ptr), row_ptr + heap_offset);
 
 		// Increment for next iteration
 		row_ptr += row_width;

package/src/duckdb/src/common/row_operations/row_heap_gather.cpp

@@ -153,6 +153,8 @@ static void HeapGatherArrayVector(Vector &v, const idx_t vcount, const Selection
 		data_ptr_t array_validitymask_location = key_locations[i];
 		key_locations[i] += array_validitymask_size;
 
+		NestedValidity parent_validity(array_validitymask_location);
+
 		// The size of each variable size entry is stored after the validity mask
 		// (if the child type is variable size)
 		data_ptr_t var_entry_size_ptr = nullptr;
@@ -164,8 +166,8 @@ static void HeapGatherArrayVector(Vector &v, const idx_t vcount, const Selection
 		// row idx
 		const auto row_idx = sel.get_index(i);
 
-		auto array_start = row_idx * array_size;
-		auto elem_remaining = array_size;
+		idx_t array_start = row_idx * array_size;
+		idx_t elem_remaining = array_size;
 
 		while (elem_remaining > 0) {
 			auto chunk_size = MinValue(static_cast<idx_t>(STANDARD_VECTOR_SIZE), elem_remaining);
@@ -190,11 +192,11 @@ static void HeapGatherArrayVector(Vector &v, const idx_t vcount, const Selection
 			}
 
 			// Pass on this array's validity mask to the child vector
-			NestedValidity parent_validity(array_validitymask_location);
 			RowOperations::HeapGather(child_vector, chunk_size, array_sel, array_entry_locations, &parent_validity);
 
 			elem_remaining -= chunk_size;
 			array_start += chunk_size;
+			parent_validity.OffsetListBy(chunk_size);
 		}
 	}
 }