duckdb 1.0.1-dev22.0 → 1.0.1-dev27.0

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

@@ -0,0 +1,56 @@
+#include "duckdb/core_functions/scalar/map_functions.hpp"
+#include "duckdb/function/scalar/list/contains_or_position.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
+
+namespace duckdb {
+
+static void MapContainsFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+	const auto count = input.size();
+
+	auto &map_vec = input.data[0];
+	auto &key_vec = MapVector::GetKeys(map_vec);
+	auto &arg_vec = input.data[1];
+
+	ListSearchOp<false>(map_vec, key_vec, arg_vec, result, count);
+
+	if (count == 1) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+}
+
+static unique_ptr<FunctionData> MapContainsBind(ClientContext &context, ScalarFunction &bound_function,
+                                                vector<unique_ptr<Expression>> &arguments) {
+	D_ASSERT(bound_function.arguments.size() == 2);
+
+	const auto &map = arguments[0]->return_type;
+	const auto &key = arguments[1]->return_type;
+
+	if (map.id() == LogicalTypeId::UNKNOWN) {
+		throw ParameterNotResolvedException();
+	}
+
+	if (key.id() == LogicalTypeId::UNKNOWN) {
+		// Infer the argument type from the map type
+		bound_function.arguments[0] = map;
+		bound_function.arguments[1] = MapType::KeyType(map);
+	} else {
+		LogicalType max_child_type;
+		if (!LogicalType::TryGetMaxLogicalType(context, MapType::KeyType(map), key, max_child_type)) {
+			throw BinderException(
+			    "%s: Cannot match element of type '%s' in a map of type '%s' - an explicit cast is required",
+			    bound_function.name, key.ToString(), map.ToString());
+		}
+
+		bound_function.arguments[0] = LogicalType::MAP(max_child_type, MapType::ValueType(map));
+		bound_function.arguments[1] = max_child_type;
+	}
+	return nullptr;
+}
+
+ScalarFunction MapContainsFun::GetFunction() {
+
+	ScalarFunction fun("map_contains", {LogicalType::MAP(LogicalType::ANY, LogicalType::ANY), LogicalType::ANY},
+	                   LogicalType::BOOLEAN, MapContainsFunction, MapContainsBind);
+	return fun;
+}
+} // namespace duckdb

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

@@ -4,125 +4,9 @@
 #include "duckdb/parser/expression/bound_expression.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
