duckdb 0.10.3-dev3.0 → 0.10.3-dev6.0

package/src/duckdb/src/core_functions/scalar/map/map_extract.cpp

@@ -58,7 +58,7 @@ void FillResult(Vector &map, Vector &offsets, Vector &result, idx_t count) {
 		auto &value_list_entry = UnifiedVectorFormat::GetData<list_entry_t>(map_data)[value_index];
 
 		// Add the values to the result
-		idx_t list_offset = value_list_entry.offset + offset;
+		idx_t list_offset = value_list_entry.offset + UnsafeNumericCast<idx_t>(offset);
 		// All keys are unique, only one will ever match
 		idx_t length = 1;
 		ListVector::Append(result, values_entries, length + list_offset, list_offset);
@@ -70,14 +70,20 @@ void FillResult(Vector &map, Vector &offsets, Vector &result, idx_t count) {
 	}
 }
 
+static bool ArgumentIsConstantNull(Vector &argument) {
+	return argument.GetType().id() == LogicalTypeId::SQLNULL;
+}
+
 static void MapExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.data.size() == 2);
-	D_ASSERT(args.data[0].GetType().id() == LogicalTypeId::MAP);
 	result.SetVectorType(VectorType::FLAT_VECTOR);
 
+	auto &map = args.data[0];
+	auto &key = args.data[1];
+
 	idx_t tuple_count = args.size();
 	// Optimization: because keys are not allowed to be NULL, we can early-out
