duckdb 1.1.2-dev6.0 → 1.1.4-dev11.0

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

@@ -1,5 +1,7 @@
 #include "duckdb/common/exception.hpp"
+#include "duckdb/common/string_util.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
+#include "duckdb/function/scalar/string_common.hpp"
 #include "duckdb/function/scalar/string_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 
@@ -10,7 +12,7 @@ namespace duckdb {
 struct StandardCharacterReader {
 	static void NextCharacter(const char *sdata, idx_t slen, idx_t &sidx) {
 		sidx++;
-		while (sidx < slen && !LengthFun::IsCharacter(sdata[sidx])) {
+		while (sidx < slen && !IsCharacter(sdata[sidx])) {
 			sidx++;
 		}
 	}
@@ -26,7 +28,7 @@ struct ASCIILCaseReader {
 	}
 
 	static char Operation(const char *data, idx_t pos) {
-		return (char)LowerFun::ASCII_TO_LOWER_MAP[(uint8_t)data[pos]];
+		return (char)StringUtil::ASCII_TO_LOWER_MAP[(uint8_t)data[pos]];
 	}
 };
 
@@ -116,8 +118,8 @@ struct LikeMatcher : public FunctionData {
 		for (; segment_idx < end_idx; segment_idx++) {
 			auto &segment = segments[segment_idx];
 			// find the pattern of the current segment
-			idx_t next_offset = ContainsFun::Find(str_data, str_len, const_uchar_ptr_cast(segment.pattern.c_str()),
-			                                      segment.pattern.size());
+			idx_t next_offset =
+			    FindStrInStr(str_data, str_len, const_uchar_ptr_cast(segment.pattern.c_str()), segment.pattern.size());
 			if (next_offset == DConstants::INVALID_INDEX) {
 				// could not find this pattern in the string: no match
 				return false;
@@ -141,8 +143,8 @@ struct LikeMatcher : public FunctionData {
 		} else {
 			auto &segment = segments.back();
 			// find the pattern of the current segment
-			idx_t next_offset = ContainsFun::Find(str_data, str_len, const_uchar_ptr_cast(segment.pattern.c_str()),
-			                                      segment.pattern.size());
+			idx_t next_offset =
+			    FindStrInStr(str_data, str_len, const_uchar_ptr_cast(segment.pattern.c_str()), segment.pattern.size());
 			return next_offset != DConstants::INVALID_INDEX;
 		}
 	}
@@ -205,6 +207,11 @@ static unique_ptr<FunctionData> LikeBindFunction(ClientContext &context, ScalarF
                                                  vector<unique_ptr<Expression>> &arguments) {
 	// pattern is the second argument. If its constant, we can already prepare the pattern and store it for later.
 	D_ASSERT(arguments.size() == 2 || arguments.size() == 3);
+	for (auto &arg : arguments) {
+		if (arg->return_type.id() == LogicalTypeId::VARCHAR && !StringType::GetCollation(arg->return_type).empty()) {
+			return nullptr;
+		}
+	}
 	if (arguments[1]->IsFoldable()) {
 		Value pattern_str = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
 		return LikeMatcher::CreateLikeMatcher(pattern_str.ToString());
@@ -228,7 +235,7 @@ bool LikeOperatorFunction(string_t &s, string_t &pat, char escape) {
 	return LikeOperatorFunction(s.GetData(), s.GetSize(), pat.GetData(), pat.GetSize(), escape);
 }
 
-bool LikeFun::Glob(const char *string, idx_t slen, const char *pattern, idx_t plen, bool allow_question_mark) {
+bool Glob(const char *string, idx_t slen, const char *pattern, idx_t plen, bool allow_question_mark) {
 	idx_t sidx = 0;
 	idx_t pidx = 0;
 main_loop : {
@@ -250,7 +257,7 @@ main_loop : {
 			}
 			// recursively match the remainder of the pattern
 			for (; sidx < slen; sidx++) {
-				if (LikeFun::Glob(string + sidx, slen - sidx, pattern + pidx, plen - pidx)) {
+				if (Glob(string + sidx, slen - sidx, pattern + pidx, plen - pidx)) {
 					return true;
 				}
 			}
@@ -402,13 +409,13 @@ bool ILikeOperatorFunction(string_t &str, string_t &pattern, char escape = '\0')
 	auto pat_size = pattern.GetSize();
 
 	// lowercase both the str and the pattern
-	idx_t str_llength = LowerFun::LowerLength(str_data, str_size);
+	idx_t str_llength = LowerLength(str_data, str_size);
 	auto str_ldata = make_unsafe_uniq_array_uninitialized<char>(str_llength);
-	LowerFun::LowerCase(str_data, str_size, str_ldata.get());
+	LowerCase(str_data, str_size, str_ldata.get());
 
-	idx_t pat_llength = LowerFun::LowerLength(pat_data, pat_size);
+	idx_t pat_llength = LowerLength(pat_data, pat_size);
 	auto pat_ldata = make_unsafe_uniq_array_uninitialized<char>(pat_llength);
-	LowerFun::LowerCase(pat_data, pat_size, pat_ldata.get());
+	LowerCase(pat_data, pat_size, pat_ldata.get());
 	string_t str_lcase(str_ldata.get(), UnsafeNumericCast<uint32_t>(str_llength));
 	string_t pat_lcase(pat_ldata.get(), UnsafeNumericCast<uint32_t>(pat_llength));
 	return LikeOperatorFunction(str_lcase, pat_lcase, escape);
@@ -468,7 +475,7 @@ struct NotILikeOperatorASCII {
 struct GlobOperator {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA str, TB pattern) {
-		return LikeFun::Glob(str.GetData(), str.GetSize(), pattern.GetData(), pattern.GetSize());
+		return Glob(str.GetData(), str.GetSize(), pattern.GetData(), pattern.GetSize());
 	}
 };
 
@@ -510,45 +517,71 @@ static void RegularLikeFunction(DataChunk &input, ExpressionState &state, Vector
 		                                                              input.size());
 	}
 }
-void LikeFun::RegisterFunction(BuiltinFunctions &set) {
-	// like
-	set.AddFunction(GetLikeFunction());
-	// not like
-	set.AddFunction(ScalarFunction("!~~", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                               RegularLikeFunction<NotLikeOperator, true>, LikeBindFunction));
-	// glob
-	set.AddFunction(ScalarFunction("~~~", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                               ScalarFunction::BinaryFunction<string_t, string_t, bool, GlobOperator>));
-	// ilike
-	set.AddFunction(ScalarFunction("~~*", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                               ScalarFunction::BinaryFunction<string_t, string_t, bool, ILikeOperator>, nullptr,
-	                               nullptr, ILikePropagateStats<ILikeOperatorASCII>));
-	// not ilike
-	set.AddFunction(ScalarFunction("!~~*", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                               ScalarFunction::BinaryFunction<string_t, string_t, bool, NotILikeOperator>, nullptr,
-	                               nullptr, ILikePropagateStats<NotILikeOperatorASCII>));
+
+ScalarFunction NotLikeFun::GetFunction() {
+	ScalarFunction not_like("!~~", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
+	                        RegularLikeFunction<NotLikeOperator, true>, LikeBindFunction);
+	not_like.collation_handling = FunctionCollationHandling::PUSH_COMBINABLE_COLLATIONS;
+	return not_like;
+}
+
+ScalarFunction GlobPatternFun::GetFunction() {
+	ScalarFunction glob("~~~", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
+	                    ScalarFunction::BinaryFunction<string_t, string_t, bool, GlobOperator>);
+	glob.collation_handling = FunctionCollationHandling::PUSH_COMBINABLE_COLLATIONS;
+	return glob;
+}
+
+ScalarFunction ILikeFun::GetFunction() {
+	ScalarFunction ilike("~~*", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
+	                     ScalarFunction::BinaryFunction<string_t, string_t, bool, ILikeOperator>, nullptr, nullptr,
+	                     ILikePropagateStats<ILikeOperatorASCII>);
+	ilike.collation_handling = FunctionCollationHandling::PUSH_COMBINABLE_COLLATIONS;
+	return ilike;
+}
+
+ScalarFunction NotILikeFun::GetFunction() {
+	ScalarFunction not_ilike("!~~*", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
+	                         ScalarFunction::BinaryFunction<string_t, string_t, bool, NotILikeOperator>, nullptr,
+	                         nullptr, ILikePropagateStats<NotILikeOperatorASCII>);
+	not_ilike.collation_handling = FunctionCollationHandling::PUSH_COMBINABLE_COLLATIONS;
+	return not_ilike;
 }
 
-ScalarFunction LikeFun::GetLikeFunction() {
-	return ScalarFunction("~~", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                      RegularLikeFunction<LikeOperator, false>, LikeBindFunction);
+ScalarFunction LikeFun::GetFunction() {
+	ScalarFunction like("~~", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
+	                    RegularLikeFunction<LikeOperator, false>, LikeBindFunction);
+	like.collation_handling = FunctionCollationHandling::PUSH_COMBINABLE_COLLATIONS;
+	return like;
 }
 
-void LikeEscapeFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(GetLikeEscapeFun());
-	set.AddFunction({"not_like_escape"},
-	                ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                               LogicalType::BOOLEAN, LikeEscapeFunction<NotLikeEscapeOperator>));
-
-	set.AddFunction({"ilike_escape"}, ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                                                 LogicalType::BOOLEAN, LikeEscapeFunction<ILikeEscapeOperator>));
-	set.AddFunction({"not_ilike_escape"},
-	                ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                               LogicalType::BOOLEAN, LikeEscapeFunction<NotILikeEscapeOperator>));
+ScalarFunction NotLikeEscapeFun::GetFunction() {
+	ScalarFunction not_like_escape("not_like_escape",
+	                               {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
+	                               LogicalType::BOOLEAN, LikeEscapeFunction<NotLikeEscapeOperator>);
+	not_like_escape.collation_handling = FunctionCollationHandling::PUSH_COMBINABLE_COLLATIONS;
+	return not_like_escape;
 }
 
-ScalarFunction LikeEscapeFun::GetLikeEscapeFun() {
-	return ScalarFunction("like_escape", {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                      LogicalType::BOOLEAN, LikeEscapeFunction<LikeEscapeOperator>);
+ScalarFunction IlikeEscapeFun::GetFunction() {
+	ScalarFunction ilike_escape("ilike_escape", {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
+	                            LogicalType::BOOLEAN, LikeEscapeFunction<ILikeEscapeOperator>);
+	ilike_escape.collation_handling = FunctionCollationHandling::PUSH_COMBINABLE_COLLATIONS;
+	return ilike_escape;
 }
+
+ScalarFunction NotIlikeEscapeFun::GetFunction() {
+	ScalarFunction not_ilike_escape("not_ilike_escape",
+	                                {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
+	                                LogicalType::BOOLEAN, LikeEscapeFunction<NotILikeEscapeOperator>);
+	not_ilike_escape.collation_handling = FunctionCollationHandling::PUSH_COMBINABLE_COLLATIONS;
+	return not_ilike_escape;
+}
+ScalarFunction LikeEscapeFun::GetFunction() {
+	ScalarFunction like_escape("like_escape", {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
+	                           LogicalType::BOOLEAN, LikeEscapeFunction<LikeEscapeOperator>);
+	like_escape.collation_handling = FunctionCollationHandling::PUSH_COMBINABLE_COLLATIONS;
+	return like_escape;
+}
+
 } // namespace duckdb

package/src/duckdb/src/{core_functions → function}/scalar/string/md5.cpp

@@ -1,7 +1,7 @@
-#include "duckdb/core_functions/scalar/string_functions.hpp"
+#include "duckdb/common/crypto/md5.hpp"
 
+#include "duckdb/function/scalar/string_functions.hpp"
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/crypto/md5.hpp"
 #include "duckdb/common/vector_operations/unary_executor.hpp"
 
 namespace duckdb {

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

@@ -1,5 +1,5 @@
+#include "duckdb/function/scalar/string_common.hpp"
 #include "duckdb/function/scalar/string_functions.hpp"
-
 #include "utf8proc_wrapper.hpp"
 
 namespace duckdb {
@@ -9,7 +9,7 @@ struct NFCNormalizeOperator {
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
 		auto input_data = input.GetData();
 		auto input_length = input.GetSize();
-		if (StripAccentsFun::IsAscii(input_data, input_length)) {
+		if (IsAscii(input_data, input_length)) {
 			return input;
 		}
 		auto normalized_str = Utf8Proc::Normalize(input_data, input_length);
@@ -31,8 +31,4 @@ ScalarFunction NFCNormalizeFun::GetFunction() {
 	return ScalarFunction("nfc_normalize", {LogicalType::VARCHAR}, LogicalType::VARCHAR, NFCNormalizeFunction);
 }
 
-void NFCNormalizeFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(NFCNormalizeFun::GetFunction());
-}
-
 } // namespace duckdb

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

@@ -65,8 +65,4 @@ ScalarFunction PrefixFun::GetFunction() {
 	                      ScalarFunction::BinaryFunction<string_t, string_t, bool, PrefixOperator>);
 }
 
-void PrefixFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(GetFunction());
-}
-
 } // namespace duckdb

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

@@ -1,4 +1,5 @@
 #include "duckdb/function/scalar/regexp.hpp"
+#include "duckdb/function/scalar/string_common.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/function/scalar/string_functions.hpp"
@@ -36,7 +37,7 @@ bool ExtractAll(duckdb_re2::StringPiece &input, duckdb_re2::RE2 &pattern, idx_t
 		// to avoid an infinite loop
 		// FIXME: support unicode characters
 		consumed++;
-		while (*startpos + consumed < input.length() && !LengthFun::IsCharacter(input[*startpos + consumed])) {
+		while (*startpos + consumed < input.length() && !IsCharacter(input[*startpos + consumed])) {
 			consumed++;
 		}
 	}

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

@@ -382,7 +382,7 @@ static unique_ptr<FunctionData> RegexExtractBind(ClientContext &context, ScalarF
 	                                        std::move(group_string));
 }
 
-void RegexpFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunctionSet RegexpFun::GetFunctions() {
 	ScalarFunctionSet regexp_full_match("regexp_full_match");
 	regexp_full_match.AddFunction(
 	    ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
@@ -392,7 +392,10 @@ void RegexpFun::RegisterFunction(BuiltinFunctions &set) {
 	    ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
 	                   RegexpMatchesFunction<RegexFullMatch>, RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState,
 	                   LogicalType::INVALID, FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
+	return (regexp_full_match);
+}
 
+ScalarFunctionSet RegexpMatchesFun::GetFunctions() {
 	ScalarFunctionSet regexp_partial_match("regexp_matches");
 	regexp_partial_match.AddFunction(ScalarFunction(
 	    {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN, RegexpMatchesFunction<RegexPartialMatch>,
@@ -402,7 +405,13 @@ void RegexpFun::RegisterFunction(BuiltinFunctions &set) {
 	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
 	    RegexpMatchesFunction<RegexPartialMatch>, RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState,
 	    LogicalType::INVALID, FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
+	for (auto &func : regexp_partial_match.functions) {
+		BaseScalarFunction::SetReturnsError(func);
+	}
+	return (regexp_partial_match);
+}
 
+ScalarFunctionSet RegexpReplaceFun::GetFunctions() {
 	ScalarFunctionSet regexp_replace("regexp_replace");
 	regexp_replace.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
 	                                          LogicalType::VARCHAR, RegexReplaceFunction, RegexReplaceBind, nullptr,
@@ -410,7 +419,10 @@ void RegexpFun::RegisterFunction(BuiltinFunctions &set) {
 	regexp_replace.AddFunction(ScalarFunction(
 	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
 	    RegexReplaceFunction, RegexReplaceBind, nullptr, nullptr, RegexInitLocalState));
+	return (regexp_replace);
+}
 
+ScalarFunctionSet RegexpExtractFun::GetFunctions() {
 	ScalarFunctionSet regexp_extract("regexp_extract");
 	regexp_extract.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
 	                                          RegexExtractFunction, RegexExtractBind, nullptr, nullptr,
@@ -434,7 +446,10 @@ void RegexpFun::RegisterFunction(BuiltinFunctions &set) {
 	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::LIST(LogicalType::VARCHAR), LogicalType::VARCHAR},
 	    LogicalType::VARCHAR, RegexExtractStructFunction, RegexExtractBind, nullptr, nullptr, RegexInitLocalState,
 	    LogicalType::INVALID, FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
+	return (regexp_extract);
+}
 
+ScalarFunctionSet RegexpExtractAllFun::GetFunctions() {
 	ScalarFunctionSet regexp_extract_all("regexp_extract_all");
 	regexp_extract_all.AddFunction(ScalarFunction(
 	    {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::LIST(LogicalType::VARCHAR),
@@ -449,12 +464,7 @@ void RegexpFun::RegisterFunction(BuiltinFunctions &set) {
 	                   LogicalType::LIST(LogicalType::VARCHAR), RegexpExtractAll::Execute, RegexpExtractAll::Bind,
 	                   nullptr, nullptr, RegexpExtractAll::InitLocalState, LogicalType::INVALID,
 	                   FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
-
-	set.AddFunction(regexp_full_match);
-	set.AddFunction(regexp_partial_match);
-	set.AddFunction(regexp_replace);
-	set.AddFunction(regexp_extract);
-	set.AddFunction(regexp_extract_all);
+	return (regexp_extract_all);
 }
 
 } // namespace duckdb

package/src/duckdb/src/{core_functions → function}/scalar/string/regexp_escape.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/scalar/string_functions.hpp"
+#include "duckdb/function/scalar/string_functions.hpp"
 #include "re2/re2.h"
 
 namespace duckdb {
@@ -16,7 +16,7 @@ static void RegexpEscapeFunction(DataChunk &args, ExpressionState &state, Vector
 }
 
 ScalarFunction RegexpEscapeFun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, RegexpEscapeFunction);
+	return ScalarFunction("regexp_escape", {LogicalType::VARCHAR}, LogicalType::VARCHAR, RegexpEscapeFunction);
 }
 
 } // namespace duckdb

package/src/duckdb/src/{core_functions → function}/scalar/string/sha1.cpp

@@ -1,6 +1,6 @@
+#include "duckdb/function/scalar/string_functions.hpp"
 #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 {

package/src/duckdb/src/{core_functions → function}/scalar/string/sha256.cpp

@@ -1,6 +1,6 @@
+#include "duckdb/function/scalar/string_functions.hpp"
 #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 {

package/src/duckdb/src/{core_functions → function}/scalar/string/string_split.cpp

@@ -1,10 +1,10 @@
+#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/function/scalar/string_common.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/common/types/vector.hpp"
 #include "duckdb/common/vector_size.hpp"
-#include "duckdb/core_functions/scalar/string_functions.hpp"
 #include "duckdb/function/scalar/regexp.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 
 namespace duckdb {
@@ -36,8 +36,7 @@ struct RegularStringSplit {
 		if (delim_size == 0) {
 			return 0;
 		}
-		return ContainsFun::Find(const_uchar_ptr_cast(input_data), input_size, const_uchar_ptr_cast(delim_data),
-		                         delim_size);
+		return FindStrInStr(const_uchar_ptr_cast(input_data), input_size, const_uchar_ptr_cast(delim_data), delim_size);
 	}
 };
 
@@ -84,7 +83,7 @@ struct StringSplitter {
 				// special case: 0 length match and pos is 0
 				// move to the next character
 				for (pos++; pos < input_size; pos++) {
-					if (LengthFun::IsCharacter(input_data[pos])) {
+					if (IsCharacter(input_data[pos])) {
 						break;
 					}
 				}

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

@@ -1,10 +1,11 @@
+#include "duckdb/function/scalar/string_common.hpp"
 #include "duckdb/function/scalar/string_functions.hpp"
 
 #include "utf8proc.hpp"
 
 namespace duckdb {
 
-bool StripAccentsFun::IsAscii(const char *input, idx_t n) {
+bool IsAscii(const char *input, idx_t n) {
 	for (idx_t i = 0; i < n; i++) {
 		if (input[i] & 0x80) {
 			// non-ascii character
@@ -17,7 +18,7 @@ bool StripAccentsFun::IsAscii(const char *input, idx_t n) {
 struct StripAccentsOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		if (StripAccentsFun::IsAscii(input.GetData(), input.GetSize())) {
+		if (IsAscii(input.GetData(), input.GetSize())) {
 			return input;
 		}
 
@@ -41,8 +42,4 @@ ScalarFunction StripAccentsFun::GetFunction() {
 	return ScalarFunction("strip_accents", {LogicalType::VARCHAR}, LogicalType::VARCHAR, StripAccentsFunction);
 }
 
-void StripAccentsFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(StripAccentsFun::GetFunction());
-}
-
 } // namespace duckdb

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

@@ -1,3 +1,4 @@
+#include "duckdb/function/scalar/string_common.hpp"
 #include "duckdb/function/scalar/string_functions.hpp"
 
 #include "duckdb/common/algorithm.hpp"
@@ -94,7 +95,7 @@ string_t SubstringASCII(Vector &result, string_t input, int64_t offset, int64_t
 	return SubstringSlice(result, input_data, start, UnsafeNumericCast<int64_t>(end - start));
 }
 
-string_t SubstringFun::SubstringUnicode(Vector &result, string_t input, int64_t offset, int64_t length) {
+string_t SubstringUnicode(Vector &result, string_t input, int64_t offset, int64_t length) {
 	auto input_data = input.GetData();
 	auto input_size = input.GetSize();
 
@@ -129,7 +130,7 @@ string_t SubstringFun::SubstringUnicode(Vector &result, string_t input, int64_t
 		}
 		int64_t current_character = 0;
 		for (idx_t i = input_size; i > 0; i--) {
-			if (LengthFun::IsCharacter(input_data[i - 1])) {
+			if (IsCharacter(input_data[i - 1])) {
 				current_character++;
 				if (current_character == start) {
 					start_pos = i;
@@ -139,10 +140,10 @@ string_t SubstringFun::SubstringUnicode(Vector &result, string_t input, int64_t
 				}
 			}
 		}
-		while (!LengthFun::IsCharacter(input_data[start_pos])) {
+		while (!IsCharacter(input_data[start_pos])) {
 			start_pos++;
 		}
-		while (end_pos < input_size && !LengthFun::IsCharacter(input_data[end_pos])) {
+		while (end_pos < input_size && !IsCharacter(input_data[end_pos])) {
 			end_pos++;
 		}
 
@@ -170,7 +171,7 @@ string_t SubstringFun::SubstringUnicode(Vector &result, string_t input, int64_t
 
 		int64_t current_character = 0;
 		for (idx_t i = 0; i < input_size; i++) {
-			if (LengthFun::IsCharacter(input_data[i])) {
+			if (IsCharacter(input_data[i])) {
 				if (current_character == start) {
 					start_pos = i;
 				} else if (current_character == end) {
@@ -190,7 +191,7 @@ string_t SubstringFun::SubstringUnicode(Vector &result, string_t input, int64_t
 	                      UnsafeNumericCast<int64_t>(end_pos - start_pos));
 }
 
-string_t SubstringFun::SubstringGrapheme(Vector &result, string_t input, int64_t offset, int64_t length) {
+string_t SubstringGrapheme(Vector &result, string_t input, int64_t offset, int64_t length) {
 	auto input_data = input.GetData();
 	auto input_size = input.GetSize();
 
@@ -251,13 +252,13 @@ string_t SubstringFun::SubstringGrapheme(Vector &result, string_t input, int64_t
 
 struct SubstringUnicodeOp {
 	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 SubstringGraphemeOp {
 	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);
 	}
 };
 
@@ -311,7 +312,7 @@ static unique_ptr<BaseStatistics> SubstringPropagateStats(ClientContext &context
 	return nullptr;
 }
 
-void SubstringFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunctionSet SubstringFun::GetFunctions() {
 	ScalarFunctionSet substr("substring");
 	substr.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::BIGINT, LogicalType::BIGINT},
 	                                  LogicalType::VARCHAR, SubstringFunction<SubstringUnicodeOp>, nullptr, nullptr,
@@ -319,10 +320,10 @@ void SubstringFun::RegisterFunction(BuiltinFunctions &set) {
 	substr.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR,
 	                                  SubstringFunction<SubstringUnicodeOp>, nullptr, nullptr,
 	                                  SubstringPropagateStats));
-	set.AddFunction(substr);
-	substr.name = "substr";
-	set.AddFunction(substr);
+	return (substr);
+}
 
+ScalarFunctionSet SubstringGraphemeFun::GetFunctions() {
 	ScalarFunctionSet substr_grapheme("substring_grapheme");
 	substr_grapheme.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::BIGINT, LogicalType::BIGINT},
 	                                           LogicalType::VARCHAR, SubstringFunction<SubstringGraphemeOp>, nullptr,
@@ -330,7 +331,7 @@ void SubstringFun::RegisterFunction(BuiltinFunctions &set) {
 	substr_grapheme.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR,
 	                                           SubstringFunction<SubstringGraphemeOp>, nullptr, nullptr,
 	                                           SubstringPropagateStats));
-	set.AddFunction(substr_grapheme);
+	return (substr_grapheme);
 }
 
 } // namespace duckdb

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

@@ -40,8 +40,4 @@ ScalarFunction SuffixFun::GetFunction() {
 	                      ScalarFunction::BinaryFunction<string_t, string_t, bool, SuffixOperator>);
 }
 
-void SuffixFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction({"suffix", "ends_with"}, GetFunction());
-}
-
 } // namespace duckdb

package/src/duckdb/src/function/scalar/struct/struct_concat.cpp

@@ -0,0 +1,115 @@
+#include "duckdb/function/scalar/nested_functions.hpp"
+#include "duckdb/function/scalar/struct_functions.hpp"
+#include "duckdb/common/case_insensitive_map.hpp"
+#include "duckdb/planner/expression_binder.hpp"
+#include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/storage/statistics/struct_stats.hpp"
+
+namespace duckdb {
+
+static void StructConcatFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &result_cols = StructVector::GetEntries(result);
+	idx_t offset = 0;
+
+	if (!args.AllConstant()) {
+		// Unless all arguments are constant, we flatten the input to make sure it's homogeneous
+		args.Flatten();
+	}
+
+	for (auto &arg : args.data) {
+		const auto &child_cols = StructVector::GetEntries(arg);
+		for (auto &child_col : child_cols) {
+			result_cols[offset++]->Reference(*child_col);
+		}
+	}
+	D_ASSERT(offset == result_cols.size());
+
+	if (args.AllConstant()) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+
+	result.Verify(args.size());
+}
+
+static unique_ptr<FunctionData> StructConcatBind(ClientContext &context, ScalarFunction &bound_function,
+                                                 vector<unique_ptr<Expression>> &arguments) {
+
+	// collect names and deconflict, construct return type
+	if (arguments.empty()) {
+		throw InvalidInputException("struct_concat: At least one argument is required");
+	}
+
+	child_list_t<LogicalType> combined_children;
+	case_insensitive_set_t name_set;
+
+	bool has_unnamed = false;
+
+	for (idx_t arg_idx = 0; arg_idx < arguments.size(); arg_idx++) {
+		const auto &arg = arguments[arg_idx];
+
+		if (arg->return_type.id() == LogicalTypeId::UNKNOWN) {
+			throw ParameterNotResolvedException();
+		}
+
+		if (arg->return_type.id() != LogicalTypeId::STRUCT) {
+			throw InvalidInputException("struct_concat: Argument at position \"%d\" is not a STRUCT", arg_idx + 1);
+		}
+
+		const auto &child_types = StructType::GetChildTypes(arg->return_type);
+		for (const auto &child : child_types) {
+			if (!child.first.empty()) {
+				auto it = name_set.find(child.first);
+				if (it != name_set.end()) {
+					if (*it == child.first) {
+						throw InvalidInputException("struct_concat: Arguments contain duplicate STRUCT entry \"%s\"",
+						                            child.first);
+					}
+					throw InvalidInputException(
+					    "struct_concat: Arguments contain case-insensitive duplicate STRUCT entry \"%s\" and \"%s\"",
+					    child.first, *it);
+				}
+				name_set.insert(child.first);
+			} else {
+				has_unnamed = true;
+			}
+			combined_children.push_back(child);
+		}
+	}
+
+	if (has_unnamed && !name_set.empty()) {
+		throw InvalidInputException("struct_concat: Cannot mix named and unnamed STRUCTs");
+	}
+
+	bound_function.return_type = LogicalType::STRUCT(combined_children);
+	return nullptr;
+}
+
+unique_ptr<BaseStatistics> StructConcatStats(ClientContext &context, FunctionStatisticsInput &input) {
+	const auto &expr = input.expr;
+
+	auto &arg_stats = input.child_stats;
+	auto &arg_exprs = input.expr.children;
+
+	auto struct_stats = StructStats::CreateUnknown(expr.return_type);
+	idx_t struct_index = 0;
+
+	for (idx_t arg_idx = 0; arg_idx < arg_exprs.size(); arg_idx++) {
+		auto &arg_stat = arg_stats[arg_idx];
+		auto &arg_type = arg_exprs[arg_idx]->return_type;
+		for (idx_t child_idx = 0; child_idx < StructType::GetChildCount(arg_type); child_idx++) {
+			auto &child_stat = StructStats::GetChildStats(arg_stat, child_idx);
+			StructStats::SetChildStats(struct_stats, struct_index++, child_stat);
+		}
+	}
+	return struct_stats.ToUnique();
+}
+
+ScalarFunction StructConcatFun::GetFunction() {
+	ScalarFunction fun("struct_concat", {}, LogicalTypeId::STRUCT, StructConcatFunction, StructConcatBind, nullptr,
+	                   StructConcatStats);
+	fun.varargs = LogicalType::ANY;
+	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+	return fun;
+}
+
+} // namespace duckdb