-
+#include "duckdb/function/scalar/list/contains_or_position.hpp"
 namespace duckdb {
 
-struct MapKeyArgFunctor {
-	// MAP is a LIST(STRUCT(K,V))
-	// meaning the MAP itself is a List, but the child vector that we're interested in (the keys)
-	// are a level deeper than the initial child vector
-
-	static Vector &GetList(Vector &map) {
-		return map;
-	}
-	static idx_t GetListSize(Vector &map) {
-		return ListVector::GetListSize(map);
-	}
-	static Vector &GetEntry(Vector &map) {
-		return MapVector::GetKeys(map);
-	}
-};
-
-void FillResult(Vector &map, Vector &offsets, Vector &result, idx_t count) {
-	UnifiedVectorFormat map_data;
-	map.ToUnifiedFormat(count, map_data);
-
-	UnifiedVectorFormat offset_data;
-	offsets.ToUnifiedFormat(count, offset_data);
-
-	auto result_data = FlatVector::GetData<list_entry_t>(result);
-	auto entry_count = ListVector::GetListSize(map);
-	auto &values_entries = MapVector::GetValues(map);
-	UnifiedVectorFormat values_entry_data;
-	// Note: this vector can have a different size than the map
-	values_entries.ToUnifiedFormat(entry_count, values_entry_data);
-
-	for (idx_t row = 0; row < count; row++) {
-		idx_t offset_idx = offset_data.sel->get_index(row);
-		auto offset = UnifiedVectorFormat::GetData<int32_t>(offset_data)[offset_idx];
-
-		// Get the current size of the list, for the offset
-		idx_t current_offset = ListVector::GetListSize(result);
-		if (!offset_data.validity.RowIsValid(offset_idx) || !offset) {
-			// Set the entry data for this result row
-			auto &entry = result_data[row];
-			entry.length = 0;
-			entry.offset = current_offset;
-			continue;
-		}
-		// All list indices start at 1, reduce by 1 to get the actual index
-		offset--;
-
-		// Get the 'values' list entry corresponding to the offset
-		idx_t value_index = map_data.sel->get_index(row);
-		auto &value_list_entry = UnifiedVectorFormat::GetData<list_entry_t>(map_data)[value_index];
-
-		// Add the values to the result
-		idx_t list_offset = value_list_entry.offset + UnsafeNumericCast<idx_t>(offset);
-		// All keys are unique, only one will ever match
-		idx_t length = 1;
-		ListVector::Append(result, values_entries, length + list_offset, list_offset);
-
-		// Set the entry data for this result row
-		auto &entry = result_data[row];
-		entry.length = length;
-		entry.offset = current_offset;
-	}
-}
-
-static bool ArgumentIsConstantNull(Vector &argument) {
-	return argument.GetType().id() == LogicalTypeId::SQLNULL;
-}
-
-static void MapExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.data.size() == 2);
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-
-	auto &map = args.data[0];
-	auto &key = args.data[1];
-
-	idx_t tuple_count = args.size();
-	// Optimization: because keys are not allowed to be NULL, we can early-out
-	if (ArgumentIsConstantNull(map) || ArgumentIsConstantNull(key)) {
-		//! We don't need to look through the map if the 'key' to look for is NULL
-		ListVector::SetListSize(result, 0);
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		auto list_data = ConstantVector::GetData<list_entry_t>(result);
-		list_data->offset = 0;
-		list_data->length = 0;
-		result.Verify(tuple_count);
-		return;
-	}
-	D_ASSERT(map.GetType().id() == LogicalTypeId::MAP);
-
-	UnifiedVectorFormat map_data;
-
-	// Create the chunk we'll feed to ListPosition
-	DataChunk list_position_chunk;
-	vector<LogicalType> chunk_types;
-	chunk_types.reserve(2);
-	chunk_types.push_back(map.GetType());
-	chunk_types.push_back(key.GetType());
-	list_position_chunk.InitializeEmpty(chunk_types.begin(), chunk_types.end());
-
-	// Populate it with the map keys list and the key vector
-	list_position_chunk.data[0].Reference(map);
-	list_position_chunk.data[1].Reference(key);
-	list_position_chunk.SetCardinality(tuple_count);
-
-	Vector position_vector(LogicalType::LIST(LogicalType::INTEGER), tuple_count);
-	// We can pass around state as it's not used by ListPositionFunction anyways
-	ListContainsOrPosition<int32_t, PositionFunctor, MapKeyArgFunctor>(list_position_chunk, position_vector);
-
-	FillResult(map, position_vector, result, tuple_count);
-
-	if (tuple_count == 1) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-
-	result.Verify(tuple_count);
-}
-
 static unique_ptr<FunctionData> MapExtractBind(ClientContext &context, ScalarFunction &bound_function,
                                                vector<unique_ptr<Expression>> &arguments) {
 	if (arguments.size() != 2) {
@@ -151,8 +35,79 @@ static unique_ptr<FunctionData> MapExtractBind(ClientContext &context, ScalarFun
 	return make_uniq<VariableReturnBindData>(bound_function.return_type);
 }
 
+static void MapExtractFunc(DataChunk &args, ExpressionState &state, Vector &result) {
+	const auto count = args.size();
+
+	auto &map_vec = args.data[0];
+	auto &arg_vec = args.data[1];
+
+	const auto map_is_null = map_vec.GetType().id() == LogicalTypeId::SQLNULL;
+	const auto arg_is_null = arg_vec.GetType().id() == LogicalTypeId::SQLNULL;
+
+	if (map_is_null || arg_is_null) {
+		// Short-circuit if either the map or the arg is NULL
+		ListVector::SetListSize(result, 0);
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+		ConstantVector::GetData<list_entry_t>(result)[0] = {0, 0};
+		result.Verify(count);
+		return;
+	}
+
+	auto &key_vec = MapVector::GetKeys(map_vec);
+	auto &val_vec = MapVector::GetValues(map_vec);
+
+	// Collect the matching positions
+	Vector pos_vec(LogicalType::INTEGER, count);
+	ListSearchOp<true>(map_vec, key_vec, arg_vec, pos_vec, args.size());
+
+	UnifiedVectorFormat val_format;
+	UnifiedVectorFormat pos_format;
+	UnifiedVectorFormat lst_format;
+
+	val_vec.ToUnifiedFormat(ListVector::GetListSize(map_vec), val_format);
+	pos_vec.ToUnifiedFormat(count, pos_format);
+	map_vec.ToUnifiedFormat(count, lst_format);
+
+	const auto pos_data = UnifiedVectorFormat::GetData<int32_t>(pos_format);
+	const auto inc_list_data = ListVector::GetData(map_vec);
+	const auto out_list_data = ListVector::GetData(result);
+
+	idx_t offset = 0;
+	for (idx_t row_idx = 0; row_idx < count; row_idx++) {
+		auto lst_idx = lst_format.sel->get_index(row_idx);
+		if (!lst_format.validity.RowIsValid(lst_idx)) {
+			FlatVector::SetNull(result, row_idx, true);
+			continue;
+		}
+
+		auto &inc_list = inc_list_data[lst_idx];
+		auto &out_list = out_list_data[row_idx];
+
+		const auto pos_idx = pos_format.sel->get_index(row_idx);
+		if (!pos_format.validity.RowIsValid(pos_idx)) {
+			// We didnt find the key in the map, so return an empty list
+			out_list.offset = offset;
+			out_list.length = 0;
+			continue;
+		}
+
+		// Compute the actual position of the value in the map value vector
+		const auto pos = inc_list.offset + UnsafeNumericCast<idx_t>(pos_data[pos_idx] - 1);
+		out_list.offset = offset;
+		out_list.length = 1;
+		ListVector::Append(result, val_vec, pos + 1, pos);
+		offset++;
+	}
+
+	if (args.size() == 1) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+
+	result.Verify(count);
+}
+
 ScalarFunction MapExtractFun::GetFunction() {
-	ScalarFunction fun({LogicalType::ANY, LogicalType::ANY}, LogicalType::ANY, MapExtractFunction, MapExtractBind);
+	ScalarFunction fun({LogicalType::ANY, LogicalType::ANY}, LogicalType::ANY, MapExtractFunc, MapExtractBind);
 	fun.varargs = LogicalType::ANY;
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	return fun;

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

@@ -516,7 +516,7 @@ struct RoundOperatorPrecision {
 				return input;
 			}
 		}
-		return UnsafeNumericCast<TR>(rounded_value);
+		return LossyNumericCast<TR>(rounded_value);
 	}
 };
 
