duckdb 0.7.2-dev2740.0 → 0.7.2-dev2867.0

package/src/duckdb/src/{function → core_functions}/scalar/operators/bitwise.cpp

@@ -1,7 +1,6 @@
-#include "duckdb/function/scalar/operators.hpp"
+#include "duckdb/core_functions/scalar/operators_functions.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/types/cast_helpers.hpp"
-#include "duckdb/function/scalar/bit_functions.hpp"
 #include "duckdb/common/types/bit.hpp"
 
 namespace duckdb {
@@ -100,14 +99,14 @@ static void BitwiseANDOperation(DataChunk &args, ExpressionState &state, Vector
 	    });
 }
 
-void BitwiseAndFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("&");
+ScalarFunctionSet BitwiseAndFun::GetFunctions() {
+	ScalarFunctionSet functions;
 	for (auto &type : LogicalType::Integral()) {
 		functions.AddFunction(
 		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseANDOperator>(type)));
 	}
 	functions.AddFunction(ScalarFunction({LogicalType::BIT, LogicalType::BIT}, LogicalType::BIT, BitwiseANDOperation));
-	set.AddFunction(functions);
+	return functions;
 }
 
 //===--------------------------------------------------------------------===//
@@ -130,14 +129,14 @@ static void BitwiseOROperation(DataChunk &args, ExpressionState &state, Vector &
 	    });
 }
 
-void BitwiseOrFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("|");
+ScalarFunctionSet BitwiseOrFun::GetFunctions() {
+	ScalarFunctionSet functions;
 	for (auto &type : LogicalType::Integral()) {
 		functions.AddFunction(
 		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseOROperator>(type)));
 	}
 	functions.AddFunction(ScalarFunction({LogicalType::BIT, LogicalType::BIT}, LogicalType::BIT, BitwiseOROperation));
-	set.AddFunction(functions);
+	return functions;
 }
 
 //===--------------------------------------------------------------------===//
@@ -160,14 +159,14 @@ static void BitwiseXOROperation(DataChunk &args, ExpressionState &state, Vector
 	    });
 }
 
-void BitwiseXorFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("xor");
+ScalarFunctionSet BitwiseXorFun::GetFunctions() {
+	ScalarFunctionSet functions;
 	for (auto &type : LogicalType::Integral()) {
 		functions.AddFunction(
 		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseXOROperator>(type)));
 	}
 	functions.AddFunction(ScalarFunction({LogicalType::BIT, LogicalType::BIT}, LogicalType::BIT, BitwiseXOROperation));
-	set.AddFunction(functions);
+	return functions;
 }
 
 //===--------------------------------------------------------------------===//
@@ -189,13 +188,13 @@ static void BitwiseNOTOperation(DataChunk &args, ExpressionState &state, Vector
 	});
 }
 
-void BitwiseNotFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("~");
+ScalarFunctionSet BitwiseNotFun::GetFunctions() {
+	ScalarFunctionSet functions;
 	for (auto &type : LogicalType::Integral()) {
 		functions.AddFunction(ScalarFunction({type}, type, GetScalarIntegerUnaryFunction<BitwiseNotOperator>(type)));
 	}
 	functions.AddFunction(ScalarFunction({LogicalType::BIT}, LogicalType::BIT, BitwiseNOTOperation));
-	set.AddFunction(functions);
+	return functions;
 }
 
 //===--------------------------------------------------------------------===//
@@ -251,15 +250,15 @@ static void BitwiseShiftLeftOperation(DataChunk &args, ExpressionState &state, V
 	    });
 }
 
-void LeftShiftFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("<<");
+ScalarFunctionSet LeftShiftFun::GetFunctions() {
+	ScalarFunctionSet functions;
 	for (auto &type : LogicalType::Integral()) {
 		functions.AddFunction(
 		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseShiftLeftOperator>(type)));
 	}
 	functions.AddFunction(
 	    ScalarFunction({LogicalType::BIT, LogicalType::INTEGER}, LogicalType::BIT, BitwiseShiftLeftOperation));
