duckdb 1.1.3 → 1.1.4-dev9.0

package/src/duckdb/extension/core_functions/scalar/string/jaro_winkler.cpp

@@ -0,0 +1,112 @@
+#include "jaro_winkler.hpp"
+
+#include "core_functions/scalar/string_functions.hpp"
+
+namespace duckdb {
+
+static inline double JaroScalarFunction(const string_t &s1, const string_t &s2, const double_t &score_cutoff = 0.0) {
+	auto s1_begin = s1.GetData();
+	auto s2_begin = s2.GetData();
+	return duckdb_jaro_winkler::jaro_similarity(s1_begin, s1_begin + s1.GetSize(), s2_begin, s2_begin + s2.GetSize(),
+	                                            score_cutoff);
+}
+
+static inline double JaroWinklerScalarFunction(const string_t &s1, const string_t &s2,
+                                               const double_t &score_cutoff = 0.0) {
+	auto s1_begin = s1.GetData();
+	auto s2_begin = s2.GetData();
+	return duckdb_jaro_winkler::jaro_winkler_similarity(s1_begin, s1_begin + s1.GetSize(), s2_begin,
+	                                                    s2_begin + s2.GetSize(), 0.1, score_cutoff);
+}
+
+template <class CACHED_SIMILARITY>
+static void CachedFunction(Vector &constant, Vector &other, Vector &result, DataChunk &args) {
+	auto val = constant.GetValue(0);
+	idx_t count = args.size();
+	if (val.IsNull()) {
+		auto &result_validity = FlatVector::Validity(result);
+		result_validity.SetAllInvalid(count);
+		return;
+	}
+
+	auto str_val = StringValue::Get(val);
+	auto cached = CACHED_SIMILARITY(str_val);
+
+	D_ASSERT(args.ColumnCount() == 2 || args.ColumnCount() == 3);
+	if (args.ColumnCount() == 2) {
+		UnaryExecutor::Execute<string_t, double>(other, result, count, [&](const string_t &other_str) {
+			auto other_str_begin = other_str.GetData();
+			return cached.similarity(other_str_begin, other_str_begin + other_str.GetSize());
+		});
+	} else {
+		auto score_cutoff = args.data[2];
+		BinaryExecutor::Execute<string_t, double_t, double>(
+		    other, score_cutoff, result, count, [&](const string_t &other_str, const double_t score_cutoff) {
+			    auto other_str_begin = other_str.GetData();
+			    return cached.similarity(other_str_begin, other_str_begin + other_str.GetSize(), score_cutoff);
+		    });
+	}
+}
+
+template <class CACHED_SIMILARITY, class SIMILARITY_FUNCTION>
+static void TemplatedJaroWinklerFunction(DataChunk &args, Vector &result, SIMILARITY_FUNCTION fun) {
+	bool arg0_constant = args.data[0].GetVectorType() == VectorType::CONSTANT_VECTOR;
+	bool arg1_constant = args.data[1].GetVectorType() == VectorType::CONSTANT_VECTOR;
+	if (!(arg0_constant ^ arg1_constant)) {
+		// We can't optimize by caching one of the two strings
+		D_ASSERT(args.ColumnCount() == 2 || args.ColumnCount() == 3);
+		if (args.ColumnCount() == 2) {
+			BinaryExecutor::Execute<string_t, string_t, double>(
+			    args.data[0], args.data[1], result, args.size(),
+			    [&](const string_t &s1, const string_t &s2) { return fun(s1, s2, 0.0); });
+			return;
+		} else {
+			TernaryExecutor::Execute<string_t, string_t, double_t, double>(args.data[0], args.data[1], args.data[2],
+			                                                               result, args.size(), fun);
+			return;
+		}
+	}
+
+	if (arg0_constant) {
+		CachedFunction<CACHED_SIMILARITY>(args.data[0], args.data[1], result, args);
+	} else {
+		CachedFunction<CACHED_SIMILARITY>(args.data[1], args.data[0], result, args);
+	}
+}
+
+static void JaroFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	TemplatedJaroWinklerFunction<duckdb_jaro_winkler::CachedJaroSimilarity<char>>(args, result, JaroScalarFunction);
+}
+
+static void JaroWinklerFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	TemplatedJaroWinklerFunction<duckdb_jaro_winkler::CachedJaroWinklerSimilarity<char>>(args, result,
+	                                                                                     JaroWinklerScalarFunction);
+}
+
+ScalarFunctionSet JaroSimilarityFun::GetFunctions() {
+	ScalarFunctionSet jaro;
+
+	const auto list_type = LogicalType::LIST(LogicalType::VARCHAR);
+	auto fun = ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::DOUBLE, JaroFunction);
+	jaro.AddFunction(fun);
+
+	fun = ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::DOUBLE}, LogicalType::DOUBLE,
+	                     JaroFunction);
+	jaro.AddFunction(fun);
+	return jaro;
+}
+
+ScalarFunctionSet JaroWinklerSimilarityFun::GetFunctions() {
+	ScalarFunctionSet jaroWinkler;
+
+	const auto list_type = LogicalType::LIST(LogicalType::VARCHAR);
+	auto fun = ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::DOUBLE, JaroWinklerFunction);
+	jaroWinkler.AddFunction(fun);
+
+	fun = ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::DOUBLE}, LogicalType::DOUBLE,
+	                     JaroWinklerFunction);
+	jaroWinkler.AddFunction(fun);
+	return jaroWinkler;
+}
+
+} // namespace duckdb