@@ -527,7 +527,7 @@ struct RoundOperator {
 		if (std::isinf(rounded_value) || std::isnan(rounded_value)) {
 			return input;
 		}
-		return UnsafeNumericCast<TR>(rounded_value);
+		return LossyNumericCast<TR>(rounded_value);
 	}
 };
 
@@ -1128,6 +1128,102 @@ ScalarFunction AcosFun::GetFunction() {
 	                      ScalarFunction::UnaryFunction<double, double, NoInfiniteDoubleWrapper<ACos>>);
 }
 
+//===--------------------------------------------------------------------===//
+// cosh
+//===--------------------------------------------------------------------===//
+struct CoshOperator {
+	template <class TA, class TR>
+	static inline TR Operation(TA input) {
+		return (double)std::cosh(input);
+	}
+};
+
+ScalarFunction CoshFun::GetFunction() {
+	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
+	                      ScalarFunction::UnaryFunction<double, double, CoshOperator>);
+}
+
+//===--------------------------------------------------------------------===//
+// acosh
+//===--------------------------------------------------------------------===//
+struct AcoshOperator {
+	template <class TA, class TR>
+	static inline TR Operation(TA input) {
+		return (double)std::acosh(input);
+	}
+};
+
+ScalarFunction AcoshFun::GetFunction() {
+	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
+	                      ScalarFunction::UnaryFunction<double, double, AcoshOperator>);
+}
+
+//===--------------------------------------------------------------------===//
+// sinh
+//===--------------------------------------------------------------------===//
+struct SinhOperator {
+	template <class TA, class TR>
+	static inline TR Operation(TA input) {
+		return (double)std::sinh(input);
+	}
+};
+
+ScalarFunction SinhFun::GetFunction() {
+	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
+	                      ScalarFunction::UnaryFunction<double, double, SinhOperator>);
+}
+
+//===--------------------------------------------------------------------===//
+// asinh
+//===--------------------------------------------------------------------===//
+struct AsinhOperator {
+	template <class TA, class TR>
+	static inline TR Operation(TA input) {
+		return (double)std::asinh(input);
+	}
+};
+
+ScalarFunction AsinhFun::GetFunction() {
+	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
+	                      ScalarFunction::UnaryFunction<double, double, AsinhOperator>);
+}
+
+//===--------------------------------------------------------------------===//
+// tanh
+//===--------------------------------------------------------------------===//
+struct TanhOperator {
+	template <class TA, class TR>
+	static inline TR Operation(TA input) {
+		return (double)std::tanh(input);
+	}
+};
+
+ScalarFunction TanhFun::GetFunction() {
+	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
+	                      ScalarFunction::UnaryFunction<double, double, TanhOperator>);
+}
+
+//===--------------------------------------------------------------------===//
+// atanh
+//===--------------------------------------------------------------------===//
+struct AtanhOperator {
+	template <class TA, class TR>
+	static inline TR Operation(TA input) {
+		if (input < -1 || input > 1) {
+			throw InvalidInputException("ATANH is undefined outside [-1,1]");
+		}
+		if (input == -1 || input == 1) {
+			return INFINITY;
+		}
+		return (double)std::atanh(input);
+	}
+};
+
+ScalarFunction AtanhFun::GetFunction() {
+	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
+	                      ScalarFunction::UnaryFunction<double, double, AtanhOperator>);
+}
+
 //===--------------------------------------------------------------------===//
 // cot
 //===--------------------------------------------------------------------===//

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