-	set.AddFunction(functions);
+	return functions;
 }
 
 //===--------------------------------------------------------------------===//
@@ -294,15 +293,15 @@ static void BitwiseShiftRightOperation(DataChunk &args, ExpressionState &state,
 	    });
 }
 
-void RightShiftFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions(">>");
+ScalarFunctionSet RightShiftFun::GetFunctions() {
+	ScalarFunctionSet functions;
 	for (auto &type : LogicalType::Integral()) {
 		functions.AddFunction(
 		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseShiftRightOperator>(type)));
 	}
 	functions.AddFunction(
 	    ScalarFunction({LogicalType::BIT, LogicalType::INTEGER}, LogicalType::BIT, BitwiseShiftRightOperation));
-	set.AddFunction(functions);
+	return functions;
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function/scalar/math → core_functions/scalar/random}/random.cpp

@@ -1,10 +1,9 @@
-#include "duckdb/function/scalar/math_functions.hpp"
+#include "duckdb/core_functions/scalar/random_functions.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/common/random_engine.hpp"
-#include "duckdb/function/scalar/uuid_functions.hpp"
 #include "duckdb/common/types/uuid.hpp"
 
 namespace duckdb {
@@ -34,11 +33,11 @@ static unique_ptr<FunctionLocalState> RandomInitLocalState(ExpressionState &stat
 	return make_uniq<RandomLocalState>(random_engine.NextRandomInteger());
 }
 
-void RandomFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunction RandomFun::GetFunction() {
 	ScalarFunction random("random", {}, LogicalType::DOUBLE, RandomFunction, nullptr, nullptr, nullptr,
 	                      RandomInitLocalState);
 	random.side_effects = FunctionSideEffects::HAS_SIDE_EFFECTS;
-	set.AddFunction(random);
+	return random;
 }
 
 static void GenerateUUIDFunction(DataChunk &args, ExpressionState &state, Vector &result) {
@@ -53,12 +52,12 @@ static void GenerateUUIDFunction(DataChunk &args, ExpressionState &state, Vector
 	}
 }
 
-void UUIDFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunction UUIDFun::GetFunction() {
 	ScalarFunction uuid_function({}, LogicalType::UUID, GenerateUUIDFunction, nullptr, nullptr, nullptr,
 	                             RandomInitLocalState);
 	// generate a random uuid
 	uuid_function.side_effects = FunctionSideEffects::HAS_SIDE_EFFECTS;
-	set.AddFunction({"uuid", "gen_random_uuid"}, uuid_function);
+	return uuid_function;
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function/scalar/math → core_functions/scalar/random}/setseed.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/math_functions.hpp"
+#include "duckdb/core_functions/scalar/random_functions.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/execution/expression_executor.hpp"
@@ -52,10 +52,10 @@ unique_ptr<FunctionData> SetSeedBind(ClientContext &context, ScalarFunction &bou
 	return make_uniq<SetseedBindData>(context);
 }
 
-void SetseedFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunction SetseedFun::GetFunction() {
 	ScalarFunction setseed("setseed", {LogicalType::DOUBLE}, LogicalType::SQLNULL, SetSeedFunction, SetSeedBind);
 	setseed.side_effects = FunctionSideEffects::HAS_SIDE_EFFECTS;
-	set.AddFunction(setseed);
+	return setseed;
 }
 
 } // namespace duckdb

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

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/core_functions/scalar/string_functions.hpp"
 #include "utf8proc.hpp"
 #include "utf8proc_wrapper.hpp"
 
@@ -16,10 +16,9 @@ struct AsciiOperator {
 	}
 };
 