package/src/duckdb/{src → extension}/core_functions/scalar/string/left_right.cpp

@@ -1,7 +1,7 @@
-#include "duckdb/core_functions/scalar/string_functions.hpp"
+#include "core_functions/scalar/string_functions.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/limits.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/function/scalar/string_common.hpp"
 
 #include <ctype.h>
 #include <algorithm>
@@ -11,22 +11,22 @@ namespace duckdb {
 struct LeftRightUnicode {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
-		return LengthFun::Length<TA, TR>(input);
+		return Length<TA, TR>(input);
 	}
 
 	static string_t Substring(Vector &result, string_t input, int64_t offset, int64_t length) {
-		return SubstringFun::SubstringUnicode(result, input, offset, length);
+		return SubstringUnicode(result, input, offset, length);
 	}
 };
 
 struct LeftRightGrapheme {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
-		return LengthFun::GraphemeCount<TA, TR>(input);
+		return GraphemeCount<TA, TR>(input);
 	}
 
 	static string_t Substring(Vector &result, string_t input, int64_t offset, int64_t length) {
-		return SubstringFun::SubstringGrapheme(result, input, offset, length);
+		return SubstringGrapheme(result, input, offset, length);
 	}
 };
 

package/src/duckdb/{src → extension}/core_functions/scalar/string/levenshtein.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/scalar/string_functions.hpp"
+#include "core_functions/scalar/string_functions.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/string_util.hpp"
 

package/src/duckdb/{src → extension}/core_functions/scalar/string/pad.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/scalar/string_functions.hpp"
+#include "core_functions/scalar/string_functions.hpp"
 
 #include "duckdb/common/algorithm.hpp"
 #include "duckdb/common/exception.hpp"
@@ -131,13 +131,17 @@ static void PadFunction(DataChunk &args, ExpressionState &state, Vector &result)
 }
 
 ScalarFunction LpadFun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR, LogicalType::INTEGER, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                      PadFunction<LeftPadOperator>);
+	ScalarFunction func({LogicalType::VARCHAR, LogicalType::INTEGER, LogicalType::VARCHAR}, LogicalType::VARCHAR,
+	                    PadFunction<LeftPadOperator>);
+	BaseScalarFunction::SetReturnsError(func);
+	return func;
 }
 
 ScalarFunction RpadFun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR, LogicalType::INTEGER, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                      PadFunction<RightPadOperator>);
