duckdb 0.10.2 → 0.10.3-dev10.0

package/src/duckdb/src/function/scalar/sequence/nextval.cpp

@@ -11,12 +11,13 @@
 #include "duckdb/common/serializer/deserializer.hpp"
 #include "duckdb/common/serializer/serializer.hpp"
 #include "duckdb/common/vector_operations/unary_executor.hpp"
+#include "duckdb/transaction/meta_transaction.hpp"
 #include "duckdb/planner/binder.hpp"
 
 namespace duckdb {
 
 struct CurrentSequenceValueOperator {
-	static int64_t Operation(DuckTransaction &transaction, SequenceCatalogEntry &seq) {
+	static int64_t Operation(DuckTransaction &, SequenceCatalogEntry &seq) {
 		return seq.CurrentValue();
 	}
 };
@@ -27,62 +28,80 @@ struct NextSequenceValueOperator {
 	}
 };
 
+SequenceCatalogEntry &BindSequence(ClientContext &context, string &catalog, string &schema, const string &name) {
+	// fetch the sequence from the catalog
+	Binder::BindSchemaOrCatalog(context, catalog, schema);
+	return Catalog::GetEntry<SequenceCatalogEntry>(context, catalog, schema, name);
+}
+
 SequenceCatalogEntry &BindSequence(ClientContext &context, const string &name) {
 	auto qname = QualifiedName::Parse(name);
-	// fetch the sequence from the catalog
-	Binder::BindSchemaOrCatalog(context, qname.catalog, qname.schema);
-	return Catalog::GetEntry<SequenceCatalogEntry>(context, qname.catalog, qname.schema, qname.name);
+	return BindSequence(context, qname.catalog, qname.schema, qname.name);
+}
+
+struct NextValLocalState : public FunctionLocalState {
+	explicit NextValLocalState(DuckTransaction &transaction, SequenceCatalogEntry &sequence)
+	    : transaction(transaction), sequence(sequence) {
+	}
+
+	DuckTransaction &transaction;
+	SequenceCatalogEntry &sequence;
+};
+
+unique_ptr<FunctionLocalState> NextValLocalFunction(ExpressionState &state, const BoundFunctionExpression &expr,
+                                                    FunctionData *bind_data) {
+	if (!bind_data) {
+		return nullptr;
+	}
+	auto &context = state.GetContext();
+	auto &info = bind_data->Cast<NextvalBindData>();
+	auto &sequence = info.sequence;
+	auto &transaction = DuckTransaction::Get(context, sequence.catalog);
+	return make_uniq<NextValLocalState>(transaction, sequence);
 }
 
 template <class OP>
 static void NextValFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &info = func_expr.bind_info->Cast<NextvalBindData>();
-	auto &input = args.data[0];
-
-	auto &context = state.GetContext();
-	if (info.sequence) {
-		auto &sequence = *info.sequence;
-		auto &transaction = DuckTransaction::Get(context, sequence.catalog);
-		// sequence to use is hard coded
-		// increment the sequence
-		result.SetVectorType(VectorType::FLAT_VECTOR);
-		auto result_data = FlatVector::GetData<int64_t>(result);
-		for (idx_t i = 0; i < args.size(); i++) {
-			// get the next value from the sequence
-			result_data[i] = OP::Operation(transaction, sequence);
-		}
-	} else {
-		// sequence to use comes from the input
-		UnaryExecutor::Execute<string_t, int64_t>(input, result, args.size(), [&](string_t value) {
-			// fetch the sequence from the catalog
-			auto &sequence = BindSequence(context, value.GetString());
-			// finally get the next value from the sequence
-			auto &transaction = DuckTransaction::Get(context, sequence.catalog);
-			return OP::Operation(transaction, sequence);
-		});
+	if (!func_expr.bind_info) {
+		// no bind info - return null
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+		ConstantVector::SetNull(result, true);
+		return;
+	}
+	auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<NextValLocalState>();
+	// sequence to use is hard coded
+	// increment the sequence
+	result.SetVectorType(VectorType::FLAT_VECTOR);
+	auto result_data = FlatVector::GetData<int64_t>(result);
+	for (idx_t i = 0; i < args.size(); i++) {
+		// get the next value from the sequence
+		result_data[i] = OP::Operation(lstate.transaction, lstate.sequence);
 	}
 }
 
-static unique_ptr<FunctionData> NextValBind(ClientContext &context, ScalarFunction &bound_function,
+static unique_ptr<FunctionData> NextValBind(ClientContext &context, ScalarFunction &,
                                             vector<unique_ptr<Expression>> &arguments) {
-	optional_ptr<SequenceCatalogEntry> sequence;
-	if (arguments[0]->IsFoldable()) {
-		// parameter to nextval function is a foldable constant
-		// evaluate the constant and perform the catalog lookup already
-		auto seqname = ExpressionExecutor::EvaluateScalar(context, *arguments[0]);
-		if (!seqname.IsNull()) {
-			sequence = &BindSequence(context, seqname.ToString());
-		}
+	if (!arguments[0]->IsFoldable()) {
+		throw NotImplementedException(
+		    "currval/nextval requires a constant sequence - non-constant sequences are no longer supported");
 	}
-	return make_uniq<NextvalBindData>(sequence);
+	// parameter to nextval function is a foldable constant
+	// evaluate the constant and perform the catalog lookup already
+	auto seqname = ExpressionExecutor::EvaluateScalar(context, *arguments[0]);
+	if (seqname.IsNull()) {
+		return nullptr;
+	}
+	auto &seq = BindSequence(context, seqname.ToString());
+	return make_uniq<NextvalBindData>(seq);
 }
 
 static void NextValDependency(BoundFunctionExpression &expr, LogicalDependencyList &dependencies) {
-	auto &info = expr.bind_info->Cast<NextvalBindData>();
-	if (info.sequence) {
-		dependencies.AddDependency(*info.sequence);
+	if (!expr.bind_info) {
+		return;
 	}
+	auto &info = expr.bind_info->Cast<NextvalBindData>();
+	dependencies.AddDependency(info.sequence);
 }
 
 void Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data, const ScalarFunction &) {
@@ -93,14 +112,21 @@ void Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_dat
 unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, ScalarFunction &) {
 	auto create_info = deserializer.ReadPropertyWithDefault<unique_ptr<CreateInfo>>(100, "sequence_create_info",
 	                                                                                unique_ptr<CreateInfo>());
-	optional_ptr<SequenceCatalogEntry> catalog_entry_ptr;
-	if (create_info) {
-		auto &seq_info = create_info->Cast<CreateSequenceInfo>();
-		auto &context = deserializer.Get<ClientContext &>();
-		catalog_entry_ptr =
-		    &Catalog::GetEntry<SequenceCatalogEntry>(context, seq_info.catalog, seq_info.schema, seq_info.name);
+	if (!create_info) {
+		return nullptr;
+	}
+	auto &seq_info = create_info->Cast<CreateSequenceInfo>();
+	auto &context = deserializer.Get<ClientContext &>();
+	auto &sequence = BindSequence(context, seq_info.catalog, seq_info.schema, seq_info.name);
+	return make_uniq<NextvalBindData>(sequence);
+}
+
+void NextValModifiedDatabases(FunctionModifiedDatabasesInput &input) {
+	if (!input.bind_data) {
+		return;
 	}
-	return make_uniq<NextvalBindData>(catalog_entry_ptr);
+	auto &seq = input.bind_data->Cast<NextvalBindData>();
+	input.modified_databases.insert(seq.sequence.ParentCatalog().GetName());
 }
 
 void NextvalFun::RegisterFunction(BuiltinFunctions &set) {
@@ -109,6 +135,8 @@ void NextvalFun::RegisterFunction(BuiltinFunctions &set) {
 	next_val.stability = FunctionStability::VOLATILE;
 	next_val.serialize = Serialize;
 	next_val.deserialize = Deserialize;
+	next_val.get_modified_databases = NextValModifiedDatabases;
+	next_val.init_local_state = NextValLocalFunction;
 	set.AddFunction(next_val);
 }
 
@@ -118,6 +146,7 @@ void CurrvalFun::RegisterFunction(BuiltinFunctions &set) {
 	curr_val.stability = FunctionStability::VOLATILE;
 	curr_val.serialize = Serialize;
 	curr_val.deserialize = Deserialize;
+	curr_val.init_local_state = NextValLocalFunction;
 	set.AddFunction(curr_val);
 }
 

package/src/duckdb/src/function/scalar/strftime_format.cpp

@@ -80,7 +80,7 @@ idx_t StrfTimeFormat::GetSpecifierLength(StrTimeSpecifier specifier, date_t date
 		if (0 <= year && year <= 9999) {
 			return 4;
 		} else {
-			return NumericHelper::SignedLength<int32_t, uint32_t>(year);
+			return UnsafeNumericCast<idx_t>(NumericHelper::SignedLength<int32_t, uint32_t>(year));
 		}
 	}
 	case StrTimeSpecifier::MONTH_DECIMAL: {
@@ -129,11 +129,14 @@ idx_t StrfTimeFormat::GetSpecifierLength(StrTimeSpecifier specifier, date_t date
 		return len;
 	}
 	case StrTimeSpecifier::DAY_OF_MONTH:
-		return NumericHelper::UnsignedLength<uint32_t>(Date::ExtractDay(date));
+		return UnsafeNumericCast<idx_t>(
+		    NumericHelper::UnsignedLength<uint32_t>(UnsafeNumericCast<uint32_t>(Date::ExtractDay(date))));
 	case StrTimeSpecifier::DAY_OF_YEAR_DECIMAL:
-		return NumericHelper::UnsignedLength<uint32_t>(Date::ExtractDayOfTheYear(date));
+		return UnsafeNumericCast<idx_t>(
+		    NumericHelper::UnsignedLength<uint32_t>(UnsafeNumericCast<uint32_t>(Date::ExtractDayOfTheYear(date))));
 	case StrTimeSpecifier::YEAR_WITHOUT_CENTURY:
-		return NumericHelper::UnsignedLength<uint32_t>(AbsValue(Date::ExtractYear(date)) % 100);
+		return UnsafeNumericCast<idx_t>(NumericHelper::UnsignedLength<uint32_t>(
+		    UnsafeNumericCast<uint32_t>(AbsValue(Date::ExtractYear(date)) % 100)));
 	default:
 		throw InternalException("Unimplemented specifier for GetSpecifierLength");
 	}
@@ -195,13 +198,13 @@ char *StrfTimeFormat::WritePadded(char *target, uint32_t value, size_t padding)
 	D_ASSERT(padding > 1);
 	if (padding % 2) {
 		int decimals = value % 1000;
-		WritePadded3(target + padding - 3, decimals);
+		WritePadded3(target + padding - 3, UnsafeNumericCast<uint32_t>(decimals));
 		value /= 1000;
 		padding -= 3;
 	}
 	for (size_t i = 0; i < padding / 2; i++) {
 		int decimals = value % 100;
-		WritePadded2(target + padding - 2 * (i + 1), decimals);
+		WritePadded2(target + padding - 2 * (i + 1), UnsafeNumericCast<uint32_t>(decimals));
 		value /= 100;
 	}
 	return target + padding;
@@ -245,26 +248,26 @@ char *StrfTimeFormat::WriteDateSpecifier(StrTimeSpecifier specifier, date_t date
 	}
 	case StrTimeSpecifier::DAY_OF_YEAR_PADDED: {
 		int32_t doy = Date::ExtractDayOfTheYear(date);
-		target = WritePadded3(target, doy);
+		target = WritePadded3(target, UnsafeNumericCast<uint32_t>(doy));
 		break;
 	}
 	case StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST:
-		target = WritePadded2(target, Date::ExtractWeekNumberRegular(date, true));
+		target = WritePadded2(target, UnsafeNumericCast<uint32_t>(Date::ExtractWeekNumberRegular(date, true)));
 		break;
 	case StrTimeSpecifier::WEEK_NUMBER_PADDED_SUN_FIRST:
-		target = WritePadded2(target, Date::ExtractWeekNumberRegular(date, false));
+		target = WritePadded2(target, UnsafeNumericCast<uint32_t>(Date::ExtractWeekNumberRegular(date, false)));
 		break;
 	case StrTimeSpecifier::WEEK_NUMBER_ISO:
-		target = WritePadded2(target, Date::ExtractISOWeekNumber(date));
+		target = WritePadded2(target, UnsafeNumericCast<uint32_t>(Date::ExtractISOWeekNumber(date)));
 		break;
 	case StrTimeSpecifier::DAY_OF_YEAR_DECIMAL: {
-		uint32_t doy = Date::ExtractDayOfTheYear(date);
+		auto doy = UnsafeNumericCast<uint32_t>(Date::ExtractDayOfTheYear(date));
 		target += NumericHelper::UnsignedLength<uint32_t>(doy);
 		NumericHelper::FormatUnsigned(doy, target);
 		break;
 	}
 	case StrTimeSpecifier::YEAR_ISO:
-		target = WritePadded(target, Date::ExtractISOYearNumber(date), 4);
+		target = WritePadded(target, UnsafeNumericCast<uint32_t>(Date::ExtractISOYearNumber(date)), 4);
 		break;
 	case StrTimeSpecifier::WEEKDAY_ISO:
 		*target = char('0' + uint8_t(Date::ExtractISODayOfTheWeek(date)));
@@ -281,7 +284,7 @@ char *StrfTimeFormat::WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t
 	// data contains [0] year, [1] month, [2] day, [3] hour, [4] minute, [5] second, [6] msec, [7] utc
 	switch (specifier) {
 	case StrTimeSpecifier::DAY_OF_MONTH_PADDED:
-		target = WritePadded2(target, data[2]);
+		target = WritePadded2(target, UnsafeNumericCast<uint32_t>(data[2]));
 		break;
 	case StrTimeSpecifier::ABBREVIATED_MONTH_NAME: {
 		auto &month_name = Date::MONTH_NAMES_ABBREVIATED[data[1] - 1];
@@ -292,14 +295,14 @@ char *StrfTimeFormat::WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t
 		return WriteString(target, month_name);
 	}
 	case StrTimeSpecifier::MONTH_DECIMAL_PADDED:
-		target = WritePadded2(target, data[1]);
+		target = WritePadded2(target, UnsafeNumericCast<uint32_t>(data[1]));
 		break;
 	case StrTimeSpecifier::YEAR_WITHOUT_CENTURY_PADDED:
-		target = WritePadded2(target, AbsValue(data[0]) % 100);
+		target = WritePadded2(target, UnsafeNumericCast<uint32_t>(AbsValue(data[0]) % 100));
 		break;
 	case StrTimeSpecifier::YEAR_DECIMAL:
 		if (data[0] >= 0 && data[0] <= 9999) {
-			target = WritePadded(target, data[0], 4);
+			target = WritePadded(target, UnsafeNumericCast<uint32_t>(data[0]), 4);
 		} else {
 			int32_t year = data[0];
 			if (data[0] < 0) {
@@ -307,13 +310,13 @@ char *StrfTimeFormat::WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t
 				year = -year;
 				target++;
 			}
-			auto len = NumericHelper::UnsignedLength<uint32_t>(year);
+			auto len = NumericHelper::UnsignedLength<uint32_t>(UnsafeNumericCast<uint32_t>(year));
 			NumericHelper::FormatUnsigned(year, target + len);
 			target += len;
 		}
 		break;
 	case StrTimeSpecifier::HOUR_24_PADDED: {
-		target = WritePadded2(target, data[3]);
+		target = WritePadded2(target, UnsafeNumericCast<uint32_t>(data[3]));
 		break;
 	}
 	case StrTimeSpecifier::HOUR_12_PADDED: {
@@ -321,7 +324,7 @@ char *StrfTimeFormat::WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t
 		if (hour == 0) {
 			hour = 12;
 		}
-		target = WritePadded2(target, hour);
+		target = WritePadded2(target, UnsafeNumericCast<uint32_t>(hour));
 		break;
 	}
 	case StrTimeSpecifier::AM_PM:
@@ -329,20 +332,20 @@ char *StrfTimeFormat::WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t
 		*target++ = 'M';
 		break;
 	case StrTimeSpecifier::MINUTE_PADDED: {
-		target = WritePadded2(target, data[4]);
+		target = WritePadded2(target, UnsafeNumericCast<uint32_t>(data[4]));
 		break;
 	}
 	case StrTimeSpecifier::SECOND_PADDED:
-		target = WritePadded2(target, data[5]);
+		target = WritePadded2(target, UnsafeNumericCast<uint32_t>(data[5]));
 		break;
 	case StrTimeSpecifier::NANOSECOND_PADDED:
-		target = WritePadded(target, data[6] * Interval::NANOS_PER_MICRO, 9);
+		target = WritePadded(target, UnsafeNumericCast<uint32_t>(data[6] * Interval::NANOS_PER_MICRO), 9);
 		break;
 	case StrTimeSpecifier::MICROSECOND_PADDED:
-		target = WritePadded(target, data[6], 6);
+		target = WritePadded(target, UnsafeNumericCast<uint32_t>(data[6]), 6);
 		break;
 	case StrTimeSpecifier::MILLISECOND_PADDED:
-		target = WritePadded3(target, data[6] / Interval::MICROS_PER_MSEC);
+		target = WritePadded3(target, UnsafeNumericCast<uint32_t>(data[6] / Interval::MICROS_PER_MSEC));
 		break;
 	case StrTimeSpecifier::UTC_OFFSET: {
 		*target++ = (data[7] < 0) ? '-' : '+';
@@ -350,10 +353,10 @@ char *StrfTimeFormat::WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t
 		auto offset = abs(data[7]);
 		auto offset_hours = offset / Interval::MINS_PER_HOUR;
 		auto offset_minutes = offset % Interval::MINS_PER_HOUR;
-		target = WritePadded2(target, offset_hours);
+		target = WritePadded2(target, UnsafeNumericCast<uint32_t>(offset_hours));
 		if (offset_minutes) {
 			*target++ = ':';
-			target = WritePadded2(target, offset_minutes);
+			target = WritePadded2(target, UnsafeNumericCast<uint32_t>(offset_minutes));
 		}
 		break;
 	}
@@ -364,7 +367,7 @@ char *StrfTimeFormat::WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t
 		}
 		break;
 	case StrTimeSpecifier::DAY_OF_MONTH: {
-		target = Write2(target, data[2] % 100);
+		target = Write2(target, UnsafeNumericCast<uint8_t>(data[2] % 100));
 		break;
 	}
 	case StrTimeSpecifier::MONTH_DECIMAL: {
@@ -372,7 +375,7 @@ char *StrfTimeFormat::WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t
 		break;
 	}
 	case StrTimeSpecifier::YEAR_WITHOUT_CENTURY: {
-		target = Write2(target, AbsValue(data[0]) % 100);
+		target = Write2(target, UnsafeNumericCast<uint8_t>(AbsValue(data[0]) % 100));
 		break;
 	}
 	case StrTimeSpecifier::HOUR_24_DECIMAL: {
@@ -740,8 +743,7 @@ int32_t StrpTimeFormat::TryParseCollection(const char *data, idx_t &pos, idx_t s
 	return -1;
 }
 
-//! Parses a timestamp using the given specifier
-bool StrpTimeFormat::Parse(string_t str, ParseResult &result) const {
+bool StrpTimeFormat::Parse(const char *data, size_t size, ParseResult &result) const {
 	auto &result_data = result.data;
 	auto &error_message = result.error_message;
 	auto &error_position = result.error_position;
@@ -755,15 +757,11 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) const {
 	result_data[5] = 0;
 	result_data[6] = 0;
 	result_data[7] = 0;
-
-	auto data = str.GetData();
-	idx_t size = str.GetSize();
 	// skip leading spaces
 	while (StringUtil::CharacterIsSpace(*data)) {
 		data++;
 		size--;
 	}
-
 	//	Check for specials
 	//	Precheck for alphas for performance.
 	idx_t pos = 0;
@@ -845,9 +843,9 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) const {
 			// numeric specifier: parse a number
 			uint64_t number = 0;
 			size_t start_pos = pos;
-			size_t end_pos = start_pos + numeric_width[i];
+			size_t end_pos = start_pos + UnsafeNumericCast<size_t>(numeric_width[i]);
 			while (pos < size && pos < end_pos && StringUtil::CharacterIsDigit(data[pos])) {
-				number = number * 10 + data[pos] - '0';
+				number = number * 10 + UnsafeNumericCast<uint64_t>(data[pos]) - '0';
 				pos++;
 			}
 			if (pos == start_pos) {
@@ -1067,7 +1065,6 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) const {
 				case StrTimeSpecifier::YEAR_DECIMAL:
 					// Just validate, don't use
 					break;
-					break;
 				case StrTimeSpecifier::WEEKDAY_DECIMAL:
 					// First offset specifier
 					offset_specifier = specifiers[i];
@@ -1229,7 +1226,7 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) const {
 				// But tz must not be empty.
 				if (tz_end == tz_begin) {
 					error_message = "Empty Time Zone name";
-					error_position = tz_begin - data;
+					error_position = UnsafeNumericCast<idx_t>(tz_begin - data);
 					return false;
 				}
 				result.tz.assign(tz_begin, tz_end);
@@ -1288,7 +1285,9 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) const {
 	case StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST: {
 		// Adjust weekday to be 0-based for the week type
 		if (has_weekday) {
-			weekday = (weekday + 7 - int(offset_specifier == StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST)) % 7;
+			weekday = (weekday + 7 -
+			           static_cast<uint64_t>(offset_specifier == StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST)) %
+			          7;
 		}
 		// Get the start of week 1, move back 7 days and then weekno * 7 + weekday gives the date
 		const auto jan1 = Date::FromDate(result_data[0], 1, 1);
@@ -1324,6 +1323,13 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) const {
 	return true;
 }
 
+//! Parses a timestamp using the given specifier
+bool StrpTimeFormat::Parse(string_t str, ParseResult &result) const {
+	auto data = str.GetData();
+	idx_t size = str.GetSize();
+	return Parse(data, size, result);
+}
+
 StrpTimeFormat::ParseResult StrpTimeFormat::Parse(const string &format_string, const string &text) {
 	StrpTimeFormat format;
 	format.format_specifier = format_string;
@@ -1413,6 +1419,14 @@ bool StrpTimeFormat::TryParseDate(string_t input, date_t &result, string &error_
 	return parse_result.TryToDate(result);
 }
 
+bool StrpTimeFormat::TryParseDate(const char *data, size_t size, date_t &result) const {
+	ParseResult parse_result;
+	if (!Parse(data, size, parse_result)) {
+		return false;
+	}
+	return parse_result.TryToDate(result);
+}
+
 bool StrpTimeFormat::TryParseTime(string_t input, dtime_t &result, string &error_message) const {
 	ParseResult parse_result;
 	if (!Parse(input, parse_result)) {
@@ -1431,4 +1445,12 @@ bool StrpTimeFormat::TryParseTimestamp(string_t input, timestamp_t &result, stri
 	return parse_result.TryToTimestamp(result);
 }
 
+bool StrpTimeFormat::TryParseTimestamp(const char *data, size_t size, timestamp_t &result) const {
+	ParseResult parse_result;
+	if (!Parse(data, size, parse_result)) {
+		return false;
+	}
+	return parse_result.TryToTimestamp(result);
+}
+
 } // namespace duckdb

package/src/duckdb/src/function/scalar/string/caseconvert.cpp

@@ -44,8 +44,8 @@ static string_t ASCIICaseConvert(Vector &result, const char *input_data, idx_t i
 	auto result_str = StringVector::EmptyString(result, output_length);
 	auto result_data = result_str.GetDataWriteable();
 	for (idx_t i = 0; i < input_length; i++) {
-		result_data[i] = IS_UPPER ? UpperFun::ASCII_TO_UPPER_MAP[uint8_t(input_data[i])]
-		                          : LowerFun::ASCII_TO_LOWER_MAP[uint8_t(input_data[i])];
+		result_data[i] = UnsafeNumericCast<char>(IS_UPPER ? UpperFun::ASCII_TO_UPPER_MAP[uint8_t(input_data[i])]
+		                                                  : LowerFun::ASCII_TO_LOWER_MAP[uint8_t(input_data[i])]);
 	}
 	result_str.Finalize();
 	return result_str;
@@ -58,12 +58,12 @@ static idx_t GetResultLength(const char *input_data, idx_t input_length) {
 		if (input_data[i] & 0x80) {
 			// unicode
 			int sz = 0;
-			int codepoint = utf8proc_codepoint(input_data + i, sz);
-			int converted_codepoint = IS_UPPER ? utf8proc_toupper(codepoint) : utf8proc_tolower(codepoint);
-			int new_sz = utf8proc_codepoint_length(converted_codepoint);
+			auto codepoint = utf8proc_codepoint(input_data + i, sz);
+			auto converted_codepoint = IS_UPPER ? utf8proc_toupper(codepoint) : utf8proc_tolower(codepoint);
+			auto new_sz = utf8proc_codepoint_length(converted_codepoint);
 			D_ASSERT(new_sz >= 0);
-			output_length += new_sz;
-			i += sz;
+			output_length += UnsafeNumericCast<idx_t>(new_sz);
+			i += UnsafeNumericCast<idx_t>(sz);
 		} else {
 			// ascii
 			output_length++;
@@ -79,17 +79,17 @@ static void CaseConvert(const char *input_data, idx_t input_length, char *result
 		if (input_data[i] & 0x80) {
 			// non-ascii character
 			int sz = 0, new_sz = 0;
-			int codepoint = utf8proc_codepoint(input_data + i, sz);
-			int converted_codepoint = IS_UPPER ? utf8proc_toupper(codepoint) : utf8proc_tolower(codepoint);
+			auto codepoint = utf8proc_codepoint(input_data + i, sz);
+			auto converted_codepoint = IS_UPPER ? utf8proc_toupper(codepoint) : utf8proc_tolower(codepoint);
 			auto success = utf8proc_codepoint_to_utf8(converted_codepoint, new_sz, result_data);
 			D_ASSERT(success);
 			(void)success;
 			result_data += new_sz;
-			i += sz;
+			i += UnsafeNumericCast<idx_t>(sz);
 		} else {
 			// ascii
-			*result_data = IS_UPPER ? UpperFun::ASCII_TO_UPPER_MAP[uint8_t(input_data[i])]
-			                        : LowerFun::ASCII_TO_LOWER_MAP[uint8_t(input_data[i])];
+			*result_data = UnsafeNumericCast<char>(IS_UPPER ? UpperFun::ASCII_TO_UPPER_MAP[uint8_t(input_data[i])]
+			                                                : LowerFun::ASCII_TO_LOWER_MAP[uint8_t(input_data[i])]);
 			result_data++;
 			i++;
 		}

package/src/duckdb/src/function/scalar/string/contains.cpp

@@ -22,7 +22,7 @@ static idx_t ContainsUnaligned(const unsigned char *haystack, idx_t haystack_siz
 	UNSIGNED haystack_entry = 0;
 	const UNSIGNED start = (sizeof(UNSIGNED) * 8) - 8;
 	const UNSIGNED shift = (sizeof(UNSIGNED) - NEEDLE_SIZE) * 8;
-	for (int i = 0; i < NEEDLE_SIZE; i++) {
+	for (idx_t i = 0; i < NEEDLE_SIZE; i++) {
 		needle_entry |= UNSIGNED(needle[i]) << UNSIGNED(start - i * 8);
 		haystack_entry |= UNSIGNED(haystack[i]) << UNSIGNED(start - i * 8);
 	}
@@ -106,7 +106,7 @@ idx_t ContainsFun::Find(const unsigned char *haystack, idx_t haystack_size, cons
 	if (location == nullptr) {
 		return DConstants::INVALID_INDEX;
 	}
-	idx_t base_offset = const_uchar_ptr_cast(location) - haystack;
+	idx_t base_offset = UnsafeNumericCast<idx_t>(const_uchar_ptr_cast(location) - haystack);
 	haystack_size -= base_offset;
 	haystack = const_uchar_ptr_cast(location);
 	// switch algorithm depending on needle size

package/src/duckdb/src/function/scalar/string/length.cpp

@@ -29,14 +29,14 @@ struct GraphemeCountOperator {
 struct StrLenOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
-		return input.GetSize();
+		return UnsafeNumericCast<TR>(input.GetSize());
 	}
 };
 
 struct OctetLenOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
-		return Bit::OctetLength(input);
+		return UnsafeNumericCast<TR>(Bit::OctetLength(input));
 	}
 };
 
@@ -44,7 +44,7 @@ struct OctetLenOperator {
 struct BitLenOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
-		return 8 * input.GetSize();
+		return UnsafeNumericCast<TR>(8 * input.GetSize());
 	}
 };
 
@@ -52,7 +52,7 @@ struct BitLenOperator {
 struct BitStringLenOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
-		return Bit::BitLength(input);
+		return UnsafeNumericCast<TR>(Bit::BitLength(input));
 	}
 };
 
@@ -73,8 +73,8 @@ static unique_ptr<BaseStatistics> LengthPropagateStats(ClientContext &context, F
 static void ListLengthFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &input = args.data[0];
 	D_ASSERT(input.GetType().id() == LogicalTypeId::LIST);
-	UnaryExecutor::Execute<list_entry_t, int64_t>(input, result, args.size(),
-	                                              [](list_entry_t input) { return input.length; });
+	UnaryExecutor::Execute<list_entry_t, int64_t>(
+	    input, result, args.size(), [](list_entry_t input) { return UnsafeNumericCast<int64_t>(input.length); });
 	if (args.AllConstant()) {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
 	}
@@ -138,7 +138,7 @@ static void ListLengthBinaryFunction(DataChunk &args, ExpressionState &, Vector
 		    if (dimension != 1) {
 			    throw NotImplementedException("array_length for lists with dimensions other than 1 not implemented");
 		    }
-		    return input.length;
+		    return UnsafeNumericCast<int64_t>(input.length);
 	    });
 	if (args.AllConstant()) {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
@@ -174,7 +174,7 @@ static void ArrayLengthBinaryFunction(DataChunk &args, ExpressionState &state, V
 			throw OutOfRangeException(StringUtil::Format(
 			    "array_length dimension '%lld' out of range (min: '1', max: '%lld')", dimension, max_dimension));
 		}
-		return dimensions[dimension - 1];
+		return dimensions[UnsafeNumericCast<idx_t>(dimension - 1)];
 	});
 
 	if (args.AllConstant()) {
@@ -196,7 +196,7 @@ static unique_ptr<FunctionData> ArrayOrListLengthBinaryBind(ClientContext &conte
 		vector<int64_t> dimensions;
 		while (true) {
 			if (type.id() == LogicalTypeId::ARRAY) {
-				dimensions.push_back(ArrayType::GetSize(type));
+				dimensions.push_back(UnsafeNumericCast<int64_t>(ArrayType::GetSize(type)));
 				type = ArrayType::GetChildType(type);
 			} else {
 				break;

package/src/duckdb/src/function/scalar/string/regexp/regexp_extract_all.cpp

@@ -96,7 +96,7 @@ void ExtractSingleTuple(const string_t &string, duckdb_re2::RE2 &pattern, int32_
 			// Every group is a substring of the original, we can find out the offset using the pointer
 			// the 'match_group' address is guaranteed to be bigger than that of the source
 			D_ASSERT(const_char_ptr_cast(match_group.begin()) >= string.GetData());
-			idx_t offset = match_group.begin() - string.GetData();
+			auto offset = UnsafeNumericCast<idx_t>(match_group.begin() - string.GetData());
 			list_content[child_idx] =
 			    string_t(string.GetData() + offset, UnsafeNumericCast<uint32_t>(match_group.size()));
 		}
@@ -199,7 +199,7 @@ void RegexpExtractAll::Execute(DataChunk &args, ExpressionState &state, Vector &
 				if (group_count_p == -1) {
 					throw InvalidInputException("Pattern failed to parse, error: '%s'", stored_re->error());
 				}
-				non_const_args->SetSize(group_count_p);
+				non_const_args->SetSize(UnsafeNumericCast<idx_t>(group_count_p));
 			}
 		}
 

package/src/duckdb/src/function/scalar/string/strip_accents.cpp

@@ -22,7 +22,8 @@ struct StripAccentsOperator {
 		}
 
 		// non-ascii, perform collation
-		auto stripped = utf8proc_remove_accents((const utf8proc_uint8_t *)input.GetData(), input.GetSize());
+		auto stripped = utf8proc_remove_accents((const utf8proc_uint8_t *)input.GetData(),
+		                                        UnsafeNumericCast<utf8proc_ssize_t>(input.GetSize()));
 		auto result_str = StringVector::AddString(result, const_char_ptr_cast(stripped));
 		free(stripped);
 		return result_str;