-	if (args.data[1].GetType().id() == LogicalTypeId::SQLNULL) {
+	if (ArgumentIsConstantNull(map) || ArgumentIsConstantNull(key)) {
 		//! We don't need to look through the map if the 'key' to look for is NULL
 		ListVector::SetListSize(result, 0);
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
@@ -87,9 +93,7 @@ static void MapExtractFunction(DataChunk &args, ExpressionState &state, Vector &
 		result.Verify(tuple_count);
 		return;
 	}
-
-	auto &map = args.data[0];
-	auto &key = args.data[1];
+	D_ASSERT(map.GetType().id() == LogicalTypeId::MAP);
 
 	UnifiedVectorFormat map_data;
 
@@ -124,18 +128,27 @@ static unique_ptr<FunctionData> MapExtractBind(ClientContext &context, ScalarFun
 	if (arguments.size() != 2) {
 		throw BinderException("MAP_EXTRACT must have exactly two arguments");
 	}
-	if (arguments[0]->return_type.id() != LogicalTypeId::MAP) {
+
+	auto &map_type = arguments[0]->return_type;
+	auto &input_type = arguments[1]->return_type;
+
+	if (map_type.id() == LogicalTypeId::SQLNULL) {
+		bound_function.return_type = LogicalType::LIST(LogicalTypeId::SQLNULL);
+		return make_uniq<VariableReturnBindData>(bound_function.return_type);
+	}
+
+	if (map_type.id() != LogicalTypeId::MAP) {
 		throw BinderException("MAP_EXTRACT can only operate on MAPs");
 	}
-	auto &value_type = MapType::ValueType(arguments[0]->return_type);
+	auto &value_type = MapType::ValueType(map_type);
 
 	//! Here we have to construct the List Type that will be returned
 	bound_function.return_type = LogicalType::LIST(value_type);
-	auto key_type = MapType::KeyType(arguments[0]->return_type);
-	if (key_type.id() != LogicalTypeId::SQLNULL && arguments[1]->return_type.id() != LogicalTypeId::SQLNULL) {
-		bound_function.arguments[1] = MapType::KeyType(arguments[0]->return_type);
+	auto key_type = MapType::KeyType(map_type);
+	if (key_type.id() != LogicalTypeId::SQLNULL && input_type.id() != LogicalTypeId::SQLNULL) {
+		bound_function.arguments[1] = MapType::KeyType(map_type);
 	}
-	return make_uniq<VariableReturnBindData>(value_type);
+	return make_uniq<VariableReturnBindData>(bound_function.return_type);
 }
 
 ScalarFunction MapExtractFun::GetFunction() {

package/src/duckdb/src/core_functions/scalar/map/map_keys_values.cpp

@@ -10,10 +10,16 @@ namespace duckdb {
 
 static void MapKeyValueFunction(DataChunk &args, ExpressionState &state, Vector &result,
                                 Vector &(*get_child_vector)(Vector &)) {
+	auto &map = args.data[0];
+
 	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
-	auto count = args.size();
+	if (map.GetType().id() == LogicalTypeId::SQLNULL) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+		ConstantVector::SetNull(result, true);
+		return;
+	}
 
-	auto &map = args.data[0];
+	auto count = args.size();
 	D_ASSERT(map.GetType().id() == LogicalTypeId::MAP);
 	auto child = get_child_vector(map);
 
@@ -60,6 +66,12 @@ static unique_ptr<FunctionData> MapKeyValueBind(ClientContext &context, ScalarFu
 		return nullptr;
 	}
 
+	if (map.id() == LogicalTypeId::SQLNULL) {
+		// Input is NULL, output is NULL[]
+		bound_function.return_type = LogicalType::LIST(LogicalTypeId::SQLNULL);
+		return make_uniq<VariableReturnBindData>(bound_function.return_type);
+	}
+
 	if (map.id() != LogicalTypeId::MAP) {
 		throw InvalidInputException("The provided argument is not a map");
 	}
@@ -83,14 +95,14 @@ static unique_ptr<FunctionData> MapValuesBind(ClientContext &context, ScalarFunc
 ScalarFunction MapKeysFun::GetFunction() {
 	//! the arguments and return types are actually set in the binder function
 	ScalarFunction fun({}, LogicalTypeId::LIST, MapKeysFunction, MapKeysBind);
-	fun.null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING;
+	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	fun.varargs = LogicalType::ANY;
 	return fun;
 }
 
 ScalarFunction MapValuesFun::GetFunction() {
 	ScalarFunction fun({}, LogicalTypeId::LIST, MapValuesFunction, MapValuesBind);
-	fun.null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING;
+	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	fun.varargs = LogicalType::ANY;
 	return fun;
 }

package/src/duckdb/src/core_functions/scalar/math/numeric.cpp

@@ -516,7 +516,7 @@ struct RoundOperatorPrecision {
 				return input;
 			}
 		}
-		return rounded_value;
+		return UnsafeNumericCast<TR>(rounded_value);
 	}
 };
 
@@ -527,7 +527,7 @@ struct RoundOperator {
 		if (std::isinf(rounded_value) || std::isnan(rounded_value)) {
 			return input;
 		}
-		return rounded_value;
+		return UnsafeNumericCast<TR>(rounded_value);
 	}
 };
 

package/src/duckdb/src/core_functions/scalar/operators/bitwise.cpp

@@ -251,7 +251,7 @@ static void BitwiseShiftLeftOperation(DataChunk &args, ExpressionState &state, V
 			    Bit::SetEmptyBitString(target, input);
 			    return target;
 		    }
-		    Bit::LeftShift(input, shift, target);
+		    Bit::LeftShift(input, UnsafeNumericCast<idx_t>(shift), target);
 		    return target;
 	    });
 }
@@ -294,7 +294,7 @@ static void BitwiseShiftRightOperation(DataChunk &args, ExpressionState &state,
 			    Bit::SetEmptyBitString(target, input);
 			    return target;
 		    }
-		    Bit::RightShift(input, shift, target);
+		    Bit::RightShift(input, UnsafeNumericCast<idx_t>(shift), target);
 		    return target;
 	    });
 }

package/src/duckdb/src/core_functions/scalar/random/setseed.cpp

@@ -39,7 +39,7 @@ static void SetSeedFunction(DataChunk &args, ExpressionState &state, Vector &res
 		if (input_seeds[i] < -1.0 || input_seeds[i] > 1.0 || Value::IsNan(input_seeds[i])) {
 			throw InvalidInputException("SETSEED accepts seed values between -1.0 and 1.0, inclusive");
 		}
-		uint32_t norm_seed = (input_seeds[i] + 1.0) * half_max;
+		auto norm_seed = NumericCast<uint32_t>((input_seeds[i] + 1.0) * half_max);
 		random_engine.SetSeed(norm_seed);
 	}
 

package/src/duckdb/src/core_functions/scalar/string/bar.cpp

