duckdb 0.10.1-dev9.0 → 0.10.1

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

@@ -927,7 +927,7 @@ bool TryCast::Operation(string_t input, bool &result, bool strict) {
 
 	switch (input_size) {
 	case 1: {
-		char c = std::tolower(*input_data);
+		char c = UnsafeNumericCast<char>(std::tolower(*input_data));
 		if (c == 't' || (!strict && c == '1')) {
 			result = true;
 			return true;
@@ -938,10 +938,10 @@ bool TryCast::Operation(string_t input, bool &result, bool strict) {
 		return false;
 	}
 	case 4: {
-		char t = std::tolower(input_data[0]);
-		char r = std::tolower(input_data[1]);
-		char u = std::tolower(input_data[2]);
-		char e = std::tolower(input_data[3]);
+		char t = UnsafeNumericCast<char>(std::tolower(input_data[0]));
+		char r = UnsafeNumericCast<char>(std::tolower(input_data[1]));
+		char u = UnsafeNumericCast<char>(std::tolower(input_data[2]));
+		char e = UnsafeNumericCast<char>(std::tolower(input_data[3]));
 		if (t == 't' && r == 'r' && u == 'u' && e == 'e') {
 			result = true;
 			return true;
@@ -949,11 +949,11 @@ bool TryCast::Operation(string_t input, bool &result, bool strict) {
 		return false;
 	}
 	case 5: {
-		char f = std::tolower(input_data[0]);
-		char a = std::tolower(input_data[1]);
-		char l = std::tolower(input_data[2]);
-		char s = std::tolower(input_data[3]);
-		char e = std::tolower(input_data[4]);
+		char f = UnsafeNumericCast<char>(std::tolower(input_data[0]));
+		char a = UnsafeNumericCast<char>(std::tolower(input_data[1]));
+		char l = UnsafeNumericCast<char>(std::tolower(input_data[2]));
+		char s = UnsafeNumericCast<char>(std::tolower(input_data[3]));
+		char e = UnsafeNumericCast<char>(std::tolower(input_data[4]));
 		if (f == 'f' && a == 'a' && l == 'l' && s == 's' && e == 'e') {
 			result = false;
 			return true;
@@ -1009,20 +1009,20 @@ bool TryCast::Operation(string_t input, double &result, bool strict) {
 }
 
 template <>
-bool TryCastErrorMessageCommaSeparated::Operation(string_t input, float &result, string *error_message, bool strict) {
-	if (!TryDoubleCast<float>(input.GetData(), input.GetSize(), result, strict, ',')) {
+bool TryCastErrorMessageCommaSeparated::Operation(string_t input, float &result, CastParameters &parameters) {
+	if (!TryDoubleCast<float>(input.GetData(), input.GetSize(), result, parameters.strict, ',')) {
 		HandleCastError::AssignError(StringUtil::Format("Could not cast string to float: \"%s\"", input.GetString()),
-		                             error_message);
+		                             parameters);
 		return false;
 	}
 	return true;
 }
 
 template <>
-bool TryCastErrorMessageCommaSeparated::Operation(string_t input, double &result, string *error_message, bool strict) {
-	if (!TryDoubleCast<double>(input.GetData(), input.GetSize(), result, strict, ',')) {
+bool TryCastErrorMessageCommaSeparated::Operation(string_t input, double &result, CastParameters &parameters) {
+	if (!TryDoubleCast<double>(input.GetData(), input.GetSize(), result, parameters.strict, ',')) {
 		HandleCastError::AssignError(StringUtil::Format("Could not cast string to double: \"%s\"", input.GetString()),
-		                             error_message);
+		                             parameters);
 		return false;
 	}
 	return true;
@@ -1126,37 +1126,49 @@ bool TryCast::Operation(interval_t input, interval_t &result, bool strict) {
 //===--------------------------------------------------------------------===//
 template <>
 duckdb::string_t CastFromTimestampNS::Operation(duckdb::timestamp_t input, Vector &result) {
-	return StringCast::Operation<timestamp_t>(Timestamp::FromEpochNanoSeconds(input.value), result);
+	return StringCast::Operation<timestamp_t>(CastTimestampNsToUs::Operation<timestamp_t, timestamp_t>(input), result);
 }
 template <>
 duckdb::string_t CastFromTimestampMS::Operation(duckdb::timestamp_t input, Vector &result) {
-	return StringCast::Operation<timestamp_t>(Timestamp::FromEpochMs(input.value), result);
+	return StringCast::Operation<timestamp_t>(CastTimestampMsToUs::Operation<timestamp_t, timestamp_t>(input), result);
 }
 template <>
 duckdb::string_t CastFromTimestampSec::Operation(duckdb::timestamp_t input, Vector &result) {
-	return StringCast::Operation<timestamp_t>(Timestamp::FromEpochSeconds(input.value), result);
+	return StringCast::Operation<timestamp_t>(CastTimestampSecToUs::Operation<timestamp_t, timestamp_t>(input), result);
 }
 
 template <>
 timestamp_t CastTimestampUsToMs::Operation(timestamp_t input) {
+	if (!Timestamp::IsFinite(input)) {
+		return input;
+	}
 	timestamp_t cast_timestamp(Timestamp::GetEpochMs(input));
 	return cast_timestamp;
 }
 
 template <>
 timestamp_t CastTimestampUsToNs::Operation(timestamp_t input) {
+	if (!Timestamp::IsFinite(input)) {
+		return input;
+	}
 	timestamp_t cast_timestamp(Timestamp::GetEpochNanoSeconds(input));
 	return cast_timestamp;
 }
 
 template <>
 timestamp_t CastTimestampUsToSec::Operation(timestamp_t input) {
+	if (!Timestamp::IsFinite(input)) {
+		return input;
+	}
 	timestamp_t cast_timestamp(Timestamp::GetEpochSeconds(input));
 	return cast_timestamp;
 }
 
 template <>
 timestamp_t CastTimestampMsToUs::Operation(timestamp_t input) {
+	if (!Timestamp::IsFinite(input)) {
+		return input;
+	}
 	return Timestamp::FromEpochMs(input.value);
 }
 
@@ -1172,17 +1184,36 @@ dtime_t CastTimestampMsToTime::Operation(timestamp_t input) {
 
 template <>
 timestamp_t CastTimestampMsToNs::Operation(timestamp_t input) {
+	if (!Timestamp::IsFinite(input)) {
+		return input;
+	}
 	auto us = CastTimestampMsToUs::Operation<timestamp_t, timestamp_t>(input);
 	return CastTimestampUsToNs::Operation<timestamp_t, timestamp_t>(us);
 }
 
 template <>
 timestamp_t CastTimestampNsToUs::Operation(timestamp_t input) {
+	if (!Timestamp::IsFinite(input)) {
+		return input;
+	}
 	return Timestamp::FromEpochNanoSeconds(input.value);
 }
 
+template <>
+timestamp_t CastTimestampSecToUs::Operation(timestamp_t input) {
+	if (!Timestamp::IsFinite(input)) {
+		return input;
+	}
+	return Timestamp::FromEpochSeconds(input.value);
+}
+
 template <>
 date_t CastTimestampNsToDate::Operation(timestamp_t input) {
+	if (input == timestamp_t::infinity()) {
+		return date_t::infinity();
+	} else if (input == timestamp_t::ninfinity()) {
+		return date_t::ninfinity();
+	}
 	const auto us = CastTimestampNsToUs::Operation<timestamp_t, timestamp_t>(input);
 	return Timestamp::GetDate(us);
 }
@@ -1195,17 +1226,18 @@ dtime_t CastTimestampNsToTime::Operation(timestamp_t input) {
 
 template <>
 timestamp_t CastTimestampSecToMs::Operation(timestamp_t input) {
+	if (!Timestamp::IsFinite(input)) {
+		return input;
+	}
 	auto us = CastTimestampSecToUs::Operation<timestamp_t, timestamp_t>(input);
 	return CastTimestampUsToMs::Operation<timestamp_t, timestamp_t>(us);
 }
 
-template <>
-timestamp_t CastTimestampSecToUs::Operation(timestamp_t input) {
-	return Timestamp::FromEpochSeconds(input.value);
-}
-
 template <>
 timestamp_t CastTimestampSecToNs::Operation(timestamp_t input) {
+	if (!Timestamp::IsFinite(input)) {
+		return input;
+	}
 	auto us = CastTimestampSecToUs::Operation<timestamp_t, timestamp_t>(input);
 	return CastTimestampUsToNs::Operation<timestamp_t, timestamp_t>(us);
 }
@@ -1230,7 +1262,15 @@ bool TryCastToTimestampNS::Operation(string_t input, timestamp_t &result, bool s
 	if (!TryCast::Operation<string_t, timestamp_t>(input, result, strict)) {
 		return false;
 	}
-	result = Timestamp::GetEpochNanoSeconds(result);
+	if (!Timestamp::IsFinite(result)) {
+		return true;
+	}
+
+	int64_t nanoseconds;
+	if (!Timestamp::TryGetEpochNanoSeconds(result, nanoseconds)) {
+		throw ConversionException("Could not convert VARCHAR value '%s' to Timestamp(NS)", input.GetString());
+	}
+	result = nanoseconds;
 	return true;
 }
 
@@ -1239,6 +1279,9 @@ bool TryCastToTimestampMS::Operation(string_t input, timestamp_t &result, bool s
 	if (!TryCast::Operation<string_t, timestamp_t>(input, result, strict)) {
 		return false;
 	}
+	if (!Timestamp::IsFinite(result)) {
+		return true;
+	}
 	result = Timestamp::GetEpochMs(result);
 	return true;
 }
@@ -1248,6 +1291,9 @@ bool TryCastToTimestampSec::Operation(string_t input, timestamp_t &result, bool
 	if (!TryCast::Operation<string_t, timestamp_t>(input, result, strict)) {
 		return false;
 	}
+	if (!Timestamp::IsFinite(result)) {
+		return true;
+	}
 	result = Timestamp::GetEpochSeconds(result);
 	return true;
 }
@@ -1257,6 +1303,9 @@ bool TryCastToTimestampNS::Operation(date_t input, timestamp_t &result, bool str
 	if (!TryCast::Operation<date_t, timestamp_t>(input, result, strict)) {
 		return false;
 	}
+	if (!Timestamp::IsFinite(result)) {
+		return true;
+	}
 	if (!TryMultiplyOperator::Operation(result.value, Interval::NANOS_PER_MICRO, result.value)) {
 		return false;
 	}
@@ -1268,6 +1317,9 @@ bool TryCastToTimestampMS::Operation(date_t input, timestamp_t &result, bool str
 	if (!TryCast::Operation<date_t, timestamp_t>(input, result, strict)) {
 		return false;
 	}
+	if (!Timestamp::IsFinite(result)) {
+		return true;
+	}
 	result.value /= Interval::MICROS_PER_MSEC;
 	return true;
 }
@@ -1277,6 +1329,9 @@ bool TryCastToTimestampSec::Operation(date_t input, timestamp_t &result, bool st
 	if (!TryCast::Operation<date_t, timestamp_t>(input, result, strict)) {
 		return false;
 	}
+	if (!Timestamp::IsFinite(result)) {
+		return true;
+	}
 	result.value /= Interval::MICROS_PER_MSEC * Interval::MSECS_PER_SEC;
 	return true;
 }
@@ -1331,10 +1386,9 @@ string_t CastFromPointer::Operation(uintptr_t input, Vector &vector) {
 // Cast To Blob
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastToBlob::Operation(string_t input, string_t &result, Vector &result_vector, string *error_message,
-                              bool strict) {
+bool TryCastToBlob::Operation(string_t input, string_t &result, Vector &result_vector, CastParameters &parameters) {
 	idx_t result_size;
-	if (!Blob::TryGetBlobSize(input, result_size, error_message)) {
+	if (!Blob::TryGetBlobSize(input, result_size, parameters)) {
 		return false;
 	}
 
@@ -1348,10 +1402,9 @@ bool TryCastToBlob::Operation(string_t input, string_t &result, Vector &result_v
 // Cast To Bit
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastToBit::Operation(string_t input, string_t &result, Vector &result_vector, string *error_message,
-                             bool strict) {
+bool TryCastToBit::Operation(string_t input, string_t &result, Vector &result_vector, CastParameters &parameters) {
 	idx_t result_size;
-	if (!Bit::TryGetBitStringSize(input, result_size, error_message)) {
+	if (!Bit::TryGetBitStringSize(input, result_size, parameters.error_message)) {
 		return false;
 	}
 
@@ -1362,32 +1415,34 @@ bool TryCastToBit::Operation(string_t input, string_t &result, Vector &result_ve
 }
 
 template <>
-bool CastFromBitToNumeric::Operation(string_t input, bool &result, bool strict) {
+bool CastFromBitToNumeric::Operation(string_t input, bool &result, CastParameters &parameters) {
 	D_ASSERT(input.GetSize() > 1);
 
 	uint8_t value;
-	bool success = CastFromBitToNumeric::Operation(input, value, strict);
+	bool success = CastFromBitToNumeric::Operation(input, value, parameters);
 	result = (value > 0);
 	return (success);
 }
 
 template <>
-bool CastFromBitToNumeric::Operation(string_t input, hugeint_t &result, bool strict) {
+bool CastFromBitToNumeric::Operation(string_t input, hugeint_t &result, CastParameters &parameters) {
 	D_ASSERT(input.GetSize() > 1);
 
 	if (input.GetSize() - 1 > sizeof(hugeint_t)) {
-		throw ConversionException("Bitstring doesn't fit inside of %s", GetTypeId<hugeint_t>());
+		throw ConversionException(parameters.query_location, "Bitstring doesn't fit inside of %s",
+		                          GetTypeId<hugeint_t>());
 	}
 	Bit::BitToNumeric(input, result);
 	return (true);
 }
 
 template <>
-bool CastFromBitToNumeric::Operation(string_t input, uhugeint_t &result, bool strict) {
+bool CastFromBitToNumeric::Operation(string_t input, uhugeint_t &result, CastParameters &parameters) {
 	D_ASSERT(input.GetSize() > 1);
 
 	if (input.GetSize() - 1 > sizeof(uhugeint_t)) {
-		throw ConversionException("Bitstring doesn't fit inside of %s", GetTypeId<uhugeint_t>());
+		throw ConversionException(parameters.query_location, "Bitstring doesn't fit inside of %s",
+		                          GetTypeId<uhugeint_t>());
 	}
 	Bit::BitToNumeric(input, result);
 	return (true);
@@ -1408,8 +1463,7 @@ string_t CastFromUUID::Operation(hugeint_t input, Vector &vector) {
 // Cast To UUID
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastToUUID::Operation(string_t input, hugeint_t &result, Vector &result_vector, string *error_message,
-                              bool strict) {
+bool TryCastToUUID::Operation(string_t input, hugeint_t &result, Vector &result_vector, CastParameters &parameters) {
 	return UUID::FromString(input.GetString(), result);
 }
 
@@ -1417,9 +1471,9 @@ bool TryCastToUUID::Operation(string_t input, hugeint_t &result, Vector &result_
 // Cast To Date
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastErrorMessage::Operation(string_t input, date_t &result, string *error_message, bool strict) {
-	if (!TryCast::Operation<string_t, date_t>(input, result, strict)) {
-		HandleCastError::AssignError(Date::ConversionError(input), error_message);
+bool TryCastErrorMessage::Operation(string_t input, date_t &result, CastParameters &parameters) {
+	if (!TryCast::Operation<string_t, date_t>(input, result, parameters.strict)) {
+		HandleCastError::AssignError(Date::ConversionError(input), parameters);
 		return false;
 	}
 	return true;
@@ -1441,9 +1495,9 @@ date_t Cast::Operation(string_t input) {
 // Cast To Time
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastErrorMessage::Operation(string_t input, dtime_t &result, string *error_message, bool strict) {
-	if (!TryCast::Operation<string_t, dtime_t>(input, result, strict)) {
-		HandleCastError::AssignError(Time::ConversionError(input), error_message);
+bool TryCastErrorMessage::Operation(string_t input, dtime_t &result, CastParameters &parameters) {
+	if (!TryCast::Operation<string_t, dtime_t>(input, result, parameters.strict)) {
+		HandleCastError::AssignError(Time::ConversionError(input), parameters);
 		return false;
 	}
 	return true;
@@ -1464,9 +1518,9 @@ dtime_t Cast::Operation(string_t input) {
 // Cast To TimeTZ
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastErrorMessage::Operation(string_t input, dtime_tz_t &result, string *error_message, bool strict) {
-	if (!TryCast::Operation<string_t, dtime_tz_t>(input, result, strict)) {
-		HandleCastError::AssignError(Time::ConversionError(input), error_message);
+bool TryCastErrorMessage::Operation(string_t input, dtime_tz_t &result, CastParameters &parameters) {
+	if (!TryCast::Operation<string_t, dtime_tz_t>(input, result, parameters.strict)) {
+		HandleCastError::AssignError(Time::ConversionError(input), parameters);
 		return false;
 	}
 	return true;
@@ -1475,7 +1529,8 @@ bool TryCastErrorMessage::Operation(string_t input, dtime_tz_t &result, string *
 template <>
 bool TryCast::Operation(string_t input, dtime_tz_t &result, bool strict) {
 	idx_t pos;
-	return Time::TryConvertTimeTZ(input.GetData(), input.GetSize(), pos, result, strict);
+	bool has_offset;
+	return Time::TryConvertTimeTZ(input.GetData(), input.GetSize(), pos, result, has_offset, strict);
 }
 
 template <>
@@ -1491,15 +1546,15 @@ dtime_tz_t Cast::Operation(string_t input) {
 // Cast To Timestamp
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastErrorMessage::Operation(string_t input, timestamp_t &result, string *error_message, bool strict) {
+bool TryCastErrorMessage::Operation(string_t input, timestamp_t &result, CastParameters &parameters) {
 	auto cast_result = Timestamp::TryConvertTimestamp(input.GetData(), input.GetSize(), result);
 	if (cast_result == TimestampCastResult::SUCCESS) {
 		return true;
 	}
 	if (cast_result == TimestampCastResult::ERROR_INCORRECT_FORMAT) {
-		HandleCastError::AssignError(Timestamp::ConversionError(input), error_message);
+		HandleCastError::AssignError(Timestamp::ConversionError(input), parameters);
 	} else {
-		HandleCastError::AssignError(Timestamp::UnsupportedTimezoneError(input), error_message);
+		HandleCastError::AssignError(Timestamp::UnsupportedTimezoneError(input), parameters);
 	}
 	return false;
 }
@@ -1518,8 +1573,8 @@ timestamp_t Cast::Operation(string_t input) {
 // Cast From Interval
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastErrorMessage::Operation(string_t input, interval_t &result, string *error_message, bool strict) {
-	return Interval::FromCString(input.GetData(), input.GetSize(), result, error_message, strict);
+bool TryCastErrorMessage::Operation(string_t input, interval_t &result, CastParameters &parameters) {
+	return Interval::FromCString(input.GetData(), input.GetSize(), result, parameters.error_message, parameters.strict);
 }
 
 //===--------------------------------------------------------------------===//
@@ -1642,7 +1697,7 @@ struct HugeIntegerCastOperation {
 				remainder *= -1;
 			}
 			state.decimal = remainder;
-			state.decimal_total_digits = -e;
+			state.decimal_total_digits = UnsafeNumericCast<uint16_t>(-e);
 			state.decimal_intermediate = 0;
 			state.decimal_intermediate_digits = 0;
 			return Finalize<T, NEGATIVE>(state);
@@ -1826,7 +1881,7 @@ struct DecimalCastOperation {
 			// Everything beyond that amount needs to be truncated
 			if (decimal_excess > exponent) {
 				// We've allowed too many decimals
-				state.excessive_decimals = decimal_excess - exponent;
+				state.excessive_decimals = UnsafeNumericCast<uint8_t>(decimal_excess - exponent);
 				exponent = 0;
 			} else {
 				exponent -= decimal_excess;
@@ -1931,7 +1986,7 @@ struct DecimalCastOperation {
 };
 
 template <class T, char decimal_separator = '.'>
-bool TryDecimalStringCast(string_t input, T &result, string *error_message, uint8_t width, uint8_t scale) {
+bool TryDecimalStringCast(string_t input, T &result, CastParameters &parameters, uint8_t width, uint8_t scale) {
 	DecimalCastData<T> state;
 	state.result = 0;
 	state.width = width;
@@ -1946,7 +2001,7 @@ bool TryDecimalStringCast(string_t input, T &result, string *error_message, uint
 	        input.GetData(), input.GetSize(), state, false)) {
 		string error = StringUtil::Format("Could not convert string \"%s\" to DECIMAL(%d,%d)", input.GetString(),
 		                                  (int)width, (int)scale);
-		HandleCastError::AssignError(error, error_message);
+		HandleCastError::AssignError(error, parameters);
 		return false;
 	}
 	result = state.result;
@@ -1954,48 +2009,51 @@ bool TryDecimalStringCast(string_t input, T &result, string *error_message, uint
 }
 
 template <>
-bool TryCastToDecimal::Operation(string_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryDecimalStringCast<int16_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(string_t input, int16_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return TryDecimalStringCast<int16_t>(input, result, parameters, width, scale);
 }
 
 template <>
-bool TryCastToDecimal::Operation(string_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryDecimalStringCast<int32_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(string_t input, int32_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return TryDecimalStringCast<int32_t>(input, result, parameters, width, scale);
 }
 
 template <>
-bool TryCastToDecimal::Operation(string_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryDecimalStringCast<int64_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(string_t input, int64_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return TryDecimalStringCast<int64_t>(input, result, parameters, width, scale);
 }
 
 template <>
-bool TryCastToDecimal::Operation(string_t input, hugeint_t &result, string *error_message, uint8_t width,
+bool TryCastToDecimal::Operation(string_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
                                  uint8_t scale) {
-	return TryDecimalStringCast<hugeint_t>(input, result, error_message, width, scale);
+	return TryDecimalStringCast<hugeint_t>(input, result, parameters, width, scale);
 }
 
 template <>
-bool TryCastToDecimalCommaSeparated::Operation(string_t input, int16_t &result, string *error_message, uint8_t width,
-                                               uint8_t scale) {
-	return TryDecimalStringCast<int16_t, ','>(input, result, error_message, width, scale);
+bool TryCastToDecimalCommaSeparated::Operation(string_t input, int16_t &result, CastParameters &parameters,
+                                               uint8_t width, uint8_t scale) {
+	return TryDecimalStringCast<int16_t, ','>(input, result, parameters, width, scale);
 }
 
 template <>
-bool TryCastToDecimalCommaSeparated::Operation(string_t input, int32_t &result, string *error_message, uint8_t width,
-                                               uint8_t scale) {
-	return TryDecimalStringCast<int32_t, ','>(input, result, error_message, width, scale);
+bool TryCastToDecimalCommaSeparated::Operation(string_t input, int32_t &result, CastParameters &parameters,
+                                               uint8_t width, uint8_t scale) {
+	return TryDecimalStringCast<int32_t, ','>(input, result, parameters, width, scale);
 }
 
 template <>
-bool TryCastToDecimalCommaSeparated::Operation(string_t input, int64_t &result, string *error_message, uint8_t width,
-                                               uint8_t scale) {
-	return TryDecimalStringCast<int64_t, ','>(input, result, error_message, width, scale);
+bool TryCastToDecimalCommaSeparated::Operation(string_t input, int64_t &result, CastParameters &parameters,
+                                               uint8_t width, uint8_t scale) {
+	return TryDecimalStringCast<int64_t, ','>(input, result, parameters, width, scale);
 }
 
 template <>
-bool TryCastToDecimalCommaSeparated::Operation(string_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                               uint8_t scale) {
-	return TryDecimalStringCast<hugeint_t, ','>(input, result, error_message, width, scale);
+bool TryCastToDecimalCommaSeparated::Operation(string_t input, hugeint_t &result, CastParameters &parameters,
+                                               uint8_t width, uint8_t scale) {
+	return TryDecimalStringCast<hugeint_t, ','>(input, result, parameters, width, scale);
 }
 
 template <>
@@ -2024,9 +2082,9 @@ string_t StringCastFromDecimal::Operation(hugeint_t input, uint8_t width, uint8_
 // Decimal <-> Bool
 //===--------------------------------------------------------------------===//
 template <class T, class OP = NumericHelper>
-bool TryCastBoolToDecimal(bool input, T &result, string *error_message, uint8_t width, uint8_t scale) {
+bool TryCastBoolToDecimal(bool input, T &result, CastParameters &parameters, uint8_t width, uint8_t scale) {
 	if (width > scale) {
-		result = input ? OP::POWERS_OF_TEN[scale] : 0;
+		result = UnsafeNumericCast<T>(input ? OP::POWERS_OF_TEN[scale] : 0);
 		return true;
 	} else {
 		return TryCast::Operation<bool, T>(input, result);
@@ -2034,42 +2092,50 @@ bool TryCastBoolToDecimal(bool input, T &result, string *error_message, uint8_t
 }
 
 template <>
-bool TryCastToDecimal::Operation(bool input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryCastBoolToDecimal<int16_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(bool input, int16_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return TryCastBoolToDecimal<int16_t>(input, result, parameters, width, scale);
 }
 
 template <>
-bool TryCastToDecimal::Operation(bool input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryCastBoolToDecimal<int32_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(bool input, int32_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return TryCastBoolToDecimal<int32_t>(input, result, parameters, width, scale);
 }
 
 template <>
-bool TryCastToDecimal::Operation(bool input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryCastBoolToDecimal<int64_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(bool input, int64_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return TryCastBoolToDecimal<int64_t>(input, result, parameters, width, scale);
 }
 
 template <>
-bool TryCastToDecimal::Operation(bool input, hugeint_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryCastBoolToDecimal<hugeint_t, Hugeint>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(bool input, hugeint_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return TryCastBoolToDecimal<hugeint_t, Hugeint>(input, result, parameters, width, scale);
 }
 
 template <>
-bool TryCastFromDecimal::Operation(int16_t input, bool &result, string *error_message, uint8_t width, uint8_t scale) {
+bool TryCastFromDecimal::Operation(int16_t input, bool &result, CastParameters &parameters, uint8_t width,
+                                   uint8_t scale) {
 	return TryCast::Operation<int16_t, bool>(input, result);
 }
 
 template <>
-bool TryCastFromDecimal::Operation(int32_t input, bool &result, string *error_message, uint8_t width, uint8_t scale) {
+bool TryCastFromDecimal::Operation(int32_t input, bool &result, CastParameters &parameters, uint8_t width,
+                                   uint8_t scale) {
 	return TryCast::Operation<int32_t, bool>(input, result);
 }
 
 template <>
-bool TryCastFromDecimal::Operation(int64_t input, bool &result, string *error_message, uint8_t width, uint8_t scale) {
+bool TryCastFromDecimal::Operation(int64_t input, bool &result, CastParameters &parameters, uint8_t width,
+                                   uint8_t scale) {
 	return TryCast::Operation<int64_t, bool>(input, result);
 }
 
 template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, bool &result, string *error_message, uint8_t width, uint8_t scale) {
+bool TryCastFromDecimal::Operation(hugeint_t input, bool &result, CastParameters &parameters, uint8_t width,
+                                   uint8_t scale) {
 	return TryCast::Operation<hugeint_t, bool>(input, result);
 }
 
@@ -2091,26 +2157,26 @@ struct UnsignedToDecimalOperator {
 };
 
 template <class SRC, class DST, class OP = SignedToDecimalOperator>
-bool StandardNumericToDecimalCast(SRC input, DST &result, string *error_message, uint8_t width, uint8_t scale) {
+bool StandardNumericToDecimalCast(SRC input, DST &result, CastParameters &parameters, uint8_t width, uint8_t scale) {
 	// check for overflow
-	DST max_width = NumericHelper::POWERS_OF_TEN[width - scale];
+	DST max_width = UnsafeNumericCast<DST>(NumericHelper::POWERS_OF_TEN[width - scale]);
 	if (OP::template Operation<SRC, DST>(input, max_width)) {
 		string error = StringUtil::Format("Could not cast value %d to DECIMAL(%d,%d)", input, width, scale);
-		HandleCastError::AssignError(error, error_message);
+		HandleCastError::AssignError(error, parameters);
 		return false;
 	}
-	result = DST(input) * NumericHelper::POWERS_OF_TEN[scale];
+	result = UnsafeNumericCast<DST>(DST(input) * NumericHelper::POWERS_OF_TEN[scale]);
 	return true;
 }
 
 template <class SRC>
-bool NumericToHugeDecimalCast(SRC input, hugeint_t &result, string *error_message, uint8_t width, uint8_t scale) {
+bool NumericToHugeDecimalCast(SRC input, hugeint_t &result, CastParameters &parameters, uint8_t width, uint8_t scale) {
 	// check for overflow
 	hugeint_t max_width = Hugeint::POWERS_OF_TEN[width - scale];
 	hugeint_t hinput = Hugeint::Convert(input);
 	if (hinput >= max_width || hinput <= -max_width) {
 		string error = StringUtil::Format("Could not cast value %s to DECIMAL(%d,%d)", hinput.ToString(), width, scale);
-		HandleCastError::AssignError(error, error_message);
+		HandleCastError::AssignError(error, parameters);
 		return false;
 	}
 	result = hinput * Hugeint::POWERS_OF_TEN[scale];
@@ -2121,191 +2187,216 @@ bool NumericToHugeDecimalCast(SRC input, hugeint_t &result, string *error_messag
 // Cast int8_t -> Decimal
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastToDecimal::Operation(int8_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<int8_t, int16_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(int8_t input, int16_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return StandardNumericToDecimalCast<int8_t, int16_t>(input, result, parameters, width, scale);
 }
 template <>
-bool TryCastToDecimal::Operation(int8_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<int8_t, int32_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(int8_t input, int32_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return StandardNumericToDecimalCast<int8_t, int32_t>(input, result, parameters, width, scale);
 }
 template <>
-bool TryCastToDecimal::Operation(int8_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<int8_t, int64_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(int8_t input, int64_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return StandardNumericToDecimalCast<int8_t, int64_t>(input, result, parameters, width, scale);
 }
 template <>
-bool TryCastToDecimal::Operation(int8_t input, hugeint_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return NumericToHugeDecimalCast<int8_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(int8_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return NumericToHugeDecimalCast<int8_t>(input, result, parameters, width, scale);
 }
 
 //===--------------------------------------------------------------------===//
 // Cast int16_t -> Decimal
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastToDecimal::Operation(int16_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<int16_t, int16_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(int16_t input, int16_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return StandardNumericToDecimalCast<int16_t, int16_t>(input, result, parameters, width, scale);
 }
 template <>
-bool TryCastToDecimal::Operation(int16_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<int16_t, int32_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(int16_t input, int32_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return StandardNumericToDecimalCast<int16_t, int32_t>(input, result, parameters, width, scale);
 }
 template <>
-bool TryCastToDecimal::Operation(int16_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<int16_t, int64_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(int16_t input, int64_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return StandardNumericToDecimalCast<int16_t, int64_t>(input, result, parameters, width, scale);
 }
 template <>
-bool TryCastToDecimal::Operation(int16_t input, hugeint_t &result, string *error_message, uint8_t width,
+bool TryCastToDecimal::Operation(int16_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
                                  uint8_t scale) {
-	return NumericToHugeDecimalCast<int16_t>(input, result, error_message, width, scale);
+	return NumericToHugeDecimalCast<int16_t>(input, result, parameters, width, scale);
 }
 
 //===--------------------------------------------------------------------===//
 // Cast int32_t -> Decimal
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastToDecimal::Operation(int32_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<int32_t, int16_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(int32_t input, int16_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return StandardNumericToDecimalCast<int32_t, int16_t>(input, result, parameters, width, scale);
 }
 template <>
-bool TryCastToDecimal::Operation(int32_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<int32_t, int32_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(int32_t input, int32_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return StandardNumericToDecimalCast<int32_t, int32_t>(input, result, parameters, width, scale);
 }
 template <>
-bool TryCastToDecimal::Operation(int32_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<int32_t, int64_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(int32_t input, int64_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return StandardNumericToDecimalCast<int32_t, int64_t>(input, result, parameters, width, scale);
 }
 template <>
-bool TryCastToDecimal::Operation(int32_t input, hugeint_t &result, string *error_message, uint8_t width,
+bool TryCastToDecimal::Operation(int32_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
                                  uint8_t scale) {
-	return NumericToHugeDecimalCast<int32_t>(input, result, error_message, width, scale);
+	return NumericToHugeDecimalCast<int32_t>(input, result, parameters, width, scale);
 }
 
 //===--------------------------------------------------------------------===//
 // Cast int64_t -> Decimal
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastToDecimal::Operation(int64_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<int64_t, int16_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(int64_t input, int16_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return StandardNumericToDecimalCast<int64_t, int16_t>(input, result, parameters, width, scale);
 }
 template <>
-bool TryCastToDecimal::Operation(int64_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<int64_t, int32_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(int64_t input, int32_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return StandardNumericToDecimalCast<int64_t, int32_t>(input, result, parameters, width, scale);
 }
 template <>
-bool TryCastToDecimal::Operation(int64_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<int64_t, int64_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(int64_t input, int64_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return StandardNumericToDecimalCast<int64_t, int64_t>(input, result, parameters, width, scale);
 }
 template <>
-bool TryCastToDecimal::Operation(int64_t input, hugeint_t &result, string *error_message, uint8_t width,
+bool TryCastToDecimal::Operation(int64_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
                                  uint8_t scale) {
-	return NumericToHugeDecimalCast<int64_t>(input, result, error_message, width, scale);
+	return NumericToHugeDecimalCast<int64_t>(input, result, parameters, width, scale);
 }
 
 //===--------------------------------------------------------------------===//
 // Cast uint8_t -> Decimal
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastToDecimal::Operation(uint8_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<uint8_t, int16_t, UnsignedToDecimalOperator>(input, result, error_message,
-	                                                                                 width, scale);
+bool TryCastToDecimal::Operation(uint8_t input, int16_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return StandardNumericToDecimalCast<uint8_t, int16_t, UnsignedToDecimalOperator>(input, result, parameters, width,
+	                                                                                 scale);
 }
 template <>
-bool TryCastToDecimal::Operation(uint8_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<uint8_t, int32_t, UnsignedToDecimalOperator>(input, result, error_message,
-	                                                                                 width, scale);
+bool TryCastToDecimal::Operation(uint8_t input, int32_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return StandardNumericToDecimalCast<uint8_t, int32_t, UnsignedToDecimalOperator>(input, result, parameters, width,
+	                                                                                 scale);
 }
 template <>
-bool TryCastToDecimal::Operation(uint8_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<uint8_t, int64_t, UnsignedToDecimalOperator>(input, result, error_message,
-	                                                                                 width, scale);
+bool TryCastToDecimal::Operation(uint8_t input, int64_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return StandardNumericToDecimalCast<uint8_t, int64_t, UnsignedToDecimalOperator>(input, result, parameters, width,
+	                                                                                 scale);
 }
 template <>
-bool TryCastToDecimal::Operation(uint8_t input, hugeint_t &result, string *error_message, uint8_t width,
+bool TryCastToDecimal::Operation(uint8_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
                                  uint8_t scale) {
-	return NumericToHugeDecimalCast<uint8_t>(input, result, error_message, width, scale);
+	return NumericToHugeDecimalCast<uint8_t>(input, result, parameters, width, scale);
 }
 
 //===--------------------------------------------------------------------===//
 // Cast uint16_t -> Decimal
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastToDecimal::Operation(uint16_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<uint16_t, int16_t, UnsignedToDecimalOperator>(input, result, error_message,
-	                                                                                  width, scale);
+bool TryCastToDecimal::Operation(uint16_t input, int16_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return StandardNumericToDecimalCast<uint16_t, int16_t, UnsignedToDecimalOperator>(input, result, parameters, width,
+	                                                                                  scale);
 }
 template <>
-bool TryCastToDecimal::Operation(uint16_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<uint16_t, int32_t, UnsignedToDecimalOperator>(input, result, error_message,
-	                                                                                  width, scale);
+bool TryCastToDecimal::Operation(uint16_t input, int32_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return StandardNumericToDecimalCast<uint16_t, int32_t, UnsignedToDecimalOperator>(input, result, parameters, width,
+	                                                                                  scale);
 }
 template <>
-bool TryCastToDecimal::Operation(uint16_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<uint16_t, int64_t, UnsignedToDecimalOperator>(input, result, error_message,
-	                                                                                  width, scale);
+bool TryCastToDecimal::Operation(uint16_t input, int64_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return StandardNumericToDecimalCast<uint16_t, int64_t, UnsignedToDecimalOperator>(input, result, parameters, width,
+	                                                                                  scale);
 }
 template <>
-bool TryCastToDecimal::Operation(uint16_t input, hugeint_t &result, string *error_message, uint8_t width,
+bool TryCastToDecimal::Operation(uint16_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
                                  uint8_t scale) {
-	return NumericToHugeDecimalCast<uint16_t>(input, result, error_message, width, scale);
+	return NumericToHugeDecimalCast<uint16_t>(input, result, parameters, width, scale);
 }
 
 //===--------------------------------------------------------------------===//
 // Cast uint32_t -> Decimal
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastToDecimal::Operation(uint32_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<uint32_t, int16_t, UnsignedToDecimalOperator>(input, result, error_message,
-	                                                                                  width, scale);
+bool TryCastToDecimal::Operation(uint32_t input, int16_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return StandardNumericToDecimalCast<uint32_t, int16_t, UnsignedToDecimalOperator>(input, result, parameters, width,
+	                                                                                  scale);
 }
 template <>
-bool TryCastToDecimal::Operation(uint32_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<uint32_t, int32_t, UnsignedToDecimalOperator>(input, result, error_message,
-	                                                                                  width, scale);
+bool TryCastToDecimal::Operation(uint32_t input, int32_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return StandardNumericToDecimalCast<uint32_t, int32_t, UnsignedToDecimalOperator>(input, result, parameters, width,
+	                                                                                  scale);
 }
 template <>
-bool TryCastToDecimal::Operation(uint32_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<uint32_t, int64_t, UnsignedToDecimalOperator>(input, result, error_message,
-	                                                                                  width, scale);
+bool TryCastToDecimal::Operation(uint32_t input, int64_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return StandardNumericToDecimalCast<uint32_t, int64_t, UnsignedToDecimalOperator>(input, result, parameters, width,
+	                                                                                  scale);
 }
 template <>
-bool TryCastToDecimal::Operation(uint32_t input, hugeint_t &result, string *error_message, uint8_t width,
+bool TryCastToDecimal::Operation(uint32_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
                                  uint8_t scale) {
-	return NumericToHugeDecimalCast<uint32_t>(input, result, error_message, width, scale);
+	return NumericToHugeDecimalCast<uint32_t>(input, result, parameters, width, scale);
 }
 
 //===--------------------------------------------------------------------===//
 // Cast uint64_t -> Decimal
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastToDecimal::Operation(uint64_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<uint64_t, int16_t, UnsignedToDecimalOperator>(input, result, error_message,
-	                                                                                  width, scale);
+bool TryCastToDecimal::Operation(uint64_t input, int16_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return StandardNumericToDecimalCast<uint64_t, int16_t, UnsignedToDecimalOperator>(input, result, parameters, width,
+	                                                                                  scale);
 }
 template <>
-bool TryCastToDecimal::Operation(uint64_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<uint64_t, int32_t, UnsignedToDecimalOperator>(input, result, error_message,
-	                                                                                  width, scale);
+bool TryCastToDecimal::Operation(uint64_t input, int32_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return StandardNumericToDecimalCast<uint64_t, int32_t, UnsignedToDecimalOperator>(input, result, parameters, width,
+	                                                                                  scale);
 }
 template <>
-bool TryCastToDecimal::Operation(uint64_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<uint64_t, int64_t, UnsignedToDecimalOperator>(input, result, error_message,
-	                                                                                  width, scale);
+bool TryCastToDecimal::Operation(uint64_t input, int64_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return StandardNumericToDecimalCast<uint64_t, int64_t, UnsignedToDecimalOperator>(input, result, parameters, width,
+	                                                                                  scale);
 }
 template <>
-bool TryCastToDecimal::Operation(uint64_t input, hugeint_t &result, string *error_message, uint8_t width,
+bool TryCastToDecimal::Operation(uint64_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
                                  uint8_t scale) {
-	return NumericToHugeDecimalCast<uint64_t>(input, result, error_message, width, scale);
+	return NumericToHugeDecimalCast<uint64_t>(input, result, parameters, width, scale);
 }
 
 //===--------------------------------------------------------------------===//
 // Hugeint -> Decimal Cast
 //===--------------------------------------------------------------------===//
 template <class DST>
-bool HugeintToDecimalCast(hugeint_t input, DST &result, string *error_message, uint8_t width, uint8_t scale) {
+bool HugeintToDecimalCast(hugeint_t input, DST &result, CastParameters &parameters, uint8_t width, uint8_t scale) {
 	// check for overflow
 	hugeint_t max_width = Hugeint::POWERS_OF_TEN[width - scale];
 	if (input >= max_width || input <= -max_width) {
 		string error = StringUtil::Format("Could not cast value %s to DECIMAL(%d,%d)", input.ToString(), width, scale);
-		HandleCastError::AssignError(error, error_message);
+		HandleCastError::AssignError(error, parameters);
 		return false;
 	}
 	result = Hugeint::Cast<DST>(input * Hugeint::POWERS_OF_TEN[scale]);
@@ -2313,39 +2404,39 @@ bool HugeintToDecimalCast(hugeint_t input, DST &result, string *error_message, u
 }
 
 template <>
-bool TryCastToDecimal::Operation(hugeint_t input, int16_t &result, string *error_message, uint8_t width,
+bool TryCastToDecimal::Operation(hugeint_t input, int16_t &result, CastParameters &parameters, uint8_t width,
                                  uint8_t scale) {
-	return HugeintToDecimalCast<int16_t>(input, result, error_message, width, scale);
+	return HugeintToDecimalCast<int16_t>(input, result, parameters, width, scale);
 }
 
 template <>
-bool TryCastToDecimal::Operation(hugeint_t input, int32_t &result, string *error_message, uint8_t width,
+bool TryCastToDecimal::Operation(hugeint_t input, int32_t &result, CastParameters &parameters, uint8_t width,
                                  uint8_t scale) {
-	return HugeintToDecimalCast<int32_t>(input, result, error_message, width, scale);
+	return HugeintToDecimalCast<int32_t>(input, result, parameters, width, scale);
 }
 
 template <>
-bool TryCastToDecimal::Operation(hugeint_t input, int64_t &result, string *error_message, uint8_t width,
+bool TryCastToDecimal::Operation(hugeint_t input, int64_t &result, CastParameters &parameters, uint8_t width,
                                  uint8_t scale) {
-	return HugeintToDecimalCast<int64_t>(input, result, error_message, width, scale);
+	return HugeintToDecimalCast<int64_t>(input, result, parameters, width, scale);
 }
 
 template <>
-bool TryCastToDecimal::Operation(hugeint_t input, hugeint_t &result, string *error_message, uint8_t width,
+bool TryCastToDecimal::Operation(hugeint_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
                                  uint8_t scale) {
-	return HugeintToDecimalCast<hugeint_t>(input, result, error_message, width, scale);
+	return HugeintToDecimalCast<hugeint_t>(input, result, parameters, width, scale);
 }
 
 //===--------------------------------------------------------------------===//
 // Uhugeint -> Decimal Cast
 //===--------------------------------------------------------------------===//
 template <class DST>
-bool UhugeintToDecimalCast(uhugeint_t input, DST &result, string *error_message, uint8_t width, uint8_t scale) {
+bool UhugeintToDecimalCast(uhugeint_t input, DST &result, CastParameters &parameters, uint8_t width, uint8_t scale) {
 	// check for overflow
 	uhugeint_t max_width = Uhugeint::POWERS_OF_TEN[width - scale];
 	if (input >= max_width) {
 		string error = StringUtil::Format("Could not cast value %s to DECIMAL(%d,%d)", input.ToString(), width, scale);
-		HandleCastError::AssignError(error, error_message);
+		HandleCastError::AssignError(error, parameters);
 		return false;
 	}
 	result = Uhugeint::Cast<DST>(input * Uhugeint::POWERS_OF_TEN[scale]);
@@ -2353,41 +2444,41 @@ bool UhugeintToDecimalCast(uhugeint_t input, DST &result, string *error_message,
 }
 
 template <>
-bool TryCastToDecimal::Operation(uhugeint_t input, int16_t &result, string *error_message, uint8_t width,
+bool TryCastToDecimal::Operation(uhugeint_t input, int16_t &result, CastParameters &parameters, uint8_t width,
                                  uint8_t scale) {
-	return UhugeintToDecimalCast<int16_t>(input, result, error_message, width, scale);
+	return UhugeintToDecimalCast<int16_t>(input, result, parameters, width, scale);
 }
 
 template <>
-bool TryCastToDecimal::Operation(uhugeint_t input, int32_t &result, string *error_message, uint8_t width,
+bool TryCastToDecimal::Operation(uhugeint_t input, int32_t &result, CastParameters &parameters, uint8_t width,
                                  uint8_t scale) {
-	return UhugeintToDecimalCast<int32_t>(input, result, error_message, width, scale);
+	return UhugeintToDecimalCast<int32_t>(input, result, parameters, width, scale);
 }
 
 template <>
-bool TryCastToDecimal::Operation(uhugeint_t input, int64_t &result, string *error_message, uint8_t width,
+bool TryCastToDecimal::Operation(uhugeint_t input, int64_t &result, CastParameters &parameters, uint8_t width,
                                  uint8_t scale) {
-	return UhugeintToDecimalCast<int64_t>(input, result, error_message, width, scale);
+	return UhugeintToDecimalCast<int64_t>(input, result, parameters, width, scale);
 }
 
 template <>
-bool TryCastToDecimal::Operation(uhugeint_t input, hugeint_t &result, string *error_message, uint8_t width,
+bool TryCastToDecimal::Operation(uhugeint_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
                                  uint8_t scale) {
-	return UhugeintToDecimalCast<hugeint_t>(input, result, error_message, width, scale);
+	return UhugeintToDecimalCast<hugeint_t>(input, result, parameters, width, scale);
 }
 
 //===--------------------------------------------------------------------===//
 // Float/Double -> Decimal Cast
 //===--------------------------------------------------------------------===//
 template <class SRC, class DST>
-bool DoubleToDecimalCast(SRC input, DST &result, string *error_message, uint8_t width, uint8_t scale) {
+bool DoubleToDecimalCast(SRC input, DST &result, CastParameters &parameters, uint8_t width, uint8_t scale) {
 	double value = input * NumericHelper::DOUBLE_POWERS_OF_TEN[scale];
 	// Add the sign (-1, 0, 1) times a tiny value to fix floating point issues (issue 3091)
 	double sign = (double(0) < value) - (value < double(0));
 	value += 1e-9 * sign;
 	if (value <= -NumericHelper::DOUBLE_POWERS_OF_TEN[width] || value >= NumericHelper::DOUBLE_POWERS_OF_TEN[width]) {
 		string error = StringUtil::Format("Could not cast value %f to DECIMAL(%d,%d)", value, width, scale);
-		HandleCastError::AssignError(error, error_message);
+		HandleCastError::AssignError(error, parameters);
 		return false;
 	}
 	result = Cast::Operation<SRC, DST>(value);
@@ -2395,73 +2486,81 @@ bool DoubleToDecimalCast(SRC input, DST &result, string *error_message, uint8_t
 }
 
 template <>
-bool TryCastToDecimal::Operation(float input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return DoubleToDecimalCast<float, int16_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(float input, int16_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return DoubleToDecimalCast<float, int16_t>(input, result, parameters, width, scale);
 }
 
 template <>
-bool TryCastToDecimal::Operation(float input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return DoubleToDecimalCast<float, int32_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(float input, int32_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return DoubleToDecimalCast<float, int32_t>(input, result, parameters, width, scale);
 }
 
 template <>
-bool TryCastToDecimal::Operation(float input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return DoubleToDecimalCast<float, int64_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(float input, int64_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return DoubleToDecimalCast<float, int64_t>(input, result, parameters, width, scale);
 }
 
 template <>
-bool TryCastToDecimal::Operation(float input, hugeint_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return DoubleToDecimalCast<float, hugeint_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(float input, hugeint_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return DoubleToDecimalCast<float, hugeint_t>(input, result, parameters, width, scale);
 }
 
 template <>
-bool TryCastToDecimal::Operation(double input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return DoubleToDecimalCast<double, int16_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(double input, int16_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return DoubleToDecimalCast<double, int16_t>(input, result, parameters, width, scale);
 }
 
 template <>
-bool TryCastToDecimal::Operation(double input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return DoubleToDecimalCast<double, int32_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(double input, int32_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return DoubleToDecimalCast<double, int32_t>(input, result, parameters, width, scale);
 }
 
 template <>
-bool TryCastToDecimal::Operation(double input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return DoubleToDecimalCast<double, int64_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(double input, int64_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return DoubleToDecimalCast<double, int64_t>(input, result, parameters, width, scale);
 }
 
 template <>
-bool TryCastToDecimal::Operation(double input, hugeint_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return DoubleToDecimalCast<double, hugeint_t>(input, result, error_message, width, scale);
+bool TryCastToDecimal::Operation(double input, hugeint_t &result, CastParameters &parameters, uint8_t width,
+                                 uint8_t scale) {
+	return DoubleToDecimalCast<double, hugeint_t>(input, result, parameters, width, scale);
 }
 
 //===--------------------------------------------------------------------===//
 // Decimal -> Numeric Cast
 //===--------------------------------------------------------------------===//
 template <class SRC, class DST>
-bool TryCastDecimalToNumeric(SRC input, DST &result, string *error_message, uint8_t scale) {
+bool TryCastDecimalToNumeric(SRC input, DST &result, CastParameters &parameters, uint8_t scale) {
 	// Round away from 0.
 	const auto power = NumericHelper::POWERS_OF_TEN[scale];
 	// https://graphics.stanford.edu/~seander/bithacks.html#ConditionalNegate
 	const auto fNegate = int64_t(input < 0);
 	const auto rounding = ((power ^ -fNegate) + fNegate) / 2;
 	const auto scaled_value = (input + rounding) / power;
-	if (!TryCast::Operation<SRC, DST>(scaled_value, result)) {
+	if (!TryCast::Operation<SRC, DST>(UnsafeNumericCast<SRC>(scaled_value), result)) {
 		string error = StringUtil::Format("Failed to cast decimal value %d to type %s", scaled_value, GetTypeId<DST>());
-		HandleCastError::AssignError(error, error_message);
+		HandleCastError::AssignError(error, parameters);
 		return false;
 	}
 	return true;
 }
 
 template <class DST>
-bool TryCastHugeDecimalToNumeric(hugeint_t input, DST &result, string *error_message, uint8_t scale) {
+bool TryCastHugeDecimalToNumeric(hugeint_t input, DST &result, CastParameters &parameters, uint8_t scale) {
 	const auto power = Hugeint::POWERS_OF_TEN[scale];
 	const auto rounding = ((input < 0) ? -power : power) / 2;
 	auto scaled_value = (input + rounding) / power;
 	if (!TryCast::Operation<hugeint_t, DST>(scaled_value, result)) {
 		string error = StringUtil::Format("Failed to cast decimal value %s to type %s",
 		                                  ConvertToString::Operation(scaled_value), GetTypeId<DST>());
-		HandleCastError::AssignError(error, error_message);
+		HandleCastError::AssignError(error, parameters);
 		return false;
 	}
 	return true;
@@ -2471,237 +2570,240 @@ bool TryCastHugeDecimalToNumeric(hugeint_t input, DST &result, string *error_mes
 // Cast Decimal -> int8_t
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastFromDecimal::Operation(int16_t input, int8_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, int8_t>(input, result, error_message, scale);
+bool TryCastFromDecimal::Operation(int16_t input, int8_t &result, CastParameters &parameters, uint8_t width,
+                                   uint8_t scale) {
+	return TryCastDecimalToNumeric<int16_t, int8_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(int32_t input, int8_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, int8_t>(input, result, error_message, scale);
+bool TryCastFromDecimal::Operation(int32_t input, int8_t &result, CastParameters &parameters, uint8_t width,
+                                   uint8_t scale) {
+	return TryCastDecimalToNumeric<int32_t, int8_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(int64_t input, int8_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, int8_t>(input, result, error_message, scale);
+bool TryCastFromDecimal::Operation(int64_t input, int8_t &result, CastParameters &parameters, uint8_t width,
+                                   uint8_t scale) {
+	return TryCastDecimalToNumeric<int64_t, int8_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, int8_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(hugeint_t input, int8_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<int8_t>(input, result, error_message, scale);
+	return TryCastHugeDecimalToNumeric<int8_t>(input, result, parameters, scale);
 }
 
 //===--------------------------------------------------------------------===//
 // Cast Decimal -> int16_t
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastFromDecimal::Operation(int16_t input, int16_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int16_t input, int16_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, int16_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int16_t, int16_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(int32_t input, int16_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int32_t input, int16_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, int16_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int32_t, int16_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(int64_t input, int16_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int64_t input, int16_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, int16_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int64_t, int16_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, int16_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(hugeint_t input, int16_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<int16_t>(input, result, error_message, scale);
+	return TryCastHugeDecimalToNumeric<int16_t>(input, result, parameters, scale);
 }
 
 //===--------------------------------------------------------------------===//
 // Cast Decimal -> int32_t
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastFromDecimal::Operation(int16_t input, int32_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int16_t input, int32_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, int32_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int16_t, int32_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(int32_t input, int32_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int32_t input, int32_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, int32_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int32_t, int32_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(int64_t input, int32_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int64_t input, int32_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, int32_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int64_t, int32_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, int32_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(hugeint_t input, int32_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<int32_t>(input, result, error_message, scale);
+	return TryCastHugeDecimalToNumeric<int32_t>(input, result, parameters, scale);
 }
 
 //===--------------------------------------------------------------------===//
 // Cast Decimal -> int64_t
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastFromDecimal::Operation(int16_t input, int64_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int16_t input, int64_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, int64_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int16_t, int64_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(int32_t input, int64_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int32_t input, int64_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, int64_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int32_t, int64_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(int64_t input, int64_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int64_t input, int64_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, int64_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int64_t, int64_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, int64_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(hugeint_t input, int64_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<int64_t>(input, result, error_message, scale);
+	return TryCastHugeDecimalToNumeric<int64_t>(input, result, parameters, scale);
 }
 
 //===--------------------------------------------------------------------===//
 // Cast Decimal -> uint8_t
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastFromDecimal::Operation(int16_t input, uint8_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int16_t input, uint8_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, uint8_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int16_t, uint8_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(int32_t input, uint8_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int32_t input, uint8_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, uint8_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int32_t, uint8_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(int64_t input, uint8_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int64_t input, uint8_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, uint8_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int64_t, uint8_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, uint8_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(hugeint_t input, uint8_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<uint8_t>(input, result, error_message, scale);
+	return TryCastHugeDecimalToNumeric<uint8_t>(input, result, parameters, scale);
 }
 
 //===--------------------------------------------------------------------===//
 // Cast Decimal -> uint16_t
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastFromDecimal::Operation(int16_t input, uint16_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int16_t input, uint16_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, uint16_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int16_t, uint16_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(int32_t input, uint16_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int32_t input, uint16_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, uint16_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int32_t, uint16_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(int64_t input, uint16_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int64_t input, uint16_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, uint16_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int64_t, uint16_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, uint16_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(hugeint_t input, uint16_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<uint16_t>(input, result, error_message, scale);
+	return TryCastHugeDecimalToNumeric<uint16_t>(input, result, parameters, scale);
 }
 
 //===--------------------------------------------------------------------===//
 // Cast Decimal -> uint32_t
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastFromDecimal::Operation(int16_t input, uint32_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int16_t input, uint32_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, uint32_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int16_t, uint32_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(int32_t input, uint32_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int32_t input, uint32_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, uint32_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int32_t, uint32_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(int64_t input, uint32_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int64_t input, uint32_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, uint32_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int64_t, uint32_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, uint32_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(hugeint_t input, uint32_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<uint32_t>(input, result, error_message, scale);
+	return TryCastHugeDecimalToNumeric<uint32_t>(input, result, parameters, scale);
 }
 
 //===--------------------------------------------------------------------===//
 // Cast Decimal -> uint64_t
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastFromDecimal::Operation(int16_t input, uint64_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int16_t input, uint64_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, uint64_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int16_t, uint64_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(int32_t input, uint64_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int32_t input, uint64_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, uint64_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int32_t, uint64_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(int64_t input, uint64_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int64_t input, uint64_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, uint64_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int64_t, uint64_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, uint64_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(hugeint_t input, uint64_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<uint64_t>(input, result, error_message, scale);
+	return TryCastHugeDecimalToNumeric<uint64_t>(input, result, parameters, scale);
 }
 
 //===--------------------------------------------------------------------===//
 // Cast Decimal -> hugeint_t
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastFromDecimal::Operation(int16_t input, hugeint_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int16_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, hugeint_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int16_t, hugeint_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(int32_t input, hugeint_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int32_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, hugeint_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int32_t, hugeint_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(int64_t input, hugeint_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int64_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, hugeint_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int64_t, hugeint_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, hugeint_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(hugeint_t input, hugeint_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<hugeint_t>(input, result, error_message, scale);
+	return TryCastHugeDecimalToNumeric<hugeint_t>(input, result, parameters, scale);
 }
 
 //===--------------------------------------------------------------------===//
 // Cast Decimal -> uhugeint_t
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastFromDecimal::Operation(int16_t input, uhugeint_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int16_t input, uhugeint_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, uhugeint_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int16_t, uhugeint_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(int32_t input, uhugeint_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int32_t input, uhugeint_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, uhugeint_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int32_t, uhugeint_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(int64_t input, uhugeint_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(int64_t input, uhugeint_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, uhugeint_t>(input, result, error_message, scale);
+	return TryCastDecimalToNumeric<int64_t, uhugeint_t>(input, result, parameters, scale);
 }
 template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, uhugeint_t &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(hugeint_t input, uhugeint_t &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<uhugeint_t>(input, result, error_message, scale);
+	return TryCastHugeDecimalToNumeric<uhugeint_t>(input, result, parameters, scale);
 }
 
 //===--------------------------------------------------------------------===//
@@ -2715,44 +2817,50 @@ bool TryCastDecimalToFloatingPoint(SRC input, DST &result, uint8_t scale) {
 
 // DECIMAL -> FLOAT
 template <>
-bool TryCastFromDecimal::Operation(int16_t input, float &result, string *error_message, uint8_t width, uint8_t scale) {
+bool TryCastFromDecimal::Operation(int16_t input, float &result, CastParameters &parameters, uint8_t width,
+                                   uint8_t scale) {
 	return TryCastDecimalToFloatingPoint<int16_t, float>(input, result, scale);
 }
 
 template <>
-bool TryCastFromDecimal::Operation(int32_t input, float &result, string *error_message, uint8_t width, uint8_t scale) {
+bool TryCastFromDecimal::Operation(int32_t input, float &result, CastParameters &parameters, uint8_t width,
+                                   uint8_t scale) {
 	return TryCastDecimalToFloatingPoint<int32_t, float>(input, result, scale);
 }
 
 template <>
-bool TryCastFromDecimal::Operation(int64_t input, float &result, string *error_message, uint8_t width, uint8_t scale) {
+bool TryCastFromDecimal::Operation(int64_t input, float &result, CastParameters &parameters, uint8_t width,
+                                   uint8_t scale) {
 	return TryCastDecimalToFloatingPoint<int64_t, float>(input, result, scale);
 }
 
 template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, float &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(hugeint_t input, float &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
 	return TryCastDecimalToFloatingPoint<hugeint_t, float>(input, result, scale);
 }
 
 // DECIMAL -> DOUBLE
 template <>
-bool TryCastFromDecimal::Operation(int16_t input, double &result, string *error_message, uint8_t width, uint8_t scale) {
+bool TryCastFromDecimal::Operation(int16_t input, double &result, CastParameters &parameters, uint8_t width,
+                                   uint8_t scale) {
 	return TryCastDecimalToFloatingPoint<int16_t, double>(input, result, scale);
 }
 
 template <>
-bool TryCastFromDecimal::Operation(int32_t input, double &result, string *error_message, uint8_t width, uint8_t scale) {
+bool TryCastFromDecimal::Operation(int32_t input, double &result, CastParameters &parameters, uint8_t width,
+                                   uint8_t scale) {
 	return TryCastDecimalToFloatingPoint<int32_t, double>(input, result, scale);
 }
 
 template <>
-bool TryCastFromDecimal::Operation(int64_t input, double &result, string *error_message, uint8_t width, uint8_t scale) {
+bool TryCastFromDecimal::Operation(int64_t input, double &result, CastParameters &parameters, uint8_t width,
+                                   uint8_t scale) {
 	return TryCastDecimalToFloatingPoint<int64_t, double>(input, result, scale);
 }
 
 template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, double &result, string *error_message, uint8_t width,
+bool TryCastFromDecimal::Operation(hugeint_t input, double &result, CastParameters &parameters, uint8_t width,
                                    uint8_t scale) {
 	return TryCastDecimalToFloatingPoint<hugeint_t, double>(input, result, scale);
 }