@@ -206,11 +206,10 @@ ScalarFunctionSet BitwiseNotFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // << [bitwise_left_shift]
 //===--------------------------------------------------------------------===//
-
 struct BitwiseShiftLeftOperator {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA input, TB shift) {
-		TA max_shift = TA(sizeof(TA) * 8);
+		TA max_shift = TA(sizeof(TA) * 8) + (NumericLimits<TA>::IsSigned() ? 0 : 1);
 		if (input < 0) {
 			throw OutOfRangeException("Cannot left-shift negative number %s", NumericHelper::ToString(input));
 		}

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

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

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

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

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

@@ -42,7 +42,7 @@ static void WriteHugeIntHexBytes(T x, char *&output, idx_t buffer_size) {
 static void WriteBinBytes(uint64_t x, char *&output, idx_t buffer_size) {
 	idx_t offset = buffer_size;
 	for (; offset >= 1; offset -= 1) {
-		*output = ((x >> (offset - 1)) & 0x01) + '0';
+		*output = NumericCast<char>(((x >> (offset - 1)) & 0x01) + '0');
 		output++;
 	}
 }
@@ -392,6 +392,8 @@ ScalarFunctionSet HexFun::GetFunctions() {
 	ScalarFunctionSet to_hex;
 	to_hex.AddFunction(
 	    ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, ToHexFunction<string_t, HexStrOperator>));
+	to_hex.AddFunction(
+	    ScalarFunction({LogicalType::VARINT}, LogicalType::VARCHAR, ToHexFunction<string_t, HexStrOperator>));
 	to_hex.AddFunction(
 	    ScalarFunction({LogicalType::BLOB}, LogicalType::VARCHAR, ToHexFunction<string_t, HexStrOperator>));
 	to_hex.AddFunction(
@@ -414,6 +416,8 @@ ScalarFunctionSet BinFun::GetFunctions() {
 
 	to_binary.AddFunction(
 	    ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, ToBinaryFunction<string_t, BinaryStrOperator>));
+	to_binary.AddFunction(
+	    ScalarFunction({LogicalType::VARINT}, LogicalType::VARCHAR, ToBinaryFunction<string_t, BinaryStrOperator>));
 	to_binary.AddFunction(ScalarFunction({LogicalType::UBIGINT}, LogicalType::VARCHAR,
 	                                     ToBinaryFunction<uint64_t, BinaryIntegralOperator>));
 	to_binary.AddFunction(

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

@@ -30,19 +30,6 @@ struct MD5Number128Operator {
 	}
 };
 
-template <bool lower>
-struct MD5Number64Operator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input) {
-		data_t digest[MD5Context::MD5_HASH_LENGTH_BINARY];
-
-		MD5Context context;
-		context.Add(input);
-		context.Finish(digest);
-		return *reinterpret_cast<uint64_t *>(&digest[lower ? 8 : 0]);
-	}
-};
-
 static void MD5Function(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &input = args.data[0];
 
@@ -55,32 +42,18 @@ static void MD5NumberFunction(DataChunk &args, ExpressionState &state, Vector &r
 	UnaryExecutor::Execute<string_t, hugeint_t, MD5Number128Operator>(input, result, args.size());
 }
 
-static void MD5NumberUpperFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &input = args.data[0];
-
-	UnaryExecutor::Execute<string_t, uint64_t, MD5Number64Operator<false>>(input, result, args.size());
-}
-
-static void MD5NumberLowerFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &input = args.data[0];
-
-	UnaryExecutor::Execute<string_t, uint64_t, MD5Number64Operator<true>>(input, result, args.size());
-}
-
-ScalarFunction MD5Fun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, MD5Function);
-}
-
-ScalarFunction MD5NumberFun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR}, LogicalType::HUGEINT, MD5NumberFunction);
-}
-
-ScalarFunction MD5NumberUpperFun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR}, LogicalType::UBIGINT, MD5NumberUpperFunction);
+ScalarFunctionSet MD5Fun::GetFunctions() {
+	ScalarFunctionSet set("md5");
+	set.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, MD5Function));
+	set.AddFunction(ScalarFunction({LogicalType::BLOB}, LogicalType::VARCHAR, MD5Function));
+	return set;
 }
 
