duckdb 0.10.1-dev6.0 → 0.10.1

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

@@ -344,14 +344,14 @@ unique_ptr<FunctionData> BindGenericRoundFunctionDecimal(ClientContext &context,
 struct CeilDecimalOperator {
 	template <class T, class POWERS_OF_TEN_CLASS>
 	static void Operation(DataChunk &input, uint8_t scale, Vector &result) {
-		T power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale];
+		T power_of_ten = UnsafeNumericCast<T>(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale]);
 		UnaryExecutor::Execute<T, T>(input.data[0], result, input.size(), [&](T input) {
 			if (input <= 0) {
 				// below 0 we floor the number (e.g. -10.5 -> -10)
-				return input / power_of_ten;
+				return UnsafeNumericCast<T>(input / power_of_ten);
 			} else {
 				// above 0 we ceil the number
-				return ((input - 1) / power_of_ten) + 1;
+				return UnsafeNumericCast<T>(((input - 1) / power_of_ten) + 1);
 			}
 		});
 	}
@@ -397,14 +397,14 @@ struct FloorOperator {
 struct FloorDecimalOperator {
 	template <class T, class POWERS_OF_TEN_CLASS>
 	static void Operation(DataChunk &input, uint8_t scale, Vector &result) {
-		T power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale];
+		T power_of_ten = UnsafeNumericCast<T>(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale]);
 		UnaryExecutor::Execute<T, T>(input.data[0], result, input.size(), [&](T input) {
 			if (input < 0) {
 				// below 0 we ceil the number (e.g. -10.5 -> -11)
-				return ((input + 1) / power_of_ten) - 1;
+				return UnsafeNumericCast<T>(((input + 1) / power_of_ten) - 1);
 			} else {
 				// above 0 we floor the number
-				return input / power_of_ten;
+				return UnsafeNumericCast<T>(input / power_of_ten);
 			}
 		});
 	}
@@ -451,10 +451,10 @@ struct TruncOperator {
 struct TruncDecimalOperator {
 	template <class T, class POWERS_OF_TEN_CLASS>
 	static void Operation(DataChunk &input, uint8_t scale, Vector &result) {
-		T power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale];
+		T power_of_ten = UnsafeNumericCast<T>(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale]);
 		UnaryExecutor::Execute<T, T>(input.data[0], result, input.size(), [&](T input) {
 			//	Always floor
-			return (input / power_of_ten);
+			return UnsafeNumericCast<T>((input / power_of_ten));
 		});
 	}
 };
@@ -533,7 +533,7 @@ struct RoundOperator {
 struct RoundDecimalOperator {
 	template <class T, class POWERS_OF_TEN_CLASS>
 	static void Operation(DataChunk &input, uint8_t scale, Vector &result) {
-		T power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale];
+		T power_of_ten = UnsafeNumericCast<T>(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale]);
 		T addition = power_of_ten / 2;
 		// regular round rounds towards the nearest number
 		// in case of a tie we round away from zero
@@ -548,7 +548,7 @@ struct RoundDecimalOperator {
 			} else {
 				input += addition;
 			}
-			return input / power_of_ten;
+			return UnsafeNumericCast<T>(input / power_of_ten);
 		});
 	}
 };
@@ -581,8 +581,8 @@ static void DecimalRoundNegativePrecisionFunction(DataChunk &input, ExpressionSt
 		result.SetValue(0, Value::INTEGER(0));
 		return;
 	}
-	T divide_power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[-info.target_scale + source_scale];
-	T multiply_power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[-info.target_scale];
+	T divide_power_of_ten = UnsafeNumericCast<T>(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[-info.target_scale + source_scale]);
+	T multiply_power_of_ten = UnsafeNumericCast<T>(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[-info.target_scale]);
 	T addition = divide_power_of_ten / 2;
 
 	UnaryExecutor::Execute<T, T>(input.data[0], result, input.size(), [&](T input) {
@@ -591,7 +591,7 @@ static void DecimalRoundNegativePrecisionFunction(DataChunk &input, ExpressionSt
 		} else {
 			input += addition;
 		}
-		return input / divide_power_of_ten * multiply_power_of_ten;
+		return UnsafeNumericCast<T>(input / divide_power_of_ten * multiply_power_of_ten);
 	});
 }
 
@@ -600,7 +600,7 @@ static void DecimalRoundPositivePrecisionFunction(DataChunk &input, ExpressionSt
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	auto &info = func_expr.bind_info->Cast<RoundPrecisionFunctionData>();
 	auto source_scale = DecimalType::GetScale(func_expr.children[0]->return_type);
-	T power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[source_scale - info.target_scale];
+	T power_of_ten = UnsafeNumericCast<T>(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[source_scale - info.target_scale]);
 	T addition = power_of_ten / 2;
 	UnaryExecutor::Execute<T, T>(input.data[0], result, input.size(), [&](T input) {
 		if (input < 0) {
@@ -608,7 +608,7 @@ static void DecimalRoundPositivePrecisionFunction(DataChunk &input, ExpressionSt
 		} else {
 			input += addition;
 		}
-		return input / power_of_ten;
+		return UnsafeNumericCast<T>(input / power_of_ten);
 	});
 }
 
@@ -656,7 +656,7 @@ unique_ptr<FunctionData> BindDecimalRoundPrecision(ClientContext &context, Scala
 			bound_function.function = ScalarFunction::NopFunction;
 			target_scale = scale;
 		} else {
-			target_scale = round_value;
+			target_scale = NumericCast<uint8_t>(round_value);
 			switch (decimal_type.InternalType()) {
 			case PhysicalType::INT16:
 				bound_function.function = DecimalRoundPositivePrecisionFunction<int16_t, NumericHelper>;
@@ -1115,6 +1115,9 @@ ScalarFunction Atan2Fun::GetFunction() {
 struct ACos {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
+		if (input < -1 || input > 1) {
+			throw InvalidInputException("ACOS is undefined outside [-1,1]");
+		}
 		return (double)std::acos(input);
 	}
 };

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

@@ -0,0 +1 @@
+

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

@@ -226,19 +226,19 @@ struct BitwiseShiftLeftOperator {
 		if (shift == 0) {
 			return input;
 		}
-		TA max_value = (TA(1) << (max_shift - shift - 1));
+		TA max_value = UnsafeNumericCast<TA>((TA(1) << (max_shift - shift - 1)));
 		if (input >= max_value) {
 			throw OutOfRangeException("Overflow in left shift (%s << %s)", NumericHelper::ToString(input),
 			                          NumericHelper::ToString(shift));
 		}
-		return input << shift;
+		return UnsafeNumericCast<TR>(input << shift);
 	}
 };
 
 static void BitwiseShiftLeftOperation(DataChunk &args, ExpressionState &state, Vector &result) {
 	BinaryExecutor::Execute<string_t, int32_t, string_t>(
 	    args.data[0], args.data[1], result, args.size(), [&](string_t input, int32_t shift) {
-		    int32_t max_shift = Bit::BitLength(input);
+		    auto max_shift = UnsafeNumericCast<int32_t>(Bit::BitLength(input));
 		    if (shift == 0) {
 			    return input;
 		    }
@@ -285,7 +285,7 @@ struct BitwiseShiftRightOperator {
 static void BitwiseShiftRightOperation(DataChunk &args, ExpressionState &state, Vector &result) {
 	BinaryExecutor::Execute<string_t, int32_t, string_t>(
 	    args.data[0], args.data[1], result, args.size(), [&](string_t input, int32_t shift) {
-		    int32_t max_shift = Bit::BitLength(input);
+		    auto max_shift = UnsafeNumericCast<int32_t>(Bit::BitLength(input));
 		    if (shift == 0) {
 			    return input;
 		    }

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

@@ -0,0 +1 @@
+

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

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

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

@@ -1,5 +1,6 @@
 #include "duckdb/common/bit_utils.hpp"
 #include "duckdb/common/exception.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/types/blob.hpp"
 #include "duckdb/common/vector_operations/unary_executor.hpp"
@@ -308,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 = (major << 4) | minor;
+			*output = UnsafeNumericCast<uint8_t>((major << 4) | minor);
 			output++;
 		}
 

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

@@ -77,7 +77,7 @@ static string_t LeftPadFunction(const string_t &str, const int32_t len, const st
 	//  Append as much of the original string as fits
 	result.insert(result.end(), data_str, data_str + written.first);
 
-	return string_t(result.data(), result.size());
+	return string_t(result.data(), UnsafeNumericCast<uint32_t>(result.size()));
 }
 
 struct LeftPadOperator {
@@ -106,7 +106,7 @@ static string_t RightPadFunction(const string_t &str, const int32_t len, const s
 		throw InvalidInputException("Insufficient padding in RPAD.");
 	};
 
-	return string_t(result.data(), result.size());
+	return string_t(result.data(), UnsafeNumericCast<uint32_t>(result.size()));
 }
 
 struct RightPadOperator {

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

@@ -18,7 +18,7 @@ static string_t RepeatScalarFunction(const string_t &str, const int64_t cnt, vec
 		result.insert(result.end(), input_str, input_str + size_str);
 	}
 
-	return string_t(result.data(), result.size());
+	return string_t(result.data(), UnsafeNumericCast<uint32_t>(result.size()));
 }
 
 static void RepeatFunction(DataChunk &args, ExpressionState &state, Vector &result) {

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

@@ -59,7 +59,7 @@ static string_t ReplaceScalarFunction(const string_t &haystack, const string_t &
 		size_haystack -= size_needle;
 	}
 
-	return string_t(result.data(), result.size());
+	return string_t(result.data(), UnsafeNumericCast<uint32_t>(result.size()));
 }
 
 static void ReplaceFunction(DataChunk &args, ExpressionState &state, Vector &result) {

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

@@ -24,7 +24,8 @@ struct StringSplitInput {
 			ListVector::SetListSize(result_list, offset + list_idx);
 			ListVector::Reserve(result_list, ListVector::GetListCapacity(result_list) * 2);
 		}
-		FlatVector::GetData<string_t>(result_child)[list_entry] = string_t(split_data, split_size);
+		FlatVector::GetData<string_t>(result_child)[list_entry] =
+		    string_t(split_data, UnsafeNumericCast<uint32_t>(split_size));
 	}
 };
 

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

@@ -71,7 +71,7 @@ static string_t TranslateScalarFunction(const string_t &haystack, const string_t
 		input_haystack += sz;
 	}
 
-	return string_t(result.data(), result.size());
+	return string_t(result.data(), UnsafeNumericCast<uint32_t>(result.size()));
 }
 
 static void TranslateFunction(DataChunk &args, ExpressionState &state, Vector &result) {

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

@@ -0,0 +1,26 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/core_functions/scalar/string/ascii.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/string/bar.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/string/chr.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/string/damerau_levenshtein.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/string/format_bytes.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/string/hamming.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/string/hex.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/string/instr.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/string/jaccard.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/string/jaro_winkler.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/string/left_right.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/string/levenshtein.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/string/md5.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/string/pad.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/string/printf.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/string/repeat.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/string/replace.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/string/reverse.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/string/sha256.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/string/starts_with.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/string/string_split.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/string/to_base.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/string/translate.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/string/trim.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/string/unicode.cpp>

package/src/duckdb/src/core_functions/scalar/struct/ub_duckdb_func_struct.cpp

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

package/src/duckdb/src/core_functions/scalar/union/ub_duckdb_func_union.cpp

@@ -0,0 +1,4 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/core_functions/scalar/union/union_extract.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/union/union_tag.cpp>
+#include </Users/carlo/duckdb/src/core_functions/scalar/union/union_value.cpp>

package/src/duckdb/src/core_functions/ub_duckdb_core_functions.cpp

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

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

@@ -57,7 +57,7 @@ void AdaptiveFilter::AdaptRuntimeStatistics(double duration) {
 			prev_mean = runtime_sum / iteration_count;
 
 			// get swap index and swap likeliness
-			std::uniform_int_distribution<int> distribution(1, right_random_border); // a <= i <= b
+			std::uniform_int_distribution<int> distribution(1, NumericCast<int>(right_random_border)); // a <= i <= b
 			idx_t random_number = distribution(generator) - 1;
 
 			swap_idx = random_number / 100;                    // index to be swapped

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

@@ -193,7 +193,7 @@ void GroupedAggregateHashTable::Resize(idx_t size) {
 					// Find an empty entry
 					auto entry_idx = ApplyBitMask(hash);
 					D_ASSERT(entry_idx == hash % capacity);
-					while (entries[entry_idx].IsOccupied() > 0) {
+					while (entries[entry_idx].IsOccupied()) {
 						entry_idx++;
 						if (entry_idx >= capacity) {
 							entry_idx = 0;

package/src/duckdb/src/execution/column_binding_resolver.cpp

@@ -12,7 +12,7 @@
 
 namespace duckdb {
 
-ColumnBindingResolver::ColumnBindingResolver() {
+ColumnBindingResolver::ColumnBindingResolver(bool verify_only) : verify_only(verify_only) {
 }
 
 void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
@@ -152,6 +152,10 @@ unique_ptr<Expression> ColumnBindingResolver::VisitReplace(BoundColumnRefExpress
 	// check the current set of column bindings to see which index corresponds to the column reference
 	for (idx_t i = 0; i < bindings.size(); i++) {
 		if (expr.binding == bindings[i]) {
+			if (verify_only) {
+				// in verification mode
+				return nullptr;
+			}
 			return make_uniq<BoundReferenceExpression>(expr.alias, expr.return_type, i);
 		}
 	}
@@ -197,6 +201,8 @@ unordered_set<idx_t> ColumnBindingResolver::VerifyInternal(LogicalOperator &op)
 
 void ColumnBindingResolver::Verify(LogicalOperator &op) {
 #ifdef DEBUG
+	ColumnBindingResolver resolver(true);
+	resolver.VisitOperator(op);
 	VerifyInternal(op);
 #endif
 }

package/src/duckdb/src/execution/expression_executor/execute_case.cpp

@@ -58,7 +58,7 @@ void ExpressionExecutor::Execute(const BoundCaseExpression &expr, ExpressionStat
 		} else {
 			// we need to execute and then fill in the desired tuples in the result
 			Execute(*case_check.then_expr, then_state, current_true_sel, tcount, intermediate_result);
-			FillSwitch(intermediate_result, result, *current_true_sel, tcount);
+			FillSwitch(intermediate_result, result, *current_true_sel, NumericCast<sel_t>(tcount));
 		}
 		// continue with the false tuples
 		current_sel = current_false_sel;
@@ -79,7 +79,7 @@ void ExpressionExecutor::Execute(const BoundCaseExpression &expr, ExpressionStat
 
 			D_ASSERT(current_sel);
 			Execute(*expr.else_expr, else_state, current_sel, current_count, intermediate_result);
-			FillSwitch(intermediate_result, result, *current_sel, current_count);
+			FillSwitch(intermediate_result, result, *current_sel, NumericCast<sel_t>(current_count));
 		}
 	}
 	if (sel) {

package/src/duckdb/src/execution/expression_executor/execute_cast.cpp

@@ -31,11 +31,13 @@ void ExpressionExecutor::Execute(const BoundCastExpression &expr, ExpressionStat
 	if (expr.try_cast) {
 		string error_message;
 		CastParameters parameters(expr.bound_cast.cast_data.get(), false, &error_message, lstate);
+		parameters.query_location = expr.query_location;
 		expr.bound_cast.function(child, result, count, parameters);
 	} else {
 		// cast it to the type specified by the cast expression
 		D_ASSERT(result.GetType() == expr.return_type);
 		CastParameters parameters(expr.bound_cast.cast_data.get(), false, nullptr, lstate);
+		parameters.query_location = expr.query_location;
 		expr.bound_cast.function(child, result, count, parameters);
 	}
 }

package/src/duckdb/src/execution/expression_executor/execute_function.cpp

@@ -70,14 +70,14 @@ void ExpressionExecutor::Execute(const BoundFunctionExpression &expr, Expression
 			}
 #endif
 		}
-		arguments.Verify();
 	}
 	arguments.SetCardinality(count);
+	arguments.Verify();
 
 	state->profiler.BeginSample();
 	D_ASSERT(expr.function.function);
 	expr.function.function(arguments, *state, result);
-	state->profiler.EndSample(count);
+	state->profiler.EndSample(NumericCast<int>(count));
 
 	VerifyNullHandling(expr, arguments, result);
 	D_ASSERT(result.GetType() == expr.return_type);

package/src/duckdb/src/execution/expression_executor/execute_operator.cpp

@@ -90,7 +90,7 @@ void ExpressionExecutor::Execute(const BoundOperatorExpression &expr, Expression
 			}
 			if (result_count > 0) {
 				vector_to_check.Slice(slice_sel, result_count);
-				FillSwitch(vector_to_check, result, result_sel, result_count);
+				FillSwitch(vector_to_check, result, result_sel, NumericCast<sel_t>(result_count));
 			}
 			current_sel = next_sel;
 			next_sel = next_sel == &sel_a ? &sel_b : &sel_a;

package/src/duckdb/src/execution/expression_executor/ub_duckdb_expression_executor.cpp

@@ -0,0 +1,11 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/execution/expression_executor/execute_between.cpp>
+#include </Users/carlo/duckdb/src/execution/expression_executor/execute_case.cpp>
+#include </Users/carlo/duckdb/src/execution/expression_executor/execute_cast.cpp>
+#include </Users/carlo/duckdb/src/execution/expression_executor/execute_comparison.cpp>
+#include </Users/carlo/duckdb/src/execution/expression_executor/execute_conjunction.cpp>
+#include </Users/carlo/duckdb/src/execution/expression_executor/execute_constant.cpp>
+#include </Users/carlo/duckdb/src/execution/expression_executor/execute_function.cpp>
+#include </Users/carlo/duckdb/src/execution/expression_executor/execute_operator.cpp>
+#include </Users/carlo/duckdb/src/execution/expression_executor/execute_parameter.cpp>
+#include </Users/carlo/duckdb/src/execution/expression_executor/execute_reference.cpp>

package/src/duckdb/src/execution/expression_executor.cpp

@@ -89,7 +89,7 @@ idx_t ExpressionExecutor::SelectExpression(DataChunk &input, SelectionVector &se
 	SetChunk(&input);
 	states[0]->profiler.BeginSample();
 	idx_t selected_tuples = Select(*expressions[0], states[0]->root_state.get(), nullptr, input.size(), &sel, nullptr);
-	states[0]->profiler.EndSample(chunk ? chunk->size() : 0);
+	states[0]->profiler.EndSample(NumericCast<int>(chunk ? chunk->size() : 0));
 	return selected_tuples;
 }
 
@@ -103,7 +103,7 @@ void ExpressionExecutor::ExecuteExpression(idx_t expr_idx, Vector &result) {
 	D_ASSERT(result.GetType().id() == expressions[expr_idx]->return_type.id());
 	states[expr_idx]->profiler.BeginSample();
 	Execute(*expressions[expr_idx], states[expr_idx]->root_state.get(), nullptr, chunk ? chunk->size() : 1, result);
-	states[expr_idx]->profiler.EndSample(chunk ? chunk->size() : 0);
+	states[expr_idx]->profiler.EndSample(NumericCast<int>(chunk ? chunk->size() : 0));
 }
 
 Value ExpressionExecutor::EvaluateScalar(ClientContext &context, const Expression &expr, bool allow_unfoldable) {
@@ -138,6 +138,9 @@ void ExpressionExecutor::Verify(const Expression &expr, Vector &vector, idx_t co
 	if (expr.verification_stats) {
 		expr.verification_stats->Verify(vector, count);
 	}
+#ifdef DUCKDB_VERIFY_DICTIONARY_EXPRESSION
+	Vector::DebugTransformToDictionary(vector, count);
+#endif
 }
 
 unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const Expression &expr,

package/src/duckdb/src/execution/index/art/art.cpp

@@ -391,7 +391,8 @@ bool Construct(ART &art, vector<ARTKey> &keys, row_t *row_ids, Node &node, KeySe
 
 	// increment the depth until we reach a leaf or find a mismatching byte
 	auto prefix_start = key_section.depth;
-	while (start_key.len != key_section.depth && start_key.ByteMatches(end_key, key_section.depth)) {
+	while (start_key.len != key_section.depth &&
+	       start_key.ByteMatches(end_key, UnsafeNumericCast<uint32_t>(key_section.depth))) {
 		key_section.depth++;
 	}
 
@@ -407,7 +408,8 @@ bool Construct(ART &art, vector<ARTKey> &keys, row_t *row_ids, Node &node, KeySe
 		}
 
 		reference<Node> ref_node(node);
-		Prefix::New(art, ref_node, start_key, prefix_start, start_key.len - prefix_start);
+		Prefix::New(art, ref_node, start_key, UnsafeNumericCast<uint32_t>(prefix_start),
+		            UnsafeNumericCast<uint32_t>(start_key.len - prefix_start));
 		if (single_row_id) {
 			Leaf::New(ref_node, row_ids[key_section.start]);
 		} else {
@@ -425,7 +427,8 @@ bool Construct(ART &art, vector<ARTKey> &keys, row_t *row_ids, Node &node, KeySe
 	// set the prefix
 	reference<Node> ref_node(node);
 	auto prefix_length = key_section.depth - prefix_start;
-	Prefix::New(art, ref_node, start_key, prefix_start, prefix_length);
+	Prefix::New(art, ref_node, start_key, UnsafeNumericCast<uint32_t>(prefix_start),
+	            UnsafeNumericCast<uint32_t>(prefix_length));
 
 	// set the node
 	auto node_type = Node::GetARTNodeTypeByCount(child_sections.size());
@@ -566,7 +569,8 @@ bool ART::Insert(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id
 	if (!node.HasMetadata()) {
 		D_ASSERT(depth <= key.len);
 		reference<Node> ref_node(node);
-		Prefix::New(*this, ref_node, key, depth, key.len - depth);
+		Prefix::New(*this, ref_node, key, UnsafeNumericCast<uint32_t>(depth),
+		            UnsafeNumericCast<uint32_t>(key.len - depth));
 		Leaf::New(ref_node, row_id);
 		return true;
 	}
@@ -593,7 +597,8 @@ bool ART::Insert(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id
 		Node leaf_node;
 		reference<Node> ref_node(leaf_node);
 		if (depth + 1 < key.len) {
-			Prefix::New(*this, ref_node, key, depth + 1, key.len - depth - 1);
+			Prefix::New(*this, ref_node, key, UnsafeNumericCast<uint32_t>(depth + 1),
+			            UnsafeNumericCast<uint32_t>(key.len - depth - 1));
 		}
 		Leaf::New(ref_node, row_id);
 		Node::InsertChild(*this, node, key[depth], leaf_node);
@@ -623,7 +628,8 @@ bool ART::Insert(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id
 	Node leaf_node;
 	reference<Node> ref_node(leaf_node);
 	if (depth + 1 < key.len) {
-		Prefix::New(*this, ref_node, key, depth + 1, key.len - depth - 1);
+		Prefix::New(*this, ref_node, key, UnsafeNumericCast<uint32_t>(depth + 1),
+		            UnsafeNumericCast<uint32_t>(key.len - depth - 1));
 	}
 	Leaf::New(ref_node, row_id);
 	Node4::InsertChild(*this, next_node, key[depth], leaf_node);

package/src/duckdb/src/execution/index/art/art_key.cpp

@@ -36,12 +36,12 @@ ARTKey ARTKey::CreateARTKey(ArenaAllocator &allocator, const LogicalType &type,
 	}
 	// end with a null-terminator
 	data[pos] = '\0';
-	return ARTKey(data, len);
+	return ARTKey(data, UnsafeNumericCast<uint32_t>(len));
 }
 
 template <>
 ARTKey ARTKey::CreateARTKey(ArenaAllocator &allocator, const LogicalType &type, const char *value) {
-	return ARTKey::CreateARTKey(allocator, type, string_t(value, strlen(value)));
+	return ARTKey::CreateARTKey(allocator, type, string_t(value, UnsafeNumericCast<uint32_t>(strlen(value))));
 }
 
 template <>
@@ -51,7 +51,7 @@ void ARTKey::CreateARTKey(ArenaAllocator &allocator, const LogicalType &type, AR
 
 template <>
 void ARTKey::CreateARTKey(ArenaAllocator &allocator, const LogicalType &type, ARTKey &key, const char *value) {
-	ARTKey::CreateARTKey(allocator, type, key, string_t(value, strlen(value)));
+	ARTKey::CreateARTKey(allocator, type, key, string_t(value, UnsafeNumericCast<uint32_t>(strlen(value))));
 }
 
 bool ARTKey::operator>(const ARTKey &k) const {

package/src/duckdb/src/execution/index/art/leaf.cpp

@@ -1,7 +1,7 @@
 #include "duckdb/execution/index/art/leaf.hpp"
-
 #include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/node.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 
 namespace duckdb {
 
@@ -25,7 +25,7 @@ void Leaf::New(ART &art, reference<Node> &node, const row_t *row_ids, idx_t coun
 
 		auto &leaf = Node::RefMutable<Leaf>(art, node, NType::LEAF);
 
-		leaf.count = MinValue((idx_t)Node::LEAF_SIZE, count);
+		leaf.count = UnsafeNumericCast<uint8_t>(MinValue((idx_t)Node::LEAF_SIZE, count));
 
 		for (idx_t i = 0; i < leaf.count; i++) {
 			leaf.row_ids[i] = row_ids[copy_count + i];

package/src/duckdb/src/execution/index/art/node16.cpp

@@ -1,7 +1,7 @@
 #include "duckdb/execution/index/art/node16.hpp"
-
 #include "duckdb/execution/index/art/node4.hpp"
 #include "duckdb/execution/index/art/node48.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 
 namespace duckdb {
 
@@ -51,7 +51,7 @@ Node16 &Node16::ShrinkNode48(ART &art, Node &node16, Node &node48) {
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
 		D_ASSERT(n16.count <= Node::NODE_16_CAPACITY);
 		if (n48.child_index[i] != Node::EMPTY_MARKER) {
-			n16.key[n16.count] = i;
+			n16.key[n16.count] = UnsafeNumericCast<uint8_t>(i);
 			n16.children[n16.count] = n48.children[n48.child_index[i]];
 			n16.count++;
 		}

package/src/duckdb/src/execution/index/art/node256.cpp

@@ -1,6 +1,6 @@
 #include "duckdb/execution/index/art/node256.hpp"
-
 #include "duckdb/execution/index/art/node48.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 
 namespace duckdb {
 
@@ -109,7 +109,7 @@ optional_ptr<Node> Node256::GetChildMutable(const uint8_t byte) {
 optional_ptr<const Node> Node256::GetNextChild(uint8_t &byte) const {
 	for (idx_t i = byte; i < Node::NODE_256_CAPACITY; i++) {
 		if (children[i].HasMetadata()) {
-			byte = i;
+			byte = UnsafeNumericCast<uint8_t>(i);
 			return &children[i];
 		}
 	}
@@ -119,7 +119,7 @@ optional_ptr<const Node> Node256::GetNextChild(uint8_t &byte) const {
 optional_ptr<Node> Node256::GetNextChildMutable(uint8_t &byte) {
 	for (idx_t i = byte; i < Node::NODE_256_CAPACITY; i++) {
 		if (children[i].HasMetadata()) {
-			byte = i;
+			byte = UnsafeNumericCast<uint8_t>(i);
 			return &children[i];
 		}
 	}

package/src/duckdb/src/execution/index/art/node48.cpp

@@ -1,7 +1,7 @@
 #include "duckdb/execution/index/art/node48.hpp"
-
 #include "duckdb/execution/index/art/node16.hpp"
 #include "duckdb/execution/index/art/node256.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 
 namespace duckdb {
 
@@ -50,7 +50,7 @@ Node48 &Node48::GrowNode16(ART &art, Node &node48, Node &node16) {
 	}
 
 	for (idx_t i = 0; i < n16.count; i++) {
-		n48.child_index[n16.key[i]] = i;
+		n48.child_index[n16.key[i]] = UnsafeNumericCast<uint8_t>(i);
 		n48.children[i] = n16.children[i];
 	}
 
@@ -120,7 +120,7 @@ void Node48::InsertChild(ART &art, Node &node, const uint8_t byte, const Node ch
 			}
 		}
 		n48.children[child_pos] = child;
-		n48.child_index[byte] = child_pos;
+		n48.child_index[byte] = UnsafeNumericCast<uint8_t>(child_pos);
 		n48.count++;
 
 	} else {
@@ -167,7 +167,7 @@ optional_ptr<Node> Node48::GetChildMutable(const uint8_t byte) {
 optional_ptr<const Node> Node48::GetNextChild(uint8_t &byte) const {
 	for (idx_t i = byte; i < Node::NODE_256_CAPACITY; i++) {
 		if (child_index[i] != Node::EMPTY_MARKER) {
-			byte = i;
+			byte = UnsafeNumericCast<uint8_t>(i);
 			D_ASSERT(children[child_index[i]].HasMetadata());
 			return &children[child_index[i]];
 		}
@@ -178,7 +178,7 @@ optional_ptr<const Node> Node48::GetNextChild(uint8_t &byte) const {
 optional_ptr<Node> Node48::GetNextChildMutable(uint8_t &byte) {
 	for (idx_t i = byte; i < Node::NODE_256_CAPACITY; i++) {
 		if (child_index[i] != Node::EMPTY_MARKER) {
-			byte = i;
+			byte = UnsafeNumericCast<uint8_t>(i);
 			D_ASSERT(children[child_index[i]].HasMetadata());
 			return &children[child_index[i]];
 		}

package/src/duckdb/src/execution/index/art/prefix.cpp

@@ -273,7 +273,7 @@ void Prefix::Split(ART &art, reference<Node> &prefix_node, Node &child_node, idx
 	}
 
 	// set the new size of this node
-	prefix.data[Node::PREFIX_SIZE] = position;
+	prefix.data[Node::PREFIX_SIZE] = UnsafeNumericCast<uint8_t>(position);
 
 	// no bytes left before the split, free this node
 	if (position == 0) {