-void ASCII::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunction ascii("ascii", {LogicalType::VARCHAR}, LogicalType::INTEGER,
-	                     ScalarFunction::UnaryFunction<string_t, int32_t, AsciiOperator>);
-	set.AddFunction(ascii);
+ScalarFunction ASCIIFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR}, LogicalType::INTEGER,
+	                      ScalarFunction::UnaryFunction<string_t, int32_t, AsciiOperator>);
 }
 
 } // namespace duckdb

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

@@ -1,3 +1,4 @@
+#include "duckdb/core_functions/scalar/string_functions.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
 #include "duckdb/common/types/string_type.hpp"
@@ -5,7 +6,6 @@
 #include "duckdb/common/types/vector.hpp"
 #include "duckdb/common/unicode_bar.hpp"
 #include "duckdb/common/vector_operations/generic_executor.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
 
 namespace duckdb {
 
@@ -81,13 +81,13 @@ static void BarFunction(DataChunk &args, ExpressionState &state, Vector &result)
 	}
 }
 
-void BarFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet bar("bar");
+ScalarFunctionSet BarFun::GetFunctions() {
+	ScalarFunctionSet bar;
 	bar.AddFunction(ScalarFunction({LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE},
 	                               LogicalType::VARCHAR, BarFunction));
 	bar.AddFunction(ScalarFunction({LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE},
 	                               LogicalType::VARCHAR, BarFunction));
-	set.AddFunction(bar);
+	return bar;
 }
 
 } // namespace duckdb

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

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/core_functions/scalar/string_functions.hpp"
 #include "utf8proc.hpp"
 #include "utf8proc_wrapper.hpp"
 
@@ -35,15 +35,14 @@ static void ChrFunction(DataChunk &args, ExpressionState &state, Vector &result)
 }
 #endif
 
-void CHR::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunction chr("chr", {LogicalType::INTEGER}, LogicalType::VARCHAR,
+ScalarFunction ChrFun::GetFunction() {
+	return ScalarFunction("chr", {LogicalType::INTEGER}, LogicalType::VARCHAR,
 #ifdef DUCKDB_DEBUG_NO_INLINE
-	                   ChrFunction
+	                      ChrFunction
 #else
-	                   ScalarFunction::UnaryFunction<int32_t, string_t, ChrOperator>
+	                      ScalarFunction::UnaryFunction<int32_t, string_t, ChrOperator>
 #endif
 	);
-	set.AddFunction(chr);
 }
 
 } // namespace duckdb

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

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/core_functions/scalar/string_functions.hpp"
 #include "duckdb/common/map.hpp"
 #include "duckdb/common/vector.hpp"
 
@@ -96,11 +96,9 @@ static void DamerauLevenshteinFunction(DataChunk &args, ExpressionState &state,
 	    [&](string_t source, string_t target) { return DamerauLevenshteinScalarFunction(result, source, target); });
 }
 
-void DamerauLevenshteinFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet damerau_levenshtein("damerau_levenshtein");
-	damerau_levenshtein.AddFunction(ScalarFunction("damerau_levenshtein", {LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                                               LogicalType::BIGINT, DamerauLevenshteinFunction));
-	set.AddFunction(damerau_levenshtein);
+ScalarFunction DamerauLevenshteinFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BIGINT,
+	                      DamerauLevenshteinFunction);
 }
 
 } // namespace duckdb

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

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/core_functions/scalar/string_functions.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 
 #include <ctype.h>
@@ -38,17 +38,8 @@ static void MismatchesFunction(DataChunk &args, ExpressionState &state, Vector &
 	    [&](string_t str, string_t tgt) { return MismatchesScalarFunction(result, str, tgt); });
 }
 