-ScalarFunction MD5NumberLowerFun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR}, LogicalType::UBIGINT, MD5NumberLowerFunction);
+ScalarFunctionSet MD5NumberFun::GetFunctions() {
+	ScalarFunctionSet set("md5_number");
+	set.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::HUGEINT, MD5NumberFunction));
+	set.AddFunction(ScalarFunction({LogicalType::BLOB}, LogicalType::HUGEINT, MD5NumberFunction));
+	return set;
 }
 
 } // namespace duckdb

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

@@ -27,15 +27,26 @@ unique_ptr<FunctionData> BindPrintfFunction(ClientContext &context, ScalarFuncti
 	for (idx_t i = 1; i < arguments.size(); i++) {
 		switch (arguments[i]->return_type.id()) {
 		case LogicalTypeId::BOOLEAN:
+			bound_function.arguments.emplace_back(LogicalType::BOOLEAN);
+			break;
 		case LogicalTypeId::TINYINT:
 		case LogicalTypeId::SMALLINT:
 		case LogicalTypeId::INTEGER:
 		case LogicalTypeId::BIGINT:
+			bound_function.arguments.emplace_back(LogicalType::BIGINT);
+			break;
+		case LogicalTypeId::UTINYINT:
+		case LogicalTypeId::USMALLINT:
+		case LogicalTypeId::UINTEGER:
+		case LogicalTypeId::UBIGINT:
+			bound_function.arguments.emplace_back(LogicalType::UBIGINT);
+			break;
 		case LogicalTypeId::FLOAT:
 		case LogicalTypeId::DOUBLE:
+			bound_function.arguments.emplace_back(LogicalType::DOUBLE);
+			break;
 		case LogicalTypeId::VARCHAR:
-			// these types are natively supported
-			bound_function.arguments.push_back(arguments[i]->return_type);
+			bound_function.arguments.push_back(LogicalType::VARCHAR);
 			break;
 		case LogicalTypeId::DECIMAL:
 			// decimal type: add cast to double
@@ -125,6 +136,11 @@ static void PrintfFunction(DataChunk &args, ExpressionState &state, Vector &resu
 				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(arg_data[arg_idx]));
 				break;
 			}
+			case LogicalTypeId::UBIGINT: {
+				auto arg_data = FlatVector::GetData<uint64_t>(col);
+				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(arg_data[arg_idx]));
+				break;
+			}
 			case LogicalTypeId::FLOAT: {
 				auto arg_data = FlatVector::GetData<float>(col);
 				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(arg_data[arg_idx]));

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

@@ -31,11 +31,56 @@ static void RepeatFunction(DataChunk &args, ExpressionState &, Vector &result) {
 	    });
 }
 