@@ -40,7 +40,7 @@ static string_t BarScalarFunction(double x, double min, double max, double max_w
 
 	result.clear();
 
-	int32_t width_as_int = static_cast<int32_t>(width * PARTIAL_BLOCKS_COUNT);
+	auto width_as_int = NumericCast<uint32_t>(width * PARTIAL_BLOCKS_COUNT);
 	idx_t full_blocks_count = (width_as_int / PARTIAL_BLOCKS_COUNT);
 	for (idx_t i = 0; i < full_blocks_count; i++) {
 		result += FULL_BLOCK;

package/src/duckdb/src/core_functions/scalar/string/chr.cpp

@@ -16,7 +16,7 @@ struct ChrOperator {
 		char c[5] = {'\0', '\0', '\0', '\0', '\0'};
 		int utf8_bytes;
 		GetCodepoint(input, c, utf8_bytes);
-		return string_t(&c[0], utf8_bytes);
+		return string_t(&c[0], UnsafeNumericCast<uint32_t>(utf8_bytes));
 	}
 };
 
@@ -30,7 +30,7 @@ static void ChrFunction(DataChunk &args, ExpressionState &state, Vector &result)
 	int utf8_bytes;
 	UnaryExecutor::Execute<int32_t, string_t>(code_vec, result, args.size(), [&](int32_t input) {
 		ChrOperator::GetCodepoint(input, c, utf8_bytes);
-		return StringVector::AddString(result, &c[0], utf8_bytes);
+		return StringVector::AddString(result, &c[0], UnsafeNumericCast<uint32_t>(utf8_bytes));
 	});
 }
 #endif

package/src/duckdb/src/core_functions/scalar/string/hex.cpp

@@ -90,7 +90,7 @@ struct HexIntegralOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
 
-		idx_t num_leading_zero = CountZeros<uint64_t>::Leading(input);
+		auto num_leading_zero = CountZeros<uint64_t>::Leading(static_cast<uint64_t>(input));
 		idx_t num_bits_to_check = 64 - num_leading_zero;
 		D_ASSERT(num_bits_to_check <= sizeof(INPUT_TYPE) * 8);
 