-void MismatchesFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet mismatches("mismatches");
-	mismatches.AddFunction(ScalarFunction("mismatches", {LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                                      LogicalType::BIGINT,
-	                                      MismatchesFunction)); // Pointer to function implementation
-	set.AddFunction(mismatches);
-
-	ScalarFunctionSet hamming("hamming");
-	hamming.AddFunction(ScalarFunction("mismatches", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BIGINT,
-	                                   MismatchesFunction)); // Pointer to function implementation
-	set.AddFunction(hamming);
+ScalarFunction HammingFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BIGINT, MismatchesFunction);
 }
 
 } // namespace duckdb

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

@@ -4,7 +4,8 @@
 #include "duckdb/common/types/blob.hpp"
 #include "duckdb/common/vector_operations/unary_executor.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/core_functions/scalar/string_functions.hpp"
 
 namespace duckdb {
 
@@ -332,10 +333,8 @@ static void FromHexFunction(DataChunk &args, ExpressionState &state, Vector &res
 	UnaryExecutor::ExecuteString<string_t, string_t, FromHexOperator>(input, result, count);
 }
 
-void HexFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet to_hex("to_hex");
-	ScalarFunctionSet from_hex("from_hex");
-
+ScalarFunctionSet HexFun::GetFunctions() {
+	ScalarFunctionSet to_hex;
 	to_hex.AddFunction(
 	    ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, ToHexFunction<string_t, HexStrOperator>));
 
@@ -347,20 +346,16 @@ void HexFun::RegisterFunction(BuiltinFunctions &set) {
 
 	to_hex.AddFunction(
 	    ScalarFunction({LogicalType::HUGEINT}, LogicalType::VARCHAR, ToHexFunction<hugeint_t, HexHugeIntOperator>));
+	return to_hex;
+}
 
-	from_hex.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::BLOB, FromHexFunction));
-
-	set.AddFunction(to_hex);
-	set.AddFunction(from_hex);
+ScalarFunction UnhexFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR}, LogicalType::BLOB, FromHexFunction);
+}
 
-	// mysql
-	to_hex.name = "hex";
-	from_hex.name = "unhex";
-	set.AddFunction(to_hex);
-	set.AddFunction(from_hex);
+ScalarFunctionSet BinFun::GetFunctions() {
+	ScalarFunctionSet to_binary;
 
-	ScalarFunctionSet to_binary("to_binary");
-	ScalarFunctionSet from_binary("from_binary");
 	to_binary.AddFunction(
 	    ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, ToBinaryFunction<string_t, BinaryStrOperator>));
 	to_binary.AddFunction(ScalarFunction({LogicalType::UBIGINT}, LogicalType::VARCHAR,
@@ -369,16 +364,11 @@ void HexFun::RegisterFunction(BuiltinFunctions &set) {
 	    ScalarFunction({LogicalType::BIGINT}, LogicalType::VARCHAR, ToBinaryFunction<int64_t, BinaryIntegralOperator>));
 	to_binary.AddFunction(ScalarFunction({LogicalType::HUGEINT}, LogicalType::VARCHAR,
 	                                     ToBinaryFunction<hugeint_t, BinaryHugeIntOperator>));
+	return to_binary;
+}
 
-	from_binary.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::BLOB, FromBinaryFunction));
-
-	set.AddFunction(to_binary);
-	set.AddFunction(from_binary);
-
-	to_binary.name = "bin";
-	from_binary.name = "unbin";
-	set.AddFunction(to_binary);
-	set.AddFunction(from_binary);
+ScalarFunction UnbinFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR}, LogicalType::BLOB, FromBinaryFunction);
 }
 
 } // namespace duckdb

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

