duckdb 0.10.1-dev6.0 → 0.10.1

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

@@ -11,31 +11,31 @@ BoundCastInfo DefaultCasts::BitCastSwitch(BindCastInput &input, const LogicalTyp
 	switch (target.id()) {
 	// Numerics
 	case LogicalTypeId::BOOLEAN:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, bool, CastFromBitToNumeric>);
+		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, bool, CastFromBitToNumeric>);
 	case LogicalTypeId::TINYINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, int8_t, CastFromBitToNumeric>);
+		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, int8_t, CastFromBitToNumeric>);
 	case LogicalTypeId::SMALLINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, int16_t, CastFromBitToNumeric>);
+		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, int16_t, CastFromBitToNumeric>);
 	case LogicalTypeId::INTEGER:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, int32_t, CastFromBitToNumeric>);
+		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, int32_t, CastFromBitToNumeric>);
 	case LogicalTypeId::BIGINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, int64_t, CastFromBitToNumeric>);
+		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, int64_t, CastFromBitToNumeric>);
 	case LogicalTypeId::UTINYINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, uint8_t, CastFromBitToNumeric>);
+		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, uint8_t, CastFromBitToNumeric>);
 	case LogicalTypeId::USMALLINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, uint16_t, CastFromBitToNumeric>);
+		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, uint16_t, CastFromBitToNumeric>);
 	case LogicalTypeId::UINTEGER:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, uint32_t, CastFromBitToNumeric>);
+		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, uint32_t, CastFromBitToNumeric>);
 	case LogicalTypeId::UBIGINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, uint64_t, CastFromBitToNumeric>);
+		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, uint64_t, CastFromBitToNumeric>);
 	case LogicalTypeId::HUGEINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, hugeint_t, CastFromBitToNumeric>);
+		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, hugeint_t, CastFromBitToNumeric>);
 	case LogicalTypeId::UHUGEINT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, uhugeint_t, CastFromBitToNumeric>);
+		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, uhugeint_t, CastFromBitToNumeric>);
 	case LogicalTypeId::FLOAT:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, float, CastFromBitToNumeric>);
+		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, float, CastFromBitToNumeric>);
 	case LogicalTypeId::DOUBLE:
-		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, double, CastFromBitToNumeric>);
+		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, double, CastFromBitToNumeric>);
 
 	case LogicalTypeId::BLOB:
 		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, CastFromBitToBlob>);

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