+unique_ptr<FunctionData> RepeatBindFunction(ClientContext &, ScalarFunction &bound_function,
+                                            vector<unique_ptr<Expression>> &arguments) {
+	switch (arguments[0]->return_type.id()) {
+	case LogicalTypeId::UNKNOWN:
+		throw ParameterNotResolvedException();
+	case LogicalTypeId::LIST:
+		break;
+	default:
+		throw NotImplementedException("repeat(list, count) requires a list as parameter");
+	}
+	bound_function.arguments[0] = arguments[0]->return_type;
+	bound_function.return_type = arguments[0]->return_type;
+	return nullptr;
+}
+
+static void RepeatListFunction(DataChunk &args, ExpressionState &, Vector &result) {
+	auto &list_vector = args.data[0];
+	auto &cnt_vector = args.data[1];
+
+	auto &source_child = ListVector::GetEntry(list_vector);
+	auto &result_child = ListVector::GetEntry(result);
+
+	idx_t current_size = ListVector::GetListSize(result);
+	BinaryExecutor::Execute<list_entry_t, int64_t, list_entry_t>(
+	    list_vector, cnt_vector, result, args.size(), [&](list_entry_t list_input, int64_t cnt) {
+		    idx_t copy_count = cnt <= 0 || list_input.length == 0 ? 0 : UnsafeNumericCast<idx_t>(cnt);
+		    idx_t result_length = list_input.length * copy_count;
+		    idx_t new_size = current_size + result_length;
+		    ListVector::Reserve(result, new_size);
+		    list_entry_t result_list;
+		    result_list.offset = current_size;
+		    result_list.length = result_length;
+		    for (idx_t i = 0; i < copy_count; i++) {
+			    // repeat the list contents "cnt" times
+			    VectorOperations::Copy(source_child, result_child, list_input.offset + list_input.length,
+			                           list_input.offset, current_size);
+			    current_size += list_input.length;
+		    }
+		    return result_list;
+	    });
+	ListVector::SetListSize(result, current_size);
+}
+
 ScalarFunctionSet RepeatFun::GetFunctions() {
 	ScalarFunctionSet repeat;
 	for (const auto &type : {LogicalType::VARCHAR, LogicalType::BLOB}) {
 		repeat.AddFunction(ScalarFunction({type, LogicalType::BIGINT}, type, RepeatFunction));
 	}
+	repeat.AddFunction(ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::BIGINT},
+	                                  LogicalType::LIST(LogicalType::ANY), RepeatListFunction, RepeatBindFunction));
 	return repeat;
 }
 

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

@@ -3,7 +3,7 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/vector_operations/unary_executor.hpp"
-#include "utf8proc.hpp"
+#include "utf8proc_wrapper.hpp"
 
 #include <string.h>
 
@@ -23,10 +23,9 @@ static bool StrReverseASCII(const char *input, idx_t n, char *output) {
 
 //! Unicode string reverse using grapheme breakers
 static void StrReverseUnicode(const char *input, idx_t n, char *output) {
-	utf8proc_grapheme_callback(input, n, [&](size_t start, size_t end) {
-		memcpy(output + n - end, input + start, end - start);
-		return true;
-	});
+	for (auto cluster : Utf8Proc::GraphemeClusters(input, n)) {
+		memcpy(output + n - cluster.end, input + cluster.start, cluster.end - cluster.start);
+	}
 }
 
 struct ReverseOperator {

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

@@ -0,0 +1,35 @@
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/vector_operations/unary_executor.hpp"
+#include "duckdb/core_functions/scalar/string_functions.hpp"
+#include "mbedtls_wrapper.hpp"
+
+namespace duckdb {
+
+struct SHA1Operator {
+	template <class INPUT_TYPE, class RESULT_TYPE>
+	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
+		auto hash = StringVector::EmptyString(result, duckdb_mbedtls::MbedTlsWrapper::SHA1_HASH_LENGTH_TEXT);
+
+		duckdb_mbedtls::MbedTlsWrapper::SHA1State state;
+		state.AddString(input.GetString());
+		state.FinishHex(hash.GetDataWriteable());
+
+		hash.Finalize();
+		return hash;
+	}
+};
+
+static void SHA1Function(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &input = args.data[0];
+
+	UnaryExecutor::ExecuteString<string_t, string_t, SHA1Operator>(input, result, args.size());
+}
+
+ScalarFunctionSet SHA1Fun::GetFunctions() {
+	ScalarFunctionSet set("sha1");
+	set.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, SHA1Function));
+	set.AddFunction(ScalarFunction({LogicalType::BLOB}, LogicalType::VARCHAR, SHA1Function));
+	return set;
+}
+
+} // namespace duckdb

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

@@ -25,8 +25,11 @@ static void SHA256Function(DataChunk &args, ExpressionState &state, Vector &resu
 	UnaryExecutor::ExecuteString<string_t, string_t, SHA256Operator>(input, result, args.size());
 }
 
-ScalarFunction SHA256Fun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, SHA256Function);
+ScalarFunctionSet SHA256Fun::GetFunctions() {
+	ScalarFunctionSet set("sha256");
+	set.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, SHA256Function));
+	set.AddFunction(ScalarFunction({LogicalType::BLOB}, LogicalType::VARCHAR, SHA256Function));
+	return set;
 }
 
 } // namespace duckdb