@@ -1,9 +1,9 @@
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/core_functions/scalar/string_functions.hpp"
 
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
-
+#include "duckdb/function/scalar/string_functions.hpp"
 #include "utf8proc.hpp"
 
 namespace duckdb {
@@ -49,17 +49,10 @@ static unique_ptr<BaseStatistics> InStrPropagateStats(ClientContext &context, Fu
 	return nullptr;
 }
 
-void InstrFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunction instr("instr",                                      // name of the function
-	                     {LogicalType::VARCHAR, LogicalType::VARCHAR}, // argument list
-	                     LogicalType::BIGINT,                          // return type
-	                     ScalarFunction::BinaryFunction<string_t, string_t, int64_t, InstrOperator>, nullptr, nullptr,
-	                     InStrPropagateStats);
-	set.AddFunction(instr);
-	instr.name = "strpos";
-	set.AddFunction(instr);
-	instr.name = "position";
-	set.AddFunction(instr);
+ScalarFunction InstrFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BIGINT,
+	                      ScalarFunction::BinaryFunction<string_t, string_t, int64_t, InstrOperator>, nullptr, nullptr,
+	                      InStrPropagateStats);
 }
 
 } // namespace duckdb

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

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/core_functions/scalar/string_functions.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/map.hpp"
 
@@ -58,11 +58,8 @@ static void JaccardFunction(DataChunk &args, ExpressionState &state, Vector &res
 	    [&](string_t str, string_t tgt) { return JaccardScalarFunction(result, str, tgt); });
 }
 
-void JaccardFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet jaccard("jaccard");
-	jaccard.AddFunction(ScalarFunction("jaccard", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::DOUBLE,
-	                                   JaccardFunction)); // Pointer to function implementation
-	set.AddFunction(jaccard);
+ScalarFunction JaccardFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::DOUBLE, JaccardFunction);
 }
 
 } // namespace duckdb

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

@@ -1,6 +1,6 @@
 #include "jaro_winkler.hpp"
 
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/core_functions/scalar/string_functions.hpp"
 
 namespace duckdb {
 
@@ -60,11 +60,12 @@ static void JaroWinklerFunction(DataChunk &args, ExpressionState &state, Vector
 	                                                                                     JaroWinklerScalarFunction);
 }
 
-void JaroWinklerFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("jaro_similarity", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::DOUBLE,
-	                               JaroFunction));
-	set.AddFunction(ScalarFunction("jaro_winkler_similarity", {LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                               LogicalType::DOUBLE, JaroWinklerFunction));
+ScalarFunction JaroSimilarityFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::DOUBLE, JaroFunction);
+}
+
+ScalarFunction JaroWinklerSimilarityFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::DOUBLE, JaroWinklerFunction);
 }
 
 } // namespace duckdb

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

@@ -1,6 +1,7 @@
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/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 <ctype.h>
 #include <algorithm>
@@ -50,11 +51,14 @@ static void LeftFunction(DataChunk &args, ExpressionState &state, Vector &result
 	    [&](string_t str, int64_t pos) { return LeftScalarFunction<OP>(result, str, pos); });
 }
 
-void LeftFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("left", {LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR,
-	                               LeftFunction<LeftRightUnicode>));
-	set.AddFunction(ScalarFunction("left_grapheme", {LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR,
-	                               LeftFunction<LeftRightGrapheme>));
+ScalarFunction LeftFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR,
+	                      LeftFunction<LeftRightUnicode>);
+}
+
+ScalarFunction LeftGraphemeFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR,
+	                      LeftFunction<LeftRightGrapheme>);
 }
 
 template <class OP>
@@ -83,11 +87,14 @@ static void RightFunction(DataChunk &args, ExpressionState &state, Vector &resul
 	    [&](string_t str, int64_t pos) { return RightScalarFunction<OP>(result, str, pos); });
 }
 
-void RightFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("right", {LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR,
-	                               RightFunction<LeftRightUnicode>));
-	set.AddFunction(ScalarFunction("right_grapheme", {LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR,
-	                               RightFunction<LeftRightGrapheme>));
+ScalarFunction RightFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR,
+	                      RightFunction<LeftRightUnicode>);
+}
+
+ScalarFunction RightGraphemeFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR,
+	                      RightFunction<LeftRightGrapheme>);
 }
 
 } // namespace duckdb

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

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/core_functions/scalar/string_functions.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/string_util.hpp"
 