+	ScalarFunction func({LogicalType::VARCHAR, LogicalType::INTEGER, LogicalType::VARCHAR}, LogicalType::VARCHAR,
+	                    PadFunction<RightPadOperator>);
+	BaseScalarFunction::SetReturnsError(func);
+	return func;
 }
 
 } // namespace duckdb

package/src/duckdb/{src → extension}/core_functions/scalar/string/parse_path.cpp

@@ -1,5 +1,5 @@
-#include "duckdb/core_functions/scalar/string_functions.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "core_functions/scalar/string_functions.hpp"
+#include "duckdb/function/scalar/string_common.hpp"
 #include "duckdb/common/local_file_system.hpp"
 #include <iostream>
 
@@ -56,11 +56,11 @@ static idx_t Find(const char *input_data, idx_t input_size, const string &sep_da
 	if (sep_data.empty()) {
 		return 0;
 	}
-	auto pos = ContainsFun::Find(const_uchar_ptr_cast(input_data), input_size, const_uchar_ptr_cast(&sep_data[0]), 1);
+	auto pos = FindStrInStr(const_uchar_ptr_cast(input_data), input_size, const_uchar_ptr_cast(&sep_data[0]), 1);
 	// both_slash option
 	if (sep_data.size() > 1) {
 		auto sec_pos =
-		    ContainsFun::Find(const_uchar_ptr_cast(input_data), input_size, const_uchar_ptr_cast(&sep_data[1]), 1);
+		    FindStrInStr(const_uchar_ptr_cast(input_data), input_size, const_uchar_ptr_cast(&sep_data[1]), 1);
 		// choose the leftmost valid position
 		if (sec_pos != DConstants::INVALID_INDEX && (sec_pos < pos || pos == DConstants::INVALID_INDEX)) {
 			return sec_pos;

package/src/duckdb/{src → extension}/core_functions/scalar/string/printf.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/scalar/string_functions.hpp"
+#include "core_functions/scalar/string_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/common/limits.hpp"
 #include "fmt/format.h"
@@ -173,6 +173,7 @@ ScalarFunction PrintfFun::GetFunction() {
 	ScalarFunction printf_fun({LogicalType::VARCHAR}, LogicalType::VARCHAR,
 	                          PrintfFunction<FMTPrintf, duckdb_fmt::printf_context>, BindPrintfFunction);
 	printf_fun.varargs = LogicalType::ANY;
+	BaseScalarFunction::SetReturnsError(printf_fun);
 	return printf_fun;
 }
 
@@ -181,6 +182,7 @@ ScalarFunction FormatFun::GetFunction() {
 	ScalarFunction format_fun({LogicalType::VARCHAR}, LogicalType::VARCHAR,
 	                          PrintfFunction<FMTFormat, duckdb_fmt::format_context>, BindPrintfFunction);
 	format_fun.varargs = LogicalType::ANY;
+	BaseScalarFunction::SetReturnsError(format_fun);
 	return format_fun;
 }
 

package/src/duckdb/{src → extension}/core_functions/scalar/string/repeat.cpp

@@ -1,5 +1,5 @@
 #include "duckdb/common/vector_operations/binary_executor.hpp"
-#include "duckdb/core_functions/scalar/string_functions.hpp"
+#include "core_functions/scalar/string_functions.hpp"
 #include "duckdb/common/operator/multiply.hpp"
 
 namespace duckdb {
@@ -81,6 +81,9 @@ ScalarFunctionSet RepeatFun::GetFunctions() {
 	}
 	repeat.AddFunction(ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::BIGINT},
 	                                  LogicalType::LIST(LogicalType::ANY), RepeatListFunction, RepeatBindFunction));
+	for (auto &func : repeat.functions) {
+		BaseScalarFunction::SetReturnsError(func);
+	}
 	return repeat;
 }
 

package/src/duckdb/{src → extension}/core_functions/scalar/string/replace.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/scalar/string_functions.hpp"
+#include "core_functions/scalar/string_functions.hpp"
 
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"

package/src/duckdb/{src → extension}/core_functions/scalar/string/reverse.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/scalar/string_functions.hpp"
+#include "core_functions/scalar/string_functions.hpp"
 
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"

package/src/duckdb/{src → extension}/core_functions/scalar/string/starts_with.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/scalar/string_functions.hpp"
+#include "core_functions/scalar/string_functions.hpp"
 
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
@@ -37,8 +37,10 @@ struct StartsWithOperator {
 };
 
 ScalarFunction StartsWithOperatorFun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                      ScalarFunction::BinaryFunction<string_t, string_t, bool, StartsWithOperator>);