@@ -109,7 +109,7 @@ struct HexIntegralOperator {
 		auto target = StringVector::EmptyString(result, buffer_size);
 		auto output = target.GetDataWriteable();
 
-		WriteHexBytes(input, output, buffer_size);
+		WriteHexBytes(static_cast<uint64_t>(input), output, buffer_size);
 
 		target.Finalize();
 		return target;
@@ -120,7 +120,7 @@ struct HexHugeIntOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
 
-		idx_t num_leading_zero = CountZeros<hugeint_t>::Leading(input);
+		idx_t num_leading_zero = CountZeros<hugeint_t>::Leading(UnsafeNumericCast<hugeint_t>(input));
 		idx_t buffer_size = sizeof(INPUT_TYPE) * 2 - (num_leading_zero / 4);
 
 		// Special case: All bits are zero
@@ -147,7 +147,7 @@ struct HexUhugeIntOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
 
-		idx_t num_leading_zero = CountZeros<uhugeint_t>::Leading(input);
+		idx_t num_leading_zero = CountZeros<uhugeint_t>::Leading(UnsafeNumericCast<uhugeint_t>(input));
 		idx_t buffer_size = sizeof(INPUT_TYPE) * 2 - (num_leading_zero / 4);
 
 		// Special case: All bits are zero
@@ -189,7 +189,7 @@ struct BinaryStrOperator {
 		auto output = target.GetDataWriteable();
 
 		for (idx_t i = 0; i < size; ++i) {
-			uint8_t byte = data[i];
+			auto byte = static_cast<uint8_t>(data[i]);
 			for (idx_t i = 8; i >= 1; --i) {
 				*output = ((byte >> (i - 1)) & 0x01) + '0';
 				output++;
@@ -205,7 +205,7 @@ struct BinaryIntegralOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
 
-		idx_t num_leading_zero = CountZeros<uint64_t>::Leading(input);
+		auto num_leading_zero = CountZeros<uint64_t>::Leading(static_cast<uint64_t>(input));
 		idx_t num_bits_to_check = 64 - num_leading_zero;
 		D_ASSERT(num_bits_to_check <= sizeof(INPUT_TYPE) * 8);
 
@@ -224,7 +224,7 @@ struct BinaryIntegralOperator {
 		auto target = StringVector::EmptyString(result, buffer_size);
 		auto output = target.GetDataWriteable();
 
-		WriteBinBytes(input, output, buffer_size);
+		WriteBinBytes(static_cast<uint64_t>(input), output, buffer_size);
 
 		target.Finalize();
 		return target;
@@ -234,7 +234,7 @@ struct BinaryIntegralOperator {
 struct BinaryHugeIntOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		idx_t num_leading_zero = CountZeros<hugeint_t>::Leading(input);
+		auto num_leading_zero = CountZeros<hugeint_t>::Leading(UnsafeNumericCast<hugeint_t>(input));
 		idx_t buffer_size = sizeof(INPUT_TYPE) * 8 - num_leading_zero;
 
 		// Special case: All bits are zero
@@ -259,7 +259,7 @@ struct BinaryHugeIntOperator {
 struct BinaryUhugeIntOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		idx_t num_leading_zero = CountZeros<uhugeint_t>::Leading(input);
+		auto num_leading_zero = CountZeros<hugeint_t>::Leading(UnsafeNumericCast<uhugeint_t>(input));
 		idx_t buffer_size = sizeof(INPUT_TYPE) * 8 - num_leading_zero;
 
 		// Special case: All bits are zero
@@ -301,7 +301,7 @@ struct FromHexOperator {
 		// Treated as a single byte
 		idx_t i = 0;
 		if (size % 2 != 0) {
-			*output = StringUtil::GetHexValue(data[i]);
+			*output = static_cast<char>(StringUtil::GetHexValue(data[i]));
 			i++;
 			output++;
 		}
@@ -309,7 +309,7 @@ struct FromHexOperator {
 		for (; i < size; i += 2) {
 			uint8_t major = StringUtil::GetHexValue(data[i]);
 			uint8_t minor = StringUtil::GetHexValue(data[i + 1]);
-			*output = UnsafeNumericCast<uint8_t>((major << 4) | minor);
+			*output = static_cast<char>((major << 4) | minor);
 			output++;
 		}
 
@@ -343,7 +343,7 @@ struct FromBinaryOperator {
 				byte |= StringUtil::GetBinaryValue(data[i]) << (j - 1);
 				i++;
 			}
-			*output = byte;
+			*output = static_cast<char>(byte); // binary eh
 			output++;
 		}
 
@@ -353,7 +353,7 @@ struct FromBinaryOperator {
 				byte |= StringUtil::GetBinaryValue(data[i]) << (j - 1);
 				i++;
 			}
-			*output = byte;
+			*output = static_cast<char>(byte);
 			output++;
 		}
 

package/src/duckdb/src/core_functions/scalar/string/instr.cpp

@@ -33,7 +33,7 @@ struct InstrAsciiOperator {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA haystack, TB needle) {
 		auto location = ContainsFun::Find(haystack, needle);
-		return location == DConstants::INVALID_INDEX ? 0 : location + 1;
+		return UnsafeNumericCast<TR>(location == DConstants::INVALID_INDEX ? 0U : location + 1U);
 	}
 };
 

package/src/duckdb/src/core_functions/scalar/string/pad.cpp

@@ -17,9 +17,9 @@ static pair<idx_t, idx_t> PadCountChars(const idx_t len, const char *data, const
 	idx_t nchars = 0;
 	for (; nchars < len && nbytes < size; ++nchars) {
 		utf8proc_int32_t codepoint;
-		auto bytes = utf8proc_iterate(str + nbytes, size - nbytes, &codepoint);
+		auto bytes = utf8proc_iterate(str + nbytes, UnsafeNumericCast<utf8proc_ssize_t>(size - nbytes), &codepoint);
 		D_ASSERT(bytes > 0);
-		nbytes += bytes;
+		nbytes += UnsafeNumericCast<idx_t>(bytes);
 	}
 
 	return pair<idx_t, idx_t>(nbytes, nchars);
@@ -47,9 +47,9 @@ static bool InsertPadding(const idx_t len, const string_t &pad, vector<char> &re
 
 		//  Write the next character
 		utf8proc_int32_t codepoint;
-		auto bytes = utf8proc_iterate(str + nbytes, size - nbytes, &codepoint);
+		auto bytes = utf8proc_iterate(str + nbytes, UnsafeNumericCast<utf8proc_ssize_t>(size - nbytes), &codepoint);
 		D_ASSERT(bytes > 0);
-		nbytes += bytes;
+		nbytes += UnsafeNumericCast<idx_t>(bytes);
 	}
 
 	//  Flush the remaining pad
@@ -67,10 +67,10 @@ static string_t LeftPadFunction(const string_t &str, const int32_t len, const st
 	auto size_str = str.GetSize();
 
 	//  Count how much of str will fit in the output
-	auto written = PadCountChars(len, data_str, size_str);
+	auto written = PadCountChars(UnsafeNumericCast<idx_t>(len), data_str, size_str);
 
 	//  Left pad by the number of characters still needed
-	if (!InsertPadding(len - written.second, pad, result)) {
+	if (!InsertPadding(UnsafeNumericCast<idx_t>(len) - written.second, pad, result)) {
 		throw InvalidInputException("Insufficient padding in LPAD.");
 	}
 
@@ -96,13 +96,13 @@ static string_t RightPadFunction(const string_t &str, const int32_t len, const s
 	auto size_str = str.GetSize();
 
 	// Count how much of str will fit in the output
-	auto written = PadCountChars(len, data_str, size_str);
+	auto written = PadCountChars(UnsafeNumericCast<idx_t>(len), data_str, size_str);
 
 	//  Append as much of the original string as fits
 	result.insert(result.end(), data_str, data_str + written.first);
 
 	//  Right pad by the number of characters still needed
-	if (!InsertPadding(len - written.second, pad, result)) {
+	if (!InsertPadding(UnsafeNumericCast<idx_t>(len) - written.second, pad, result)) {
 		throw InvalidInputException("Insufficient padding in RPAD.");
 	};
 

package/src/duckdb/src/core_functions/scalar/string/repeat.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/common/vector_operations/binary_executor.hpp"
 #include "duckdb/core_functions/scalar/string_functions.hpp"
+#include "duckdb/common/operator/multiply.hpp"
 
 namespace duckdb {
 
@@ -11,15 +12,22 @@ static void RepeatFunction(DataChunk &args, ExpressionState &, Vector &result) {
 	    str_vector, cnt_vector, result, args.size(), [&](string_t str, int64_t cnt) {
 		    auto input_str = str.GetData();
 		    auto size_str = str.GetSize();
+		    idx_t copy_count = cnt <= 0 || size_str == 0 ? 0 : UnsafeNumericCast<idx_t>(cnt);
 
-		    idx_t copy_count = cnt <= 0 || size_str == 0 ? 0 : idx_t(cnt);
-		    auto result_str = StringVector::EmptyString(result, size_str * copy_count);
-		    auto result_data = result_str.GetDataWriteable();
-		    for (idx_t i = 0; i < copy_count; i++) {
-			    memcpy(result_data + i * size_str, input_str, size_str);
+		    idx_t copy_size;
+		    if (TryMultiplyOperator::Operation(size_str, copy_count, copy_size)) {
+			    auto result_str = StringVector::EmptyString(result, copy_size);
+			    auto result_data = result_str.GetDataWriteable();
+			    for (idx_t i = 0; i < copy_count; i++) {
+				    memcpy(result_data + i * size_str, input_str, size_str);
+			    }
+			    result_str.Finalize();
+			    return result_str;
+		    } else {
+			    throw OutOfRangeException(
+			        "Cannot create a string of size: '%d' * '%d', the maximum supported string size is: '%d'", size_str,
+			        copy_count, string_t::MAX_STRING_SIZE);
 		    }
-		    result_str.Finalize();
-		    return result_str;
 	    });
 }
 

package/src/duckdb/src/core_functions/scalar/string/string_split.cpp

@@ -51,7 +51,7 @@ struct ConstantRegexpStringSplit {
 			return DConstants::INVALID_INDEX;
 		}
 		match_size = match.size();
-		return match.data() - input_data;
+		return UnsafeNumericCast<idx_t>(match.data() - input_data);
 	}
 };
 

package/src/duckdb/src/core_functions/scalar/string/to_base.cpp

@@ -48,7 +48,7 @@ static void ToBaseFunction(DataChunk &args, ExpressionState &state, Vector &resu
 			    length++;
 		    }
 
-		    return StringVector::AddString(result, ptr, end - ptr);
+		    return StringVector::AddString(result, ptr, UnsafeNumericCast<idx_t>(end - ptr));
 	    });
 }
 

package/src/duckdb/src/core_functions/scalar/string/translate.cpp

@@ -37,10 +37,10 @@ static string_t TranslateScalarFunction(const string_t &haystack, const string_t
 	while (i < size_needle && j < size_thread) {
 		auto codepoint_needle = Utf8Proc::UTF8ToCodepoint(input_needle, sz);
 		input_needle += sz;
-		i += sz;
+		i += UnsafeNumericCast<idx_t>(sz);
 		auto codepoint_thread = Utf8Proc::UTF8ToCodepoint(input_thread, sz);
 		input_thread += sz;
-		j += sz;
+		j += UnsafeNumericCast<idx_t>(sz);
 		// Ignore unicode character that is existed in to_replace
 		if (to_replace.count(codepoint_needle) == 0) {
 			to_replace[codepoint_needle] = codepoint_thread;
@@ -52,7 +52,7 @@ static string_t TranslateScalarFunction(const string_t &haystack, const string_t
 	while (i < size_needle) {
 		auto codepoint_needle = Utf8Proc::UTF8ToCodepoint(input_needle, sz);
 		input_needle += sz;
-		i += sz;
+		i += UnsafeNumericCast<idx_t>(sz);
 		// Add unicode character that will be deleted
 		if (to_replace.count(codepoint_needle) == 0) {
 			to_delete.insert(codepoint_needle);
@@ -60,7 +60,7 @@ static string_t TranslateScalarFunction(const string_t &haystack, const string_t
 	}
 
 	char c[5] = {'\0', '\0', '\0', '\0', '\0'};
-	for (i = 0; i < size_haystack; i += sz) {
+	for (i = 0; i < size_haystack; i += UnsafeNumericCast<idx_t>(sz)) {
 		auto codepoint_haystack = Utf8Proc::UTF8ToCodepoint(input_haystack, sz);
 		if (to_replace.count(codepoint_haystack) != 0) {
 			Utf8Proc::CodepointToUtf8(to_replace[codepoint_haystack], c_sz, c);

package/src/duckdb/src/core_functions/scalar/string/trim.cpp

@@ -23,12 +23,13 @@ struct TrimOperator {
 		idx_t begin = 0;
 		if (LTRIM) {
 			while (begin < size) {
-				auto bytes = utf8proc_iterate(str + begin, size - begin, &codepoint);
+				auto bytes =
+				    utf8proc_iterate(str + begin, UnsafeNumericCast<utf8proc_ssize_t>(size - begin), &codepoint);
 				D_ASSERT(bytes > 0);
 				if (utf8proc_category(codepoint) != UTF8PROC_CATEGORY_ZS) {
 					break;
 				}
-				begin += bytes;
+				begin += UnsafeNumericCast<idx_t>(bytes);
 			}
 		}
 
@@ -37,9 +38,9 @@ struct TrimOperator {
 		if (RTRIM) {
 			end = begin;
 			for (auto next = begin; next < size;) {
-				auto bytes = utf8proc_iterate(str + next, size - next, &codepoint);
+				auto bytes = utf8proc_iterate(str + next, UnsafeNumericCast<utf8proc_ssize_t>(size - next), &codepoint);
 				D_ASSERT(bytes > 0);
-				next += bytes;
+				next += UnsafeNumericCast<idx_t>(bytes);
 				if (utf8proc_category(codepoint) != UTF8PROC_CATEGORY_ZS) {
 					end = next;
 				}
@@ -69,7 +70,8 @@ static void GetIgnoredCodepoints(string_t ignored, unordered_set<utf8proc_int32_
 	idx_t pos = 0;
 	while (pos < size) {
 		utf8proc_int32_t codepoint;
-		pos += utf8proc_iterate(dataptr + pos, size - pos, &codepoint);
+		pos += UnsafeNumericCast<idx_t>(
+		    utf8proc_iterate(dataptr + pos, UnsafeNumericCast<utf8proc_ssize_t>(size - pos), &codepoint));
 		ignored_codepoints.insert(codepoint);
 	}
 }
@@ -91,11 +93,12 @@ static void BinaryTrimFunction(DataChunk &input, ExpressionState &state, Vector
 		    idx_t begin = 0;
 		    if (LTRIM) {
 			    while (begin < size) {
-				    auto bytes = utf8proc_iterate(str + begin, size - begin, &codepoint);
+				    auto bytes =
+				        utf8proc_iterate(str + begin, UnsafeNumericCast<utf8proc_ssize_t>(size - begin), &codepoint);
 				    if (ignored_codepoints.find(codepoint) == ignored_codepoints.end()) {
 					    break;
 				    }
-				    begin += bytes;
+				    begin += UnsafeNumericCast<idx_t>(bytes);
 			    }
 		    }
 
@@ -104,9 +107,10 @@ static void BinaryTrimFunction(DataChunk &input, ExpressionState &state, Vector
 		    if (RTRIM) {
 			    end = begin;
 			    for (auto next = begin; next < size;) {
-				    auto bytes = utf8proc_iterate(str + next, size - next, &codepoint);
+				    auto bytes =
+				        utf8proc_iterate(str + next, UnsafeNumericCast<utf8proc_ssize_t>(size - next), &codepoint);
 				    D_ASSERT(bytes > 0);
-				    next += bytes;
+				    next += UnsafeNumericCast<idx_t>(bytes);
 				    if (ignored_codepoints.find(codepoint) == ignored_codepoints.end()) {
 					    end = next;
 				    }

package/src/duckdb/src/core_functions/scalar/string/unicode.cpp

@@ -15,7 +15,7 @@ struct UnicodeOperator {
 		auto str = reinterpret_cast<const utf8proc_uint8_t *>(input.GetData());
 		auto len = input.GetSize();
 		utf8proc_int32_t codepoint;
-		(void)utf8proc_iterate(str, len, &codepoint);
+		(void)utf8proc_iterate(str, UnsafeNumericCast<utf8proc_ssize_t>(len), &codepoint);
 		return codepoint;
 	}
 };

package/src/duckdb/src/execution/adaptive_filter.cpp

@@ -58,7 +58,7 @@ void AdaptiveFilter::AdaptRuntimeStatistics(double duration) {
 
 			// get swap index and swap likeliness
 			std::uniform_int_distribution<int> distribution(1, NumericCast<int>(right_random_border)); // a <= i <= b
-			idx_t random_number = distribution(generator) - 1;
+			auto random_number = UnsafeNumericCast<idx_t>(distribution(generator) - 1);
 
 			swap_idx = random_number / 100;                    // index to be swapped
 			idx_t likeliness = random_number - 100 * swap_idx; // random number between [0, 100)

package/src/duckdb/src/execution/aggregate_hashtable.cpp

@@ -40,7 +40,7 @@ GroupedAggregateHashTable::GroupedAggregateHashTable(ClientContext &context, All
                                                      vector<AggregateObject> aggregate_objects_p,
                                                      idx_t initial_capacity, idx_t radix_bits)
     : BaseAggregateHashTable(context, allocator, aggregate_objects_p, std::move(payload_types_p)),
-      radix_bits(radix_bits), count(0), capacity(0), aggregate_allocator(make_shared<ArenaAllocator>(allocator)) {
+      radix_bits(radix_bits), count(0), capacity(0), aggregate_allocator(make_shared_ptr<ArenaAllocator>(allocator)) {
 
 	// Append hash column to the end and initialise the row layout
 	group_types_p.emplace_back(LogicalType::HASH);
@@ -122,7 +122,7 @@ idx_t GroupedAggregateHashTable::InitialCapacity() {
 
 idx_t GroupedAggregateHashTable::GetCapacityForCount(idx_t count) {
 	count = MaxValue<idx_t>(InitialCapacity(), count);
-	return NextPowerOfTwo(count * LOAD_FACTOR);
+	return NextPowerOfTwo(NumericCast<uint64_t>(static_cast<double>(count) * LOAD_FACTOR));
 }
 
 idx_t GroupedAggregateHashTable::Capacity() const {
@@ -130,7 +130,7 @@ idx_t GroupedAggregateHashTable::Capacity() const {
 }
 
 idx_t GroupedAggregateHashTable::ResizeThreshold() const {
-	return Capacity() / LOAD_FACTOR;
+	return NumericCast<idx_t>(static_cast<double>(Capacity()) / LOAD_FACTOR);
 }
 
 idx_t GroupedAggregateHashTable::ApplyBitMask(hash_t hash) const {
@@ -246,7 +246,7 @@ idx_t GroupedAggregateHashTable::AddChunk(DataChunk &groups, Vector &group_hashe
 #endif
 
 	const auto new_group_count = FindOrCreateGroups(groups, group_hashes, state.addresses, state.new_groups);
-	VectorOperations::AddInPlace(state.addresses, layout.GetAggrOffset(), payload.size());
+	VectorOperations::AddInPlace(state.addresses, NumericCast<int64_t>(layout.GetAggrOffset()), payload.size());
 
 	// Now every cell has an entry, update the aggregates
 	auto &aggregates = layout.GetAggregates();
@@ -258,7 +258,7 @@ idx_t GroupedAggregateHashTable::AddChunk(DataChunk &groups, Vector &group_hashe
 		if (filter_idx >= filter.size() || i < filter[filter_idx]) {
 			// Skip all the aggregates that are not in the filter
 			payload_idx += aggr.child_count;
-			VectorOperations::AddInPlace(state.addresses, aggr.payload_size, payload.size());
+			VectorOperations::AddInPlace(state.addresses, NumericCast<int64_t>(aggr.payload_size), payload.size());
 			continue;
 		}
 		D_ASSERT(i == filter[filter_idx]);
@@ -272,7 +272,7 @@ idx_t GroupedAggregateHashTable::AddChunk(DataChunk &groups, Vector &group_hashe
 
 		// Move to the next aggregate
 		payload_idx += aggr.child_count;
-		VectorOperations::AddInPlace(state.addresses, aggr.payload_size, payload.size());
+		VectorOperations::AddInPlace(state.addresses, NumericCast<int64_t>(aggr.payload_size), payload.size());
 		filter_idx++;
 	}
 
@@ -360,7 +360,8 @@ idx_t GroupedAggregateHashTable::FindOrCreateGroupsInternal(DataChunk &groups, V
 
 	idx_t new_group_count = 0;
 	idx_t remaining_entries = groups.size();
-	while (remaining_entries > 0) {
+	idx_t iteration_count;
+	for (iteration_count = 0; remaining_entries > 0 && iteration_count < capacity; iteration_count++) {
 		idx_t new_entry_count = 0;
 		idx_t need_compare_count = 0;
 		idx_t no_match_count = 0;
@@ -370,7 +371,9 @@ idx_t GroupedAggregateHashTable::FindOrCreateGroupsInternal(DataChunk &groups, V
 			const auto index = sel_vector->get_index(i);
 			const auto &salt = hash_salts[index];
 			auto &ht_offset = ht_offsets[index];
-			while (true) {
+
+			idx_t inner_iteration_count;
+			for (inner_iteration_count = 0; inner_iteration_count < capacity; inner_iteration_count++) {
 				auto &entry = entries[ht_offset];
 				if (entry.IsOccupied()) { // Cell is occupied: Compare salts
 					if (entry.GetSalt() == salt) {
@@ -393,6 +396,9 @@ idx_t GroupedAggregateHashTable::FindOrCreateGroupsInternal(DataChunk &groups, V
 					break;
 				}
 			}
+			if (inner_iteration_count == capacity) {
+				throw InternalException("Maximum inner iteration count reached in GroupedAggregateHashTable");
+			}
 		}
 
 		if (new_entry_count != 0) {
@@ -440,6 +446,9 @@ idx_t GroupedAggregateHashTable::FindOrCreateGroupsInternal(DataChunk &groups, V
 		sel_vector = &state.no_match_vector;
 		remaining_entries = no_match_count;
 	}
+	if (iteration_count == capacity) {
+		throw InternalException("Maximum outer iteration count reached in GroupedAggregateHashTable");
+	}
 
 	count += new_group_count;
 	return new_group_count;