@@ -77,17 +77,8 @@ static void LevenshteinFunction(DataChunk &args, ExpressionState &state, Vector
 	    [&](string_t str, string_t tgt) { return LevenshteinScalarFunction(result, str, tgt); });
 }
 
-void LevenshteinFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet levenshtein("levenshtein");
-	levenshtein.AddFunction(ScalarFunction("levenshtein", {LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                                       LogicalType::BIGINT,
-	                                       LevenshteinFunction)); // Pointer to function implementation
-	set.AddFunction(levenshtein);
-
-	ScalarFunctionSet editdist3("editdist3");
-	editdist3.AddFunction(ScalarFunction("levenshtein", {LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                                     LogicalType::BIGINT, LevenshteinFunction));
-	set.AddFunction(editdist3);
+ScalarFunction LevenshteinFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BIGINT, LevenshteinFunction);
 }
 
 } // namespace duckdb

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

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/core_functions/scalar/string_functions.hpp"
 
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/crypto/md5.hpp"
@@ -67,26 +67,20 @@ static void MD5NumberLowerFunction(DataChunk &args, ExpressionState &state, Vect
 	UnaryExecutor::Execute<string_t, uint64_t, MD5Number64Operator<true>>(input, result, args.size());
 }
 
-void MD5Fun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("md5",                  // name of the function
-	                               {LogicalType::VARCHAR}, // argument list
-	                               LogicalType::VARCHAR,   // return type
-	                               MD5Function));          // pointer to function implementation
-
-	set.AddFunction(ScalarFunction("md5_number",           // name of the function
-	                               {LogicalType::VARCHAR}, // argument list
-	                               LogicalType::HUGEINT,   // return type
-	                               MD5NumberFunction));    // pointer to function implementation
-
-	set.AddFunction(ScalarFunction("md5_number_upper",       // name of the function
-	                               {LogicalType::VARCHAR},   // argument list
-	                               LogicalType::UBIGINT,     // return type
-	                               MD5NumberUpperFunction)); // pointer to function implementation
-
-	set.AddFunction(ScalarFunction("md5_number_lower",       // name of the function
-	                               {LogicalType::VARCHAR},   // argument list
-	                               LogicalType::UBIGINT,     // return type
-	                               MD5NumberLowerFunction)); // pointer to function implementation
+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);
+}
+
+ScalarFunction MD5NumberLowerFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR}, LogicalType::UBIGINT, MD5NumberLowerFunction);
 }
 
 } // namespace duckdb

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

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/core_functions/scalar/string_functions.hpp"
 
 #include "duckdb/common/algorithm.hpp"
 #include "duckdb/common/exception.hpp"
@@ -130,20 +130,14 @@ static void PadFunction(DataChunk &args, ExpressionState &state, Vector &result)
 	    });
 }
 
-void LpadFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("lpad",                                      // name of the function
-	                               {LogicalType::VARCHAR, LogicalType::INTEGER, // argument list
-	                                LogicalType::VARCHAR},
-	                               LogicalType::VARCHAR,           // return type
-	                               PadFunction<LeftPadOperator>)); // pointer to function implementation
+ScalarFunction LpadFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR, LogicalType::INTEGER, LogicalType::VARCHAR}, LogicalType::VARCHAR,
+	                      PadFunction<LeftPadOperator>);
 }
 
-void RpadFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("rpad",                                      // name of the function
-	                               {LogicalType::VARCHAR, LogicalType::INTEGER, // argument list
-	                                LogicalType::VARCHAR},
-	                               LogicalType::VARCHAR,            // return type
-	                               PadFunction<RightPadOperator>)); // pointer to function implementation
+ScalarFunction RpadFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR, LogicalType::INTEGER, LogicalType::VARCHAR}, LogicalType::VARCHAR,
+	                      PadFunction<RightPadOperator>);
 }
 
 } // namespace duckdb