+	ScalarFunction starts_with({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
+	                           ScalarFunction::BinaryFunction<string_t, string_t, bool, StartsWithOperator>);
+	starts_with.collation_handling = FunctionCollationHandling::PUSH_COMBINABLE_COLLATIONS;
+	return starts_with;
 }
 
 } // namespace duckdb

package/src/duckdb/{src → extension}/core_functions/scalar/string/to_base.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/scalar/string_functions.hpp"
+#include "core_functions/scalar/string_functions.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 

package/src/duckdb/{src → extension}/core_functions/scalar/string/translate.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/scalar/string_functions.hpp"
+#include "core_functions/scalar/string_functions.hpp"
 
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"

package/src/duckdb/{src → extension}/core_functions/scalar/string/trim.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/scalar/string_functions.hpp"
+#include "core_functions/scalar/string_functions.hpp"
 
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"

package/src/duckdb/{src → extension}/core_functions/scalar/string/unicode.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/scalar/string_functions.hpp"
+#include "core_functions/scalar/string_functions.hpp"
 
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"

package/src/duckdb/{src → extension}/core_functions/scalar/string/url_encode.cpp

@@ -1,5 +1,5 @@
 #include "duckdb/common/vector_operations/unary_executor.hpp"
-#include "duckdb/core_functions/scalar/string_functions.hpp"
+#include "core_functions/scalar/string_functions.hpp"
 #include "duckdb/common/string_util.hpp"
 
 namespace duckdb {

package/src/duckdb/{src → extension}/core_functions/scalar/struct/struct_insert.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/scalar/struct_functions.hpp"
+#include "core_functions/scalar/struct_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/parser/expression/bound_expression.hpp"
@@ -11,25 +11,23 @@ namespace duckdb {
 
 static void StructInsertFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &starting_vec = args.data[0];
-
 	starting_vec.Verify(args.size());
 
 	auto &starting_child_entries = StructVector::GetEntries(starting_vec);
 	auto &result_child_entries = StructVector::GetEntries(result);
 
-	// Assign the starting vector entries to the result vector
-	for (size_t i = 0; i < starting_child_entries.size(); i++) {
+	// Assign the original child entries to the STRUCT.
+	for (idx_t i = 0; i < starting_child_entries.size(); i++) {
 		auto &starting_child = starting_child_entries[i];
 		result_child_entries[i]->Reference(*starting_child);
 	}
 
-	// Assign the new entries to the result vector
-	for (size_t i = 1; i < args.ColumnCount(); i++) {
+	// Assign the new children to the result vector.
+	for (idx_t i = 1; i < args.ColumnCount(); i++) {
 		result_child_entries[starting_child_entries.size() + i - 1]->Reference(args.data[i]);
 	}
 
 	result.Verify(args.size());
-
 	if (args.AllConstant()) {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
 	}
@@ -37,69 +35,65 @@ static void StructInsertFunction(DataChunk &args, ExpressionState &state, Vector
 
 static unique_ptr<FunctionData> StructInsertBind(ClientContext &context, ScalarFunction &bound_function,
                                                  vector<unique_ptr<Expression>> &arguments) {
-	case_insensitive_set_t name_collision_set;
-
 	if (arguments.empty()) {
 		throw InvalidInputException("Missing required arguments for struct_insert function.");
 	}
-
 	if (LogicalTypeId::STRUCT != arguments[0]->return_type.id()) {
 		throw InvalidInputException("The first argument to struct_insert must be a STRUCT");
 	}
-
 	if (arguments.size() < 2) {
-		throw InvalidInputException("Can't insert nothing into a struct");
+		throw InvalidInputException("Can't insert nothing into a STRUCT");
 	}
 
-	child_list_t<LogicalType> new_struct_children;
-
-	auto &existing_struct_children = StructType::GetChildTypes(arguments[0]->return_type);
+	case_insensitive_set_t name_collision_set;
+	child_list_t<LogicalType> new_children;
+	auto &existing_children = StructType::GetChildTypes(arguments[0]->return_type);
 
-	for (size_t i = 0; i < existing_struct_children.size(); i++) {
-		auto &child = existing_struct_children[i];
+	for (idx_t i = 0; i < existing_children.size(); i++) {
+		auto &child = existing_children[i];
 		name_collision_set.insert(child.first);
-		new_struct_children.push_back(make_pair(child.first, child.second));
+		new_children.push_back(make_pair(child.first, child.second));
 	}
 
 	// Loop through the additional arguments (name/value pairs)
 	for (idx_t i = 1; i < arguments.size(); i++) {
 		auto &child = arguments[i];
-		if (child->alias.empty() && bound_function.name == "struct_insert") {
-			throw BinderException("Need named argument for struct insert, e.g. STRUCT_PACK(a := b)");
+		if (child->GetAlias().empty()) {
+			throw BinderException("Need named argument for struct insert, e.g., a := b");
 		}
-		if (name_collision_set.find(child->alias) != name_collision_set.end()) {
-			throw BinderException("Duplicate struct entry name \"%s\"", child->alias);
+		if (name_collision_set.find(child->GetAlias()) != name_collision_set.end()) {
+			throw BinderException("Duplicate struct entry name \"%s\"", child->GetAlias());
 		}
-		name_collision_set.insert(child->alias);
-		new_struct_children.push_back(make_pair(child->alias, arguments[i]->return_type));
+		name_collision_set.insert(child->GetAlias());
+		new_children.push_back(make_pair(child->GetAlias(), arguments[i]->return_type));
 	}
 
-	// this is more for completeness reasons
-	bound_function.return_type = LogicalType::STRUCT(new_struct_children);
+	bound_function.return_type = LogicalType::STRUCT(new_children);
 	return make_uniq<VariableReturnBindData>(bound_function.return_type);
 }
 
 unique_ptr<BaseStatistics> StructInsertStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto &expr = input.expr;
-	auto new_struct_stats = StructStats::CreateUnknown(expr.return_type);
+	auto new_stats = StructStats::CreateUnknown(expr.return_type);
 
 	auto existing_count = StructType::GetChildCount(child_stats[0].GetType());
 	auto existing_stats = StructStats::GetChildStats(child_stats[0]);
 	for (idx_t i = 0; i < existing_count; i++) {
-		StructStats::SetChildStats(new_struct_stats, i, existing_stats[i]);
+		StructStats::SetChildStats(new_stats, i, existing_stats[i]);
 	}
+
 	auto new_count = StructType::GetChildCount(expr.return_type);
 	auto offset = new_count - child_stats.size();
 	for (idx_t i = 1; i < child_stats.size(); i++) {
-		StructStats::SetChildStats(new_struct_stats, offset + i, child_stats[i]);
+		StructStats::SetChildStats(new_stats, offset + i, child_stats[i]);
 	}
-	return new_struct_stats.ToUnique();
+	return new_stats.ToUnique();
 }
 
 ScalarFunction StructInsertFun::GetFunction() {
-	// the arguments and return types are actually set in the binder function
 	ScalarFunction fun({}, LogicalTypeId::STRUCT, StructInsertFunction, StructInsertBind, nullptr, StructInsertStats);
+	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	fun.varargs = LogicalType::ANY;
 	fun.serialize = VariableReturnBindData::Serialize;
 	fun.deserialize = VariableReturnBindData::Deserialize;

package/src/duckdb/{src → extension}/core_functions/scalar/union/union_extract.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/scalar/union_functions.hpp"
+#include "core_functions/scalar/union_functions.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"

package/src/duckdb/{src → extension}/core_functions/scalar/union/union_tag.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/scalar/union_functions.hpp"
+#include "core_functions/scalar/union_functions.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"

package/src/duckdb/{src → extension}/core_functions/scalar/union/union_value.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/scalar/union_functions.hpp"
+#include "core_functions/scalar/union_functions.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
@@ -44,13 +44,13 @@ static unique_ptr<FunctionData> UnionValueBind(ClientContext &context, ScalarFun
 	}
 	auto &child = arguments[0];
 
-	if (child->alias.empty()) {
+	if (child->GetAlias().empty()) {
 		throw BinderException("Need named argument for union tag, e.g. UNION_VALUE(a := b)");
 	}
 
 	child_list_t<LogicalType> union_members;
 
-	union_members.push_back(make_pair(child->alias, child->return_type));
+	union_members.push_back(make_pair(child->GetAlias(), child->return_type));
 
 	bound_function.return_type = LogicalType::UNION(std::move(union_members));
 	return make_uniq<VariableReturnBindData>(bound_function.return_type);

package/src/duckdb/extension/icu/icu-dateadd.cpp

@@ -37,7 +37,7 @@ static inline void CalendarAddHour(icu::Calendar *calendar, int64_t interval_hou
 		while (interval_hour > 0) {
 			calendar->add(UCAL_HOUR,
 			              interval_hour > NumericLimits<int32_t>::Maximum() ? NumericLimits<int32_t>::Maximum()
-			                                                                : interval_hour,
+			                                                                : static_cast<int32_t>(interval_hour),
 			              status);
 			interval_hour -= NumericLimits<int32_t>::Maximum();
 		}
@@ -45,7 +45,7 @@ static inline void CalendarAddHour(icu::Calendar *calendar, int64_t interval_hou
 		while (interval_hour < 0) {
 			calendar->add(UCAL_HOUR,
 			              interval_hour < NumericLimits<int32_t>::Minimum() ? NumericLimits<int32_t>::Minimum()
-			                                                                : interval_hour,
+			                                                                : static_cast<int32_t>(interval_hour),
 			              status);
 			interval_hour -= NumericLimits<int32_t>::Minimum();
 		}
@@ -85,13 +85,13 @@ timestamp_t ICUCalendarAdd::Operation(timestamp_t timestamp, interval_t interval
 	// Break units apart to avoid overflow
 	auto interval_h = interval.micros / Interval::MICROS_PER_MSEC;
 
-	const auto interval_ms = interval_h % Interval::MSECS_PER_SEC;
+	const auto interval_ms = static_cast<int32_t>(interval_h % Interval::MSECS_PER_SEC);
 	interval_h /= Interval::MSECS_PER_SEC;
 
-	const auto interval_s = interval_h % Interval::SECS_PER_MINUTE;
+	const auto interval_s = static_cast<int32_t>(interval_h % Interval::SECS_PER_MINUTE);
 	interval_h /= Interval::SECS_PER_MINUTE;
 
-	const auto interval_m = interval_h % Interval::MINS_PER_HOUR;
+	const auto interval_m = static_cast<int32_t>(interval_h % Interval::MINS_PER_HOUR);
 	interval_h /= Interval::MINS_PER_HOUR;
 
 	if (interval.months < 0 || interval.days < 0 || interval.micros < 0) {
@@ -132,6 +132,9 @@ timestamp_t ICUCalendarSub::Operation(timestamp_t timestamp, interval_t interval
 
 template <>
 interval_t ICUCalendarSub::Operation(timestamp_t end_date, timestamp_t start_date, icu::Calendar *calendar) {
+	if (!Timestamp::IsFinite(end_date) || !Timestamp::IsFinite(start_date)) {
+		throw InvalidInputException("Cannot subtract infinite timestamps");
+	}
 	if (start_date > end_date) {
 		auto negated = Operation<timestamp_t, timestamp_t, interval_t>(start_date, end_date, calendar);
 		return {-negated.months, -negated.days, -negated.micros};
@@ -156,7 +159,7 @@ interval_t ICUCalendarSub::Operation(timestamp_t end_date, timestamp_t start_dat
 	auto min_diff = SubtractField(calendar, UCAL_MINUTE, end_date);
 	auto sec_diff = SubtractField(calendar, UCAL_SECOND, end_date);
 	auto ms_diff = SubtractField(calendar, UCAL_MILLISECOND, end_date);
-	auto micros_diff = ms_diff * Interval::MICROS_PER_MSEC + (end_micros - start_micros);
+	auto micros_diff = UnsafeNumericCast<int32_t>(ms_diff * Interval::MICROS_PER_MSEC + (end_micros - start_micros));
 	result.micros = Time::FromTime(hour_diff, min_diff, sec_diff, micros_diff).micros;
 
 	return result;
@@ -188,7 +191,7 @@ interval_t ICUCalendarAge::Operation(timestamp_t end_date, timestamp_t start_dat
 	auto min_diff = SubtractField(calendar, UCAL_MINUTE, end_date);
 	auto sec_diff = SubtractField(calendar, UCAL_SECOND, end_date);
 	auto ms_diff = SubtractField(calendar, UCAL_MILLISECOND, end_date);
-	auto micros_diff = ms_diff * Interval::MICROS_PER_MSEC + (end_micros - start_micros);
+	auto micros_diff = UnsafeNumericCast<int32_t>(ms_diff * Interval::MICROS_PER_MSEC + (end_micros - start_micros));
 	result.micros = Time::FromTime(hour_diff, min_diff, sec_diff, micros_diff).micros;
 
 	return result;
@@ -204,7 +207,9 @@ struct ICUDateAdd : public ICUDateFunc {
 		auto &info = func_expr.bind_info->Cast<BindData>();
 		CalendarPtr calendar(info.calendar->clone());
 
-		auto end_date = Timestamp::GetCurrentTimestamp();
+		//	Subtract argument from current_date (at midnight)
+		const auto end_date = CurrentMidnight(calendar.get(), state);
+
 		UnaryExecutor::Execute<TA, TR>(args.data[0], result, args.size(), [&](TA start_date) {
 			return OP::template Operation<timestamp_t, TA, TR>(end_date, start_date, calendar.get());
 		});
@@ -247,7 +252,7 @@ struct ICUDateAdd : public ICUDateFunc {
 		                                                                            LogicalType::INTERVAL));
 		set.AddFunction(GetDateAddFunction<interval_t, timestamp_t, ICUCalendarAdd>(LogicalType::INTERVAL,
 		                                                                            LogicalType::TIMESTAMP_TZ));
-		ExtensionUtil::AddFunctionOverload(db, set);
+		ExtensionUtil::RegisterFunction(db, set);
 	}
 
 	template <typename TA, typename OP>
@@ -269,7 +274,7 @@ struct ICUDateAdd : public ICUDateFunc {
 		//	temporal - temporal
 		set.AddFunction(GetBinaryAgeFunction<timestamp_t, timestamp_t, ICUCalendarSub>(LogicalType::TIMESTAMP_TZ,
 		                                                                               LogicalType::TIMESTAMP_TZ));
-		ExtensionUtil::AddFunctionOverload(db, set);
+		ExtensionUtil::RegisterFunction(db, set);
 	}
 
 	static void AddDateAgeFunctions(const string &name, DatabaseInstance &db) {
@@ -278,7 +283,7 @@ struct ICUDateAdd : public ICUDateFunc {
 		set.AddFunction(GetBinaryAgeFunction<timestamp_t, timestamp_t, ICUCalendarAge>(LogicalType::TIMESTAMP_TZ,
 		                                                                               LogicalType::TIMESTAMP_TZ));
 		set.AddFunction(GetUnaryAgeFunction<timestamp_t, ICUCalendarAge>(LogicalType::TIMESTAMP_TZ));
-		ExtensionUtil::AddFunctionOverload(db, set);
+		ExtensionUtil::RegisterFunction(db, set);
 	}
 };
 

package/src/duckdb/extension/icu/icu-datefunc.cpp

@@ -117,7 +117,7 @@ bool ICUDateFunc::TryGetTime(icu::Calendar *calendar, uint64_t micros, timestamp
 timestamp_t ICUDateFunc::GetTime(icu::Calendar *calendar, uint64_t micros) {
 	timestamp_t result;
 	if (!TryGetTime(calendar, micros, result)) {
-		throw ConversionException("Unable to convert ICU date to timestamp");
+		throw ConversionException("ICU date overflows timestamp range");
 	}
 	return result;
 }
@@ -148,7 +148,7 @@ int32_t ICUDateFunc::ExtractField(icu::Calendar *calendar, UCalendarDateFields f
 	return result;
 }
 
-int64_t ICUDateFunc::SubtractField(icu::Calendar *calendar, UCalendarDateFields field, timestamp_t end_date) {
+int32_t ICUDateFunc::SubtractField(icu::Calendar *calendar, UCalendarDateFields field, timestamp_t end_date) {
 	const int64_t millis = end_date.value / Interval::MICROS_PER_MSEC;
 	const auto when = UDate(millis);
 	UErrorCode status = U_ZERO_ERROR;

package/src/duckdb/extension/icu/icu-datepart.cpp

@@ -587,7 +587,7 @@ struct ICUDatePart : public ICUDateFunc {
 	                                      const LogicalType &result_type = LogicalType::BIGINT) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(GetUnaryPartCodeFunction<timestamp_t, RESULT_TYPE>(LogicalType::TIMESTAMP_TZ, result_type));
-		ExtensionUtil::AddFunctionOverload(db, set);
+		ExtensionUtil::RegisterFunction(db, set);
 	}
 
 	template <typename INPUT_TYPE, typename RESULT_TYPE>
@@ -610,7 +610,10 @@ struct ICUDatePart : public ICUDateFunc {
 		ScalarFunctionSet set(name);
 		set.AddFunction(GetBinaryPartCodeFunction<timestamp_t, int64_t>(LogicalType::TIMESTAMP_TZ));
 		set.AddFunction(GetStructFunction<timestamp_t>(LogicalType::TIMESTAMP_TZ));
-		ExtensionUtil::AddFunctionOverload(db, set);
+		for (auto &func : set.functions) {
+			BaseScalarFunction::SetReturnsError(func);
+		}
+		ExtensionUtil::RegisterFunction(db, set);
 	}
 
 	static duckdb::unique_ptr<FunctionData> BindLastDate(ClientContext &context, ScalarFunction &bound_function,
@@ -627,7 +630,7 @@ struct ICUDatePart : public ICUDateFunc {
 	static void AddLastDayFunctions(const string &name, DatabaseInstance &db) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(GetLastDayFunction<timestamp_t>(LogicalType::TIMESTAMP_TZ));
-		ExtensionUtil::AddFunctionOverload(db, set);
+		ExtensionUtil::RegisterFunction(db, set);
 	}
 
 	static unique_ptr<FunctionData> BindMonthName(ClientContext &context, ScalarFunction &bound_function,
@@ -644,7 +647,7 @@ struct ICUDatePart : public ICUDateFunc {
 	static void AddMonthNameFunctions(const string &name, DatabaseInstance &db) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(GetMonthNameFunction<timestamp_t>(LogicalType::TIMESTAMP_TZ));
-		ExtensionUtil::AddFunctionOverload(db, set);
+		ExtensionUtil::RegisterFunction(db, set);
 	}
 
 	static unique_ptr<FunctionData> BindDayName(ClientContext &context, ScalarFunction &bound_function,
@@ -661,7 +664,7 @@ struct ICUDatePart : public ICUDateFunc {
 	static void AddDayNameFunctions(const string &name, DatabaseInstance &db) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(GetDayNameFunction<timestamp_t>(LogicalType::TIMESTAMP_TZ));
-		ExtensionUtil::AddFunctionOverload(db, set);
+		ExtensionUtil::RegisterFunction(db, set);
 	}
 };