@@ -14,6 +14,7 @@ BindCastInput::BindCastInput(CastFunctionSet &function_set, optional_ptr<BindCas
 
 BoundCastInfo BindCastInput::GetCastFunction(const LogicalType &source, const LogicalType &target) {
 	GetCastFunctionInput input(context);
+	input.query_location = query_location;
 	return function_set.GetCastFunction(source, target, input);
 }
 
@@ -47,6 +48,7 @@ BoundCastInfo CastFunctionSet::GetCastFunction(const LogicalType &source, const
 	for (idx_t i = bind_functions.size(); i > 0; i--) {
 		auto &bind_function = bind_functions[i - 1];
 		BindCastInput input(*this, bind_function.info.get(), get_input.context);
+		input.query_location = get_input.query_location;
 		auto result = bind_function.function(input, source, target);
 		if (result.function) {
 			// found a cast function! return it

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

@@ -15,17 +15,17 @@ static bool FromDecimalCast(Vector &source, Vector &result, idx_t count, CastPar
 	auto scale = DecimalType::GetScale(source_type);
 	switch (source_type.InternalType()) {
 	case PhysicalType::INT16:
-		return VectorCastHelpers::TemplatedDecimalCast<int16_t, T, TryCastFromDecimal>(
-		    source, result, count, parameters.error_message, width, scale);
+		return VectorCastHelpers::TemplatedDecimalCast<int16_t, T, TryCastFromDecimal>(source, result, count,
+		                                                                               parameters, width, scale);
 	case PhysicalType::INT32:
-		return VectorCastHelpers::TemplatedDecimalCast<int32_t, T, TryCastFromDecimal>(
-		    source, result, count, parameters.error_message, width, scale);
+		return VectorCastHelpers::TemplatedDecimalCast<int32_t, T, TryCastFromDecimal>(source, result, count,
+		                                                                               parameters, width, scale);
 	case PhysicalType::INT64:
-		return VectorCastHelpers::TemplatedDecimalCast<int64_t, T, TryCastFromDecimal>(
-		    source, result, count, parameters.error_message, width, scale);
+		return VectorCastHelpers::TemplatedDecimalCast<int64_t, T, TryCastFromDecimal>(source, result, count,
+		                                                                               parameters, width, scale);
 	case PhysicalType::INT128:
-		return VectorCastHelpers::TemplatedDecimalCast<hugeint_t, T, TryCastFromDecimal>(
-		    source, result, count, parameters.error_message, width, scale);
+		return VectorCastHelpers::TemplatedDecimalCast<hugeint_t, T, TryCastFromDecimal>(source, result, count,
+		                                                                                 parameters, width, scale);
 	default:
 		throw InternalException("Unimplemented internal type for decimal");
 	}
@@ -33,19 +33,19 @@ static bool FromDecimalCast(Vector &source, Vector &result, idx_t count, CastPar
 
 template <class LIMIT_TYPE, class FACTOR_TYPE = LIMIT_TYPE>
 struct DecimalScaleInput {
-	DecimalScaleInput(Vector &result_p, FACTOR_TYPE factor_p) : result(result_p), factor(factor_p) {
+	DecimalScaleInput(Vector &result_p, FACTOR_TYPE factor_p, CastParameters &parameters)
+	    : result(result_p), vector_cast_data(result, parameters), factor(factor_p) {
 	}
-	DecimalScaleInput(Vector &result_p, LIMIT_TYPE limit_p, FACTOR_TYPE factor_p, string *error_message_p,
+	DecimalScaleInput(Vector &result_p, LIMIT_TYPE limit_p, FACTOR_TYPE factor_p, CastParameters &parameters,
 	                  uint8_t source_width_p, uint8_t source_scale_p)
-	    : result(result_p), limit(limit_p), factor(factor_p), error_message(error_message_p),
+	    : result(result_p), vector_cast_data(result, parameters), limit(limit_p), factor(factor_p),
 	      source_width(source_width_p), source_scale(source_scale_p) {
 	}
 
 	Vector &result;
+	VectorTryCastData vector_cast_data;
 	LIMIT_TYPE limit;
 	FACTOR_TYPE factor;
-	bool all_converted = true;
-	string *error_message;
 	uint8_t source_width;
 	uint8_t source_scale;
 };
@@ -66,36 +66,34 @@ struct DecimalScaleUpCheckOperator {
 			auto error = StringUtil::Format("Casting value \"%s\" to type %s failed: value is out of range!",
 			                                Decimal::ToString(input, data->source_width, data->source_scale),
 			                                data->result.GetType().ToString());
-			return HandleVectorCastError::Operation<RESULT_TYPE>(std::move(error), mask, idx, data->error_message,
-			                                                     data->all_converted);
+			return HandleVectorCastError::Operation<RESULT_TYPE>(std::move(error), mask, idx, data->vector_cast_data);
 		}
 		return Cast::Operation<INPUT_TYPE, RESULT_TYPE>(input) * data->factor;
 	}
 };
 
 template <class SOURCE, class DEST, class POWERS_SOURCE, class POWERS_DEST>
-bool TemplatedDecimalScaleUp(Vector &source, Vector &result, idx_t count, string *error_message) {
+bool TemplatedDecimalScaleUp(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	auto source_scale = DecimalType::GetScale(source.GetType());
 	auto source_width = DecimalType::GetWidth(source.GetType());
 	auto result_scale = DecimalType::GetScale(result.GetType());
 	auto result_width = DecimalType::GetWidth(result.GetType());
 	D_ASSERT(result_scale >= source_scale);
 	idx_t scale_difference = result_scale - source_scale;
-	DEST multiply_factor = POWERS_DEST::POWERS_OF_TEN[scale_difference];
+	DEST multiply_factor = UnsafeNumericCast<DEST>(POWERS_DEST::POWERS_OF_TEN[scale_difference]);
 	idx_t target_width = result_width - scale_difference;
 	if (source_width < target_width) {
-		DecimalScaleInput<SOURCE, DEST> input(result, multiply_factor);
+		DecimalScaleInput<SOURCE, DEST> input(result, multiply_factor, parameters);
 		// type will always fit: no need to check limit
 		UnaryExecutor::GenericExecute<SOURCE, DEST, DecimalScaleUpOperator>(source, result, count, &input);
 		return true;
 	} else {
 		// type might not fit: check limit
-		auto limit = POWERS_SOURCE::POWERS_OF_TEN[target_width];
-		DecimalScaleInput<SOURCE, DEST> input(result, limit, multiply_factor, error_message, source_width,
-		                                      source_scale);
+		auto limit = UnsafeNumericCast<SOURCE>(POWERS_SOURCE::POWERS_OF_TEN[target_width]);
+		DecimalScaleInput<SOURCE, DEST> input(result, limit, multiply_factor, parameters, source_width, source_scale);
 		UnaryExecutor::GenericExecute<SOURCE, DEST, DecimalScaleUpCheckOperator>(source, result, count, &input,
-		                                                                         error_message);
-		return input.all_converted;
+		                                                                         parameters.error_message);
+		return input.vector_cast_data.all_converted;
 	}
 }
 
@@ -115,15 +113,14 @@ struct DecimalScaleDownCheckOperator {
 			auto error = StringUtil::Format("Casting value \"%s\" to type %s failed: value is out of range!",
 			                                Decimal::ToString(input, data->source_width, data->source_scale),
 			                                data->result.GetType().ToString());
-			return HandleVectorCastError::Operation<RESULT_TYPE>(std::move(error), mask, idx, data->error_message,
-			                                                     data->all_converted);
+			return HandleVectorCastError::Operation<RESULT_TYPE>(std::move(error), mask, idx, data->vector_cast_data);
 		}
 		return Cast::Operation<INPUT_TYPE, RESULT_TYPE>(input / data->factor);
 	}
 };
 
 template <class SOURCE, class DEST, class POWERS_SOURCE>
-bool TemplatedDecimalScaleDown(Vector &source, Vector &result, idx_t count, string *error_message) {
+bool TemplatedDecimalScaleDown(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	auto source_scale = DecimalType::GetScale(source.GetType());
 	auto source_width = DecimalType::GetWidth(source.GetType());
 	auto result_scale = DecimalType::GetScale(result.GetType());
@@ -131,19 +128,20 @@ bool TemplatedDecimalScaleDown(Vector &source, Vector &result, idx_t count, stri
 	D_ASSERT(result_scale < source_scale);
 	idx_t scale_difference = source_scale - result_scale;
 	idx_t target_width = result_width + scale_difference;
-	SOURCE divide_factor = POWERS_SOURCE::POWERS_OF_TEN[scale_difference];
+	auto divide_factor = UnsafeNumericCast<SOURCE>(POWERS_SOURCE::POWERS_OF_TEN[scale_difference]);
 	if (source_width < target_width) {
-		DecimalScaleInput<SOURCE> input(result, divide_factor);
+		DecimalScaleInput<SOURCE> input(result, divide_factor, parameters);
 		// type will always fit: no need to check limit
 		UnaryExecutor::GenericExecute<SOURCE, DEST, DecimalScaleDownOperator>(source, result, count, &input);
 		return true;
 	} else {
 		// type might not fit: check limit
-		auto limit = POWERS_SOURCE::POWERS_OF_TEN[target_width];
-		DecimalScaleInput<SOURCE> input(result, limit, divide_factor, error_message, source_width, source_scale);
+
+		auto limit = UnsafeNumericCast<SOURCE>(POWERS_SOURCE::POWERS_OF_TEN[target_width]);
+		DecimalScaleInput<SOURCE> input(result, limit, divide_factor, parameters, source_width, source_scale);
 		UnaryExecutor::GenericExecute<SOURCE, DEST, DecimalScaleDownCheckOperator>(source, result, count, &input,
-		                                                                           error_message);
-		return input.all_converted;
+		                                                                           parameters.error_message);
+		return input.vector_cast_data.all_converted;
 	}
 }
 
@@ -160,16 +158,16 @@ static bool DecimalDecimalCastSwitch(Vector &source, Vector &result, idx_t count
 		switch (result.GetType().InternalType()) {
 		case PhysicalType::INT16:
 			return TemplatedDecimalScaleUp<SOURCE, int16_t, POWERS_SOURCE, NumericHelper>(source, result, count,
-			                                                                              parameters.error_message);
+			                                                                              parameters);
 		case PhysicalType::INT32:
 			return TemplatedDecimalScaleUp<SOURCE, int32_t, POWERS_SOURCE, NumericHelper>(source, result, count,
-			                                                                              parameters.error_message);
+			                                                                              parameters);
 		case PhysicalType::INT64:
 			return TemplatedDecimalScaleUp<SOURCE, int64_t, POWERS_SOURCE, NumericHelper>(source, result, count,
-			                                                                              parameters.error_message);
+			                                                                              parameters);
 		case PhysicalType::INT128:
 			return TemplatedDecimalScaleUp<SOURCE, hugeint_t, POWERS_SOURCE, Hugeint>(source, result, count,
-			                                                                          parameters.error_message);
+			                                                                          parameters);
 		default:
 			throw NotImplementedException("Unimplemented internal type for decimal");
 		}
@@ -177,17 +175,13 @@ static bool DecimalDecimalCastSwitch(Vector &source, Vector &result, idx_t count
 		// divide
 		switch (result.GetType().InternalType()) {
 		case PhysicalType::INT16:
-			return TemplatedDecimalScaleDown<SOURCE, int16_t, POWERS_SOURCE>(source, result, count,
-			                                                                 parameters.error_message);
+			return TemplatedDecimalScaleDown<SOURCE, int16_t, POWERS_SOURCE>(source, result, count, parameters);
 		case PhysicalType::INT32:
-			return TemplatedDecimalScaleDown<SOURCE, int32_t, POWERS_SOURCE>(source, result, count,
-			                                                                 parameters.error_message);
+			return TemplatedDecimalScaleDown<SOURCE, int32_t, POWERS_SOURCE>(source, result, count, parameters);
 		case PhysicalType::INT64:
-			return TemplatedDecimalScaleDown<SOURCE, int64_t, POWERS_SOURCE>(source, result, count,
-			                                                                 parameters.error_message);
+			return TemplatedDecimalScaleDown<SOURCE, int64_t, POWERS_SOURCE>(source, result, count, parameters);
 		case PhysicalType::INT128:
-			return TemplatedDecimalScaleDown<SOURCE, hugeint_t, POWERS_SOURCE>(source, result, count,
-			                                                                   parameters.error_message);
+			return TemplatedDecimalScaleDown<SOURCE, hugeint_t, POWERS_SOURCE>(source, result, count, parameters);
 		default:
 			throw NotImplementedException("Unimplemented internal type for decimal");
 		}

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

@@ -32,6 +32,10 @@ bool DefaultCasts::NopCast(Vector &source, Vector &result, idx_t count, CastPara
 	return true;
 }
 
+void HandleCastError::AssignError(const string &error_message, CastParameters &parameters) {
+	AssignError(error_message, parameters.error_message, parameters.query_location);
+}
+
 static string UnimplementedCastMessage(const LogicalType &source_type, const LogicalType &target_type) {
 	return StringUtil::Format("Unimplemented type for cast (%s -> %s)", source_type.ToString(), target_type.ToString());
 }
@@ -40,8 +44,7 @@ static string UnimplementedCastMessage(const LogicalType &source_type, const Log
 bool DefaultCasts::TryVectorNullCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	bool success = true;
 	if (VectorOperations::HasNotNull(source, count)) {
-		HandleCastError::AssignError(UnimplementedCastMessage(source.GetType(), result.GetType()),
-		                             parameters.error_message);
+		HandleCastError::AssignError(UnimplementedCastMessage(source.GetType(), result.GetType()), parameters);
 		success = false;
 	}
 	result.SetVectorType(VectorType::CONSTANT_VECTOR);

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

@@ -1,3 +1,4 @@
+#include "duckdb/common/numeric_utils.hpp"
 #include "duckdb/function/cast/default_casts.hpp"
 #include "duckdb/function/cast/vector_cast_helpers.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
@@ -6,7 +7,6 @@ namespace duckdb {
 
 template <class SRC_TYPE, class RES_TYPE>
 bool EnumEnumCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	bool all_converted = true;
 	result.SetVectorType(VectorType::FLAT_VECTOR);
 
 	auto &str_vec = EnumType::GetValuesInsertOrder(source.GetType());
@@ -24,6 +24,7 @@ bool EnumEnumCast(Vector &source, Vector &result, idx_t count, CastParameters &p
 	auto result_data = FlatVector::GetData<RES_TYPE>(result);
 	auto &result_mask = FlatVector::Validity(result);
 
+	VectorTryCastData vector_cast_data(result, parameters);
 	for (idx_t i = 0; i < count; i++) {
 		auto src_idx = source_sel->get_index(i);
 		if (!source_mask.RowIsValid(src_idx)) {
@@ -35,16 +36,15 @@ bool EnumEnumCast(Vector &source, Vector &result, idx_t count, CastParameters &p
 			// key doesn't exist on result enum
 			if (!parameters.error_message) {
 				result_data[i] = HandleVectorCastError::Operation<RES_TYPE>(
-				    CastExceptionText<SRC_TYPE, RES_TYPE>(source_data[src_idx]), result_mask, i,
-				    parameters.error_message, all_converted);
+				    CastExceptionText<SRC_TYPE, RES_TYPE>(source_data[src_idx]), result_mask, i, vector_cast_data);
 			} else {
 				result_mask.SetInvalid(i);
 			}
 			continue;
 		}
-		result_data[i] = key;
+		result_data[i] = UnsafeNumericCast<RES_TYPE>(key);
 	}
-	return all_converted;
+	return vector_cast_data.all_converted;
 }
 
 template <class SRC_TYPE>

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

@@ -151,7 +151,7 @@ static bool ListToArrayCast(Vector &source, Vector &result, idx_t count, CastPar
 			// Cant cast to array, list size mismatch
 			auto msg = StringUtil::Format("Cannot cast list with length %llu to array with length %u", ldata.length,
 			                              array_size);
-			HandleCastError::AssignError(msg, parameters.error_message);
+			HandleCastError::AssignError(msg, parameters);
 			ConstantVector::SetNull(result, true);
 			return false;
 		}
@@ -159,10 +159,23 @@ static bool ListToArrayCast(Vector &source, Vector &result, idx_t count, CastPar
 		auto &source_cc = ListVector::GetEntry(source);
 		auto &result_cc = ArrayVector::GetEntry(result);
 
-		// Since the list was constant, there can only be one sequence of data in the child vector
 		CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state);
-		bool all_succeeded = cast_data.child_cast_info.function(source_cc, result_cc, array_size, child_parameters);
-		return all_succeeded;
+
+		if (ldata.offset == 0) {
+			// Fast path: offset is zero, we can just cast `array_size` elements of the child vectors directly
+			// Since the list was constant, there can only be one sequence of data in the child vector
+			return cast_data.child_cast_info.function(source_cc, result_cc, array_size, child_parameters);
+		}
+
+		// Else, we need to copy the range we want to cast to a new vector and cast that
+		// In theory we could slice the source child to create a dictionary, but we would then have to flatten the
+		// result child which is going to allocate a temp vector and perform a copy anyway. Since we just want to copy a
+		// single contiguous range with a single offset, this is simpler.
+
+		Vector payload_vector(source_cc.GetType(), array_size);
+		VectorOperations::Copy(source_cc, payload_vector, ldata.offset + array_size, ldata.offset, 0);
+		return cast_data.child_cast_info.function(payload_vector, result_cc, array_size, child_parameters);
+
 	} else {
 		source.Flatten(count);
 		result.SetVectorType(VectorType::FLAT_VECTOR);
@@ -189,7 +202,7 @@ static bool ListToArrayCast(Vector &source, Vector &result, idx_t count, CastPar
 					all_ok = false;
 					auto msg = StringUtil::Format("Cannot cast list with length %llu to array with length %u",
 					                              ldata[i].length, array_size);
-					HandleCastError::AssignError(msg, parameters.error_message);
+					HandleCastError::AssignError(msg, parameters);
 				}
 				FlatVector::SetNull(result, i, true);
 				for (idx_t array_elem = 0; array_elem < array_size; array_elem++) {
@@ -208,13 +221,13 @@ static bool ListToArrayCast(Vector &source, Vector &result, idx_t count, CastPar
 		// Fast path: No lists are null
 		// We can just cast the child vector directly
 		// Note: Its worth doing a CheckAllValid here, the slow path is significantly more expensive
-		if (FlatVector::Validity(source).CheckAllValid(count)) {
+		if (FlatVector::Validity(result).CheckAllValid(count)) {
 			Vector payload_vector(result_cc.GetType(), child_count);
 
 			bool ok = cast_data.child_cast_info.function(source_cc, payload_vector, child_count, child_parameters);
 			if (all_ok && !ok) {
 				all_ok = false;
-				HandleCastError::AssignError(*child_parameters.error_message, parameters.error_message);
+				HandleCastError::AssignError(*child_parameters.error_message, parameters);
 			}
 			// Now do the actual copy onto the result vector, making sure to slice properly in case the lists are out of
 			// order
@@ -228,12 +241,9 @@ static bool ListToArrayCast(Vector &source, Vector &result, idx_t count, CastPar
 		cast_chunk.Initialize(Allocator::DefaultAllocator(), {source_cc.GetType(), result_cc.GetType()}, array_size);
 
 		for (idx_t i = 0; i < count; i++) {
-			if (FlatVector::IsNull(source, i)) {
-				FlatVector::SetNull(result, i, true);
-				// Also null the array children
-				for (idx_t array_elem = 0; array_elem < array_size; array_elem++) {
-					FlatVector::SetNull(result_cc, i * array_size + array_elem, true);
-				}
+			if (FlatVector::IsNull(result, i)) {
+				// We've already failed to cast this list above (e.g. length mismatch), so theres nothing to do here.
+				continue;
 			} else {
 				auto &list_cast_input = cast_chunk.data[0];
 				auto &list_cast_output = cast_chunk.data[1];
@@ -246,7 +256,7 @@ static bool ListToArrayCast(Vector &source, Vector &result, idx_t count, CastPar
 				    cast_data.child_cast_info.function(list_cast_input, list_cast_output, array_size, child_parameters);
 				if (all_ok && !ok) {
 					all_ok = false;
-					HandleCastError::AssignError(*child_parameters.error_message, parameters.error_message);
+					HandleCastError::AssignError(*child_parameters.error_message, parameters);
 				}
 				VectorOperations::Copy(list_cast_output, result_cc, array_size, 0, i * array_size);
 

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

@@ -1,6 +1,7 @@
 #include "duckdb/function/cast/default_casts.hpp"
 #include "duckdb/function/cast/vector_cast_helpers.hpp"
 #include "duckdb/common/exception/conversion_exception.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 #include "duckdb/common/pair.hpp"
 #include "duckdb/common/vector.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
@@ -11,8 +12,7 @@ namespace duckdb {
 template <class T>
 bool StringEnumCastLoop(const string_t *source_data, ValidityMask &source_mask, const LogicalType &source_type,
                         T *result_data, ValidityMask &result_mask, const LogicalType &result_type, idx_t count,
-                        string *error_message, const SelectionVector *sel) {
-	bool all_converted = true;
+                        VectorTryCastData &vector_cast_data, const SelectionVector *sel) {
 	for (idx_t i = 0; i < count; i++) {
 		idx_t source_idx = i;
 		if (sel) {
@@ -21,17 +21,16 @@ bool StringEnumCastLoop(const string_t *source_data, ValidityMask &source_mask,
 		if (source_mask.RowIsValid(source_idx)) {
 			auto pos = EnumType::GetPos(result_type, source_data[source_idx]);
 			if (pos == -1) {
-				result_data[i] =
-				    HandleVectorCastError::Operation<T>(CastExceptionText<string_t, T>(source_data[source_idx]),
-				                                        result_mask, i, error_message, all_converted);
+				result_data[i] = HandleVectorCastError::Operation<T>(
+				    CastExceptionText<string_t, T>(source_data[source_idx]), result_mask, i, vector_cast_data);
 			} else {
-				result_data[i] = pos;
+				result_data[i] = UnsafeNumericCast<T>(pos);
 			}
 		} else {
 			result_mask.SetInvalid(i);
 		}
 	}
-	return all_converted;
+	return vector_cast_data.all_converted;
 }
 
 template <class T>
@@ -46,8 +45,9 @@ bool StringEnumCast(Vector &source, Vector &result, idx_t count, CastParameters
 		auto result_data = ConstantVector::GetData<T>(result);
 		auto &result_mask = ConstantVector::Validity(result);
 
+		VectorTryCastData vector_cast_data(result, parameters);
 		return StringEnumCastLoop(source_data, source_mask, source.GetType(), result_data, result_mask,
-		                          result.GetType(), 1, parameters.error_message, nullptr);
+		                          result.GetType(), 1, vector_cast_data, nullptr);
 	}
 	default: {
 		UnifiedVectorFormat vdata;
@@ -61,8 +61,9 @@ bool StringEnumCast(Vector &source, Vector &result, idx_t count, CastParameters
 		auto result_data = FlatVector::GetData<T>(result);
 		auto &result_mask = FlatVector::Validity(result);
 
+		VectorTryCastData vector_cast_data(result, parameters);
 		return StringEnumCastLoop(source_data, source_mask, source.GetType(), result_data, result_mask,
-		                          result.GetType(), count, parameters.error_message, source_sel);
+		                          result.GetType(), count, vector_cast_data, source_sel);
 	}
 	}
 }
@@ -144,7 +145,7 @@ bool VectorStringToList::StringToNestedTypeCastLoop(const string_t *source_data,
 	auto list_data = ListVector::GetData(result);
 	auto child_data = FlatVector::GetData<string_t>(varchar_vector);
 
-	bool all_converted = true;
+	VectorTryCastData vector_cast_data(result, parameters);
 	idx_t total = 0;
 	for (idx_t i = 0; i < count; i++) {
 		idx_t idx = i;
@@ -160,7 +161,7 @@ bool VectorStringToList::StringToNestedTypeCastLoop(const string_t *source_data,
 		if (!VectorStringToList::SplitStringList(source_data[idx], child_data, total, varchar_vector)) {
 			string text = "Type VARCHAR with value '" + source_data[idx].GetString() +
 			              "' can't be cast to the destination type LIST";
-			HandleVectorCastError::Operation<string_t>(text, result_mask, idx, parameters.error_message, all_converted);
+			HandleVectorCastError::Operation<string_t>(text, result_mask, idx, vector_cast_data);
 		}
 		list_data[i].length = total - list_data[i].offset; // length is the amount of parts coming from this string
 	}
@@ -169,8 +170,25 @@ bool VectorStringToList::StringToNestedTypeCastLoop(const string_t *source_data,
 	auto &result_child = ListVector::GetEntry(result);
 	auto &cast_data = parameters.cast_data->Cast<ListBoundCastData>();
 	CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state);
-	return cast_data.child_cast_info.function(varchar_vector, result_child, total_list_size, child_parameters) &&
-	       all_converted;
+	bool all_converted =
+	    cast_data.child_cast_info.function(varchar_vector, result_child, total_list_size, child_parameters) &&
+	    vector_cast_data.all_converted;
+	if (!all_converted && parameters.nullify_parent) {
+		UnifiedVectorFormat inserted_column_data;
+		result_child.ToUnifiedFormat(total_list_size, inserted_column_data);
+		UnifiedVectorFormat parse_column_data;
+		varchar_vector.ToUnifiedFormat(total_list_size, parse_column_data);
+		// Something went wrong in the conversion, we need to nullify the parent
+		for (idx_t i = 0; i < count; i++) {
+			for (idx_t j = list_data[i].offset; j < list_data[i].offset + list_data[i].length; j++) {
+				if (!inserted_column_data.validity.RowIsValid(j) && parse_column_data.validity.RowIsValid(j)) {
+					result_mask.SetInvalid(i);
+					break;
+				}
+			}
+		}
+	}
+	return all_converted;
 }
 
 static LogicalType InitVarcharStructType(const LogicalType &target) {
@@ -204,7 +222,7 @@ bool VectorStringToStruct::StringToNestedTypeCastLoop(const string_t *source_dat
 		child_masks[child_idx].get().SetAllInvalid(count);
 	}
 
-	bool all_converted = true;
+	VectorTryCastData vector_cast_data(result, parameters);
 	for (idx_t i = 0; i < count; i++) {
 		idx_t idx = i;
 		if (sel) {
@@ -221,9 +239,9 @@ bool VectorStringToStruct::StringToNestedTypeCastLoop(const string_t *source_dat
 			string text = "Type VARCHAR with value '" + source_data[idx].GetString() +
 			              "' can't be cast to the destination type STRUCT";
 			for (auto &child_mask : child_masks) {
-				child_mask.get().SetInvalid(idx); // some values may have already been found and set valid
+				child_mask.get().SetInvalid(i); // some values may have already been found and set valid
 			}
-			HandleVectorCastError::Operation<string_t>(text, result_mask, idx, parameters.error_message, all_converted);
+			HandleVectorCastError::Operation<string_t>(text, result_mask, i, vector_cast_data);
 		}
 	}
 
@@ -237,10 +255,10 @@ bool VectorStringToStruct::StringToNestedTypeCastLoop(const string_t *source_dat
 		auto &child_cast_info = cast_data.child_cast_info[child_idx];
 		CastParameters child_parameters(parameters, child_cast_info.cast_data, lstate.local_states[child_idx]);
 		if (!child_cast_info.function(child_varchar_vector, result_child_vector, count, child_parameters)) {
-			all_converted = false;
+			vector_cast_data.all_converted = false;
 		}
 	}
-	return all_converted;
+	return vector_cast_data.all_converted;
 }
 
 //===--------------------------------------------------------------------===//
@@ -285,7 +303,7 @@ bool VectorStringToMap::StringToNestedTypeCastLoop(const string_t *source_data,
 	ListVector::SetListSize(result, total_elements);
 	auto list_data = ListVector::GetData(result);
 
-	bool all_converted = true;
+	VectorTryCastData vector_cast_data(result, parameters);
 	idx_t total = 0;
 	for (idx_t i = 0; i < count; i++) {
 		idx_t idx = i;
@@ -293,7 +311,7 @@ bool VectorStringToMap::StringToNestedTypeCastLoop(const string_t *source_data,
 			idx = sel->get_index(i);
 		}
 		if (!source_mask.RowIsValid(idx)) {
-			result_mask.SetInvalid(idx);
+			result_mask.SetInvalid(i);
 			continue;
 		}
 
@@ -302,8 +320,8 @@ bool VectorStringToMap::StringToNestedTypeCastLoop(const string_t *source_data,
 		                                       varchar_key_vector, varchar_val_vector)) {
 			string text = "Type VARCHAR with value '" + source_data[idx].GetString() +
 			              "' can't be cast to the destination type MAP";
-			FlatVector::SetNull(result, idx, true);
-			HandleVectorCastError::Operation<string_t>(text, result_mask, idx, parameters.error_message, all_converted);
+			FlatVector::SetNull(result, i, true);
+			HandleVectorCastError::Operation<string_t>(text, result_mask, i, vector_cast_data);
 		}
 		list_data[i].length = total - list_data[i].offset;
 	}
@@ -316,15 +334,15 @@ bool VectorStringToMap::StringToNestedTypeCastLoop(const string_t *source_data,
 
 	CastParameters key_params(parameters, cast_data.key_cast.cast_data, lstate.key_state);
 	if (!cast_data.key_cast.function(varchar_key_vector, result_key_child, total_elements, key_params)) {
-		all_converted = false;
+		vector_cast_data.all_converted = false;
 	}
 	CastParameters val_params(parameters, cast_data.value_cast.cast_data, lstate.value_state);
 	if (!cast_data.value_cast.function(varchar_val_vector, result_val_child, total_elements, val_params)) {
-		all_converted = false;
+		vector_cast_data.all_converted = false;
 	}
 
 	auto &key_validity = FlatVector::Validity(result_key_child);
-	if (!all_converted) {
+	if (!vector_cast_data.all_converted) {
 		for (idx_t row_idx = 0; row_idx < count; row_idx++) {
 			if (!result_mask.RowIsValid(row_idx)) {
 				continue;
@@ -339,7 +357,7 @@ bool VectorStringToMap::StringToNestedTypeCastLoop(const string_t *source_data,
 		}
 	}
 	MapVector::MapConversionVerify(result, count);
-	return all_converted;
+	return vector_cast_data.all_converted;
 }
 
 //===--------------------------------------------------------------------===//
@@ -370,7 +388,7 @@ bool VectorStringToArray::StringToNestedTypeCastLoop(const string_t *source_data
 				if (parameters.strict) {
 					throw ConversionException(msg);
 				}
-				HandleCastError::AssignError(msg, parameters.error_message);
+				HandleCastError::AssignError(msg, parameters);
 			}
 			result_mask.SetInvalid(i);
 		}
@@ -380,7 +398,7 @@ bool VectorStringToArray::StringToNestedTypeCastLoop(const string_t *source_data
 	Vector varchar_vector(LogicalType::VARCHAR, child_count);
 	auto child_data = FlatVector::GetData<string_t>(varchar_vector);
 
-	bool all_converted = true;
+	VectorTryCastData vector_cast_data(result, parameters);
 	idx_t total = 0;
 	for (idx_t i = 0; i < count; i++) {
 		idx_t idx = i;
@@ -404,7 +422,7 @@ bool VectorStringToArray::StringToNestedTypeCastLoop(const string_t *source_data
 		if (!VectorStringToList::SplitStringList(source_data[idx], child_data, total, varchar_vector)) {
 			auto text = StringUtil::Format("Type VARCHAR with value '%s' can't be cast to the destination type ARRAY",
 			                               source_data[idx].GetString());
-			HandleVectorCastError::Operation<string_t>(text, result_mask, idx, parameters.error_message, all_converted);
+			HandleVectorCastError::Operation<string_t>(text, result_mask, idx, vector_cast_data);
 		}
 	}
 	D_ASSERT(total == child_count);
@@ -414,7 +432,7 @@ bool VectorStringToArray::StringToNestedTypeCastLoop(const string_t *source_data
 	CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state);
 	bool cast_result = cast_data.child_cast_info.function(varchar_vector, result_child, child_count, child_parameters);
 
-	return all_lengths_match && cast_result && all_converted;
+	return all_lengths_match && cast_result && vector_cast_data.all_converted;
 }
 
 template <class T>

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

@@ -14,7 +14,7 @@ unique_ptr<BoundCastData> StructBoundCastData::BindStructToStructCast(BindCastIn
 	auto source_is_unnamed = StructType::IsUnnamed(source);
 
 	if (source_child_types.size() != result_child_types.size()) {
-		throw TypeMismatchException(source, target, "Cannot cast STRUCTs of different size");
+		throw TypeMismatchException(input.query_location, source, target, "Cannot cast STRUCTs of different size");
 	}
 	bool named_struct_cast = !source_is_unnamed && !target_is_unnamed;
 	case_insensitive_map_t<idx_t> target_members;
@@ -36,7 +36,7 @@ unique_ptr<BoundCastData> StructBoundCastData::BindStructToStructCast(BindCastIn
 			// named struct cast - find corresponding member in target
 			auto entry = target_members.find(source_child.first);
 			if (entry == target_members.end()) {
-				throw TypeMismatchException(source, target,
+				throw TypeMismatchException(input.query_location, source, target,
 				                            "Cannot cast STRUCTs - element \"" + source_child.first +
 				                                "\" in source struct was not found in target struct");
 			}