duckdb 0.7.2-dev2706.0 → 0.7.2-dev2820.0

package/src/duckdb/src/core_functions/scalar/date/strftime.cpp

@@ -0,0 +1,251 @@
+#include "duckdb/function/scalar/strftime_format.hpp"
+
+#include "duckdb/common/vector_operations/unary_executor.hpp"
+#include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/planner/expression/bound_parameter_expression.hpp"
+#include "duckdb/core_functions/scalar/date_functions.hpp"
+
+#include <cctype>
+#include <utility>
+
+namespace duckdb {
+
+struct StrfTimeBindData : public FunctionData {
+	explicit StrfTimeBindData(StrfTimeFormat format_p, string format_string_p, bool is_null)
+	    : format(std::move(format_p)), format_string(std::move(format_string_p)), is_null(is_null) {
+	}
+
+	StrfTimeFormat format;
+	string format_string;
+	bool is_null;
+
+	unique_ptr<FunctionData> Copy() const override {
+		return make_uniq<StrfTimeBindData>(format, format_string, is_null);
+	}
+
+	bool Equals(const FunctionData &other_p) const override {
+		auto &other = (const StrfTimeBindData &)other_p;
+		return format_string == other.format_string;
+	}
+};
+
+template <bool REVERSED>
+static unique_ptr<FunctionData> StrfTimeBindFunction(ClientContext &context, ScalarFunction &bound_function,
+                                                     vector<unique_ptr<Expression>> &arguments) {
+	auto format_idx = REVERSED ? 0 : 1;
+	auto &format_arg = arguments[format_idx];
+	if (format_arg->HasParameter()) {
+		throw ParameterNotResolvedException();
+	}
+	if (!format_arg->IsFoldable()) {
+		throw InvalidInputException("strftime format must be a constant");
+	}
+	Value options_str = ExpressionExecutor::EvaluateScalar(context, *format_arg);
+	auto format_string = options_str.GetValue<string>();
+	StrfTimeFormat format;
+	bool is_null = options_str.IsNull();
+	if (!is_null) {
+		string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
+		if (!error.empty()) {
+			throw InvalidInputException("Failed to parse format specifier %s: %s", format_string, error);
+		}
+	}
+	return make_uniq<StrfTimeBindData>(format, format_string, is_null);
+}
+
+template <bool REVERSED>
+static void StrfTimeFunctionDate(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<StrfTimeBindData>();
+
+	if (info.is_null) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+		ConstantVector::SetNull(result, true);
+		return;
+	}
+	info.format.ConvertDateVector(args.data[REVERSED ? 1 : 0], result, args.size());
+}
+
+template <bool REVERSED>
+static void StrfTimeFunctionTimestamp(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<StrfTimeBindData>();
+
+	if (info.is_null) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+		ConstantVector::SetNull(result, true);
+		return;
+	}
+	info.format.ConvertTimestampVector(args.data[REVERSED ? 1 : 0], result, args.size());
+}
+
+ScalarFunctionSet StrfTimeFun::GetFunctions() {
+	ScalarFunctionSet strftime;
+
+	strftime.AddFunction(ScalarFunction({LogicalType::DATE, LogicalType::VARCHAR}, LogicalType::VARCHAR,
+	                                    StrfTimeFunctionDate<false>, StrfTimeBindFunction<false>));
+	strftime.AddFunction(ScalarFunction({LogicalType::TIMESTAMP, LogicalType::VARCHAR}, LogicalType::VARCHAR,
+	                                    StrfTimeFunctionTimestamp<false>, StrfTimeBindFunction<false>));
+	strftime.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE}, LogicalType::VARCHAR,
+	                                    StrfTimeFunctionDate<true>, StrfTimeBindFunction<true>));
+	strftime.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP}, LogicalType::VARCHAR,
+	                                    StrfTimeFunctionTimestamp<true>, StrfTimeBindFunction<true>));
+	return strftime;
+}
+
+struct StrpTimeBindData : public FunctionData {
+	StrpTimeBindData(const StrpTimeFormat &format, const string &format_string)
+	    : formats(1, format), format_strings(1, format_string) {
+	}
+
+	StrpTimeBindData(vector<StrpTimeFormat> formats_p, vector<string> format_strings_p)
+	    : formats(std::move(formats_p)), format_strings(std::move(format_strings_p)) {
+	}
+
+	vector<StrpTimeFormat> formats;
+	vector<string> format_strings;
+
+	unique_ptr<FunctionData> Copy() const override {
+		return make_uniq<StrpTimeBindData>(formats, format_strings);
+	}
+
+	bool Equals(const FunctionData &other_p) const override {
+		auto &other = (const StrpTimeBindData &)other_p;
+		return format_strings == other.format_strings;
+	}
+};
+
+static unique_ptr<FunctionData> StrpTimeBindFunction(ClientContext &context, ScalarFunction &bound_function,
+                                                     vector<unique_ptr<Expression>> &arguments) {
+	if (arguments[1]->HasParameter()) {
+		throw ParameterNotResolvedException();
+	}
+	if (!arguments[1]->IsFoldable()) {
+		throw InvalidInputException("strptime format must be a constant");
+	}
+	Value format_value = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
+	string format_string;
+	StrpTimeFormat format;
+	if (format_value.IsNull()) {
+		return make_uniq<StrpTimeBindData>(format, format_string);
+	} else if (format_value.type().id() == LogicalTypeId::VARCHAR) {
+		format_string = format_value.ToString();
+		format.format_specifier = format_string;
+		string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
+		if (!error.empty()) {
+			throw InvalidInputException("Failed to parse format specifier %s: %s", format_string, error);
+		}
+		if (format.HasFormatSpecifier(StrTimeSpecifier::UTC_OFFSET)) {
+			bound_function.return_type = LogicalType::TIMESTAMP_TZ;
+		}
+		return make_uniq<StrpTimeBindData>(format, format_string);
+	} else if (format_value.type() == LogicalType::LIST(LogicalType::VARCHAR)) {
+		const auto &children = ListValue::GetChildren(format_value);
+		if (children.empty()) {
+			throw InvalidInputException("strptime format list must not be empty");
+		}
+		vector<string> format_strings;
+		vector<StrpTimeFormat> formats;
+		for (const auto &child : children) {
+			format_string = child.ToString();
+			format.format_specifier = format_string;
+			string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
+			if (!error.empty()) {
+				throw InvalidInputException("Failed to parse format specifier %s: %s", format_string, error);
+			}
+			// If any format has UTC offsets, then we have to produce TSTZ
+			if (format.HasFormatSpecifier(StrTimeSpecifier::UTC_OFFSET)) {
+				bound_function.return_type = LogicalType::TIMESTAMP_TZ;
+			}
+			format_strings.emplace_back(format_string);
+			formats.emplace_back(format);
+		}
+		return make_uniq<StrpTimeBindData>(formats, format_strings);
+	} else {
+		throw InvalidInputException("strptime format must be a string");
+	}
+}
+
+struct StrpTimeFunction {
+
+	static void Parse(DataChunk &args, ExpressionState &state, Vector &result) {
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+		auto &info = func_expr.bind_info->Cast<StrpTimeBindData>();
+
+		if (ConstantVector::IsNull(args.data[1])) {
+			result.SetVectorType(VectorType::CONSTANT_VECTOR);
+			ConstantVector::SetNull(result, true);
+			return;
+		}
+		UnaryExecutor::Execute<string_t, timestamp_t>(args.data[0], result, args.size(), [&](string_t input) {
+			StrpTimeFormat::ParseResult result;
+			for (auto &format : info.formats) {
+				if (format.Parse(input, result)) {
+					return result.ToTimestamp();
+				}
+			}
+			throw InvalidInputException(result.FormatError(input, info.formats[0].format_specifier));
+		});
+	}
+
+	static void TryParse(DataChunk &args, ExpressionState &state, Vector &result) {
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+		auto &info = func_expr.bind_info->Cast<StrpTimeBindData>();
+
+		if (ConstantVector::IsNull(args.data[1])) {
+			result.SetVectorType(VectorType::CONSTANT_VECTOR);
+			ConstantVector::SetNull(result, true);
+			return;
+		}
+
+		UnaryExecutor::ExecuteWithNulls<string_t, timestamp_t>(
+		    args.data[0], result, args.size(), [&](string_t input, ValidityMask &mask, idx_t idx) {
+			    timestamp_t result;
+			    string error;
+			    for (auto &format : info.formats) {
+				    if (format.TryParseTimestamp(input, result, error)) {
+					    return result;
+				    }
+			    }
+
+			    mask.SetInvalid(idx);
+			    return timestamp_t();
+		    });
+	}
+};
+
+ScalarFunctionSet StrpTimeFun::GetFunctions() {
+	ScalarFunctionSet strptime;
+
+	const auto list_type = LogicalType::LIST(LogicalType::VARCHAR);
+	auto fun = ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::TIMESTAMP,
+	                          StrpTimeFunction::Parse, StrpTimeBindFunction);
+	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+	strptime.AddFunction(fun);
+
+	fun = ScalarFunction({LogicalType::VARCHAR, list_type}, LogicalType::TIMESTAMP, StrpTimeFunction::Parse,
+	                     StrpTimeBindFunction);
+	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+	strptime.AddFunction(fun);
+	return strptime;
+}
+
+ScalarFunctionSet TryStrpTimeFun::GetFunctions() {
+	ScalarFunctionSet try_strptime;
+
+	const auto list_type = LogicalType::LIST(LogicalType::VARCHAR);
+	auto fun = ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::TIMESTAMP,
+	                          StrpTimeFunction::TryParse, StrpTimeBindFunction);
+	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+	try_strptime.AddFunction(fun);
+
+	fun = ScalarFunction({LogicalType::VARCHAR, list_type}, LogicalType::TIMESTAMP, StrpTimeFunction::TryParse,
+	                     StrpTimeBindFunction);
+	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+	try_strptime.AddFunction(fun);
+
+	return try_strptime;
+}
+
+} // namespace duckdb

package/src/duckdb/src/{function → core_functions}/scalar/date/time_bucket.cpp

@@ -9,7 +9,7 @@
 #include "duckdb/common/vector_operations/binary_executor.hpp"
 #include "duckdb/common/vector_operations/ternary_executor.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/scalar/date_functions.hpp"
+#include "duckdb/core_functions/scalar/date_functions.hpp"
 
 namespace duckdb {
 
@@ -350,8 +350,8 @@ static void TimeBucketOriginFunction(DataChunk &args, ExpressionState &state, Ve
 	}
 }
 
-void TimeBucketFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet time_bucket("time_bucket");
+ScalarFunctionSet TimeBucketFun::GetFunctions() {
+	ScalarFunctionSet time_bucket;
 	time_bucket.AddFunction(
 	    ScalarFunction({LogicalType::INTERVAL, LogicalType::DATE}, LogicalType::DATE, TimeBucketFunction<date_t>));
 	time_bucket.AddFunction(ScalarFunction({LogicalType::INTERVAL, LogicalType::TIMESTAMP}, LogicalType::TIMESTAMP,
@@ -364,8 +364,7 @@ void TimeBucketFun::RegisterFunction(BuiltinFunctions &set) {
 	                                       LogicalType::DATE, TimeBucketOriginFunction<date_t>));
 	time_bucket.AddFunction(ScalarFunction({LogicalType::INTERVAL, LogicalType::TIMESTAMP, LogicalType::TIMESTAMP},
 	                                       LogicalType::TIMESTAMP, TimeBucketOriginFunction<timestamp_t>));
-
-	set.AddFunction(time_bucket);
+	return time_bucket;
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/scalar/date/to_interval.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/date_functions.hpp"
+#include "duckdb/core_functions/scalar/date_functions.hpp"
 #include "duckdb/common/types/interval.hpp"
 #include "duckdb/common/operator/multiply.hpp"
 
@@ -107,24 +107,44 @@ struct ToMicroSecondsOperator {
 	}
 };
 
-void ToIntervalFun::RegisterFunction(BuiltinFunctions &set) {
-	// register the individual operators
-	set.AddFunction(ScalarFunction("to_years", {LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                               ScalarFunction::UnaryFunction<int32_t, interval_t, ToYearsOperator>));
-	set.AddFunction(ScalarFunction("to_months", {LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                               ScalarFunction::UnaryFunction<int32_t, interval_t, ToMonthsOperator>));
-	set.AddFunction(ScalarFunction("to_days", {LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                               ScalarFunction::UnaryFunction<int32_t, interval_t, ToDaysOperator>));
-	set.AddFunction(ScalarFunction("to_hours", {LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                               ScalarFunction::UnaryFunction<int64_t, interval_t, ToHoursOperator>));
-	set.AddFunction(ScalarFunction("to_minutes", {LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                               ScalarFunction::UnaryFunction<int64_t, interval_t, ToMinutesOperator>));
-	set.AddFunction(ScalarFunction("to_seconds", {LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                               ScalarFunction::UnaryFunction<int64_t, interval_t, ToSecondsOperator>));
-	set.AddFunction(ScalarFunction("to_milliseconds", {LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                               ScalarFunction::UnaryFunction<int64_t, interval_t, ToMilliSecondsOperator>));
-	set.AddFunction(ScalarFunction("to_microseconds", {LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                               ScalarFunction::UnaryFunction<int64_t, interval_t, ToMicroSecondsOperator>));
+ScalarFunction ToYearsFun::GetFunction() {
+	return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
+	                      ScalarFunction::UnaryFunction<int32_t, interval_t, ToYearsOperator>);
+}
+
+ScalarFunction ToMonthsFun::GetFunction() {
+	return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
+	                      ScalarFunction::UnaryFunction<int32_t, interval_t, ToMonthsOperator>);
+}
+
+ScalarFunction ToDaysFun::GetFunction() {
+	return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
+	                      ScalarFunction::UnaryFunction<int32_t, interval_t, ToDaysOperator>);
+}
+
+ScalarFunction ToHoursFun::GetFunction() {
+	return ScalarFunction({LogicalType::BIGINT}, LogicalType::INTERVAL,
+	                      ScalarFunction::UnaryFunction<int64_t, interval_t, ToHoursOperator>);
+}
+
+ScalarFunction ToMinutesFun::GetFunction() {
+	return ScalarFunction({LogicalType::BIGINT}, LogicalType::INTERVAL,
+	                      ScalarFunction::UnaryFunction<int64_t, interval_t, ToMinutesOperator>);
+}
+
+ScalarFunction ToSecondsFun::GetFunction() {
+	return ScalarFunction({LogicalType::BIGINT}, LogicalType::INTERVAL,
+	                      ScalarFunction::UnaryFunction<int64_t, interval_t, ToSecondsOperator>);
+}
+
+ScalarFunction ToMillisecondsFun::GetFunction() {
+	return ScalarFunction({LogicalType::BIGINT}, LogicalType::INTERVAL,
+	                      ScalarFunction::UnaryFunction<int64_t, interval_t, ToMilliSecondsOperator>);
+}
+
+ScalarFunction ToMicrosecondsFun::GetFunction() {
+	return ScalarFunction({LogicalType::BIGINT}, LogicalType::INTERVAL,
+	                      ScalarFunction::UnaryFunction<int64_t, interval_t, ToMicroSecondsOperator>);
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function/scalar/enum/enum_functions_implementation.cpp → core_functions/scalar/enum/enum_functions.cpp}

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/enum_functions.hpp"
+#include "duckdb/core_functions/scalar/enum_functions.hpp"
 
 namespace duckdb {
 
@@ -130,40 +130,36 @@ unique_ptr<FunctionData> BindEnumRangeBoundaryFunction(ClientContext &context, S
 	return nullptr;
 }
 
-void EnumFirst::RegisterFunction(BuiltinFunctions &set) {
-	auto fun =
-	    ScalarFunction("enum_first", {LogicalType::ANY}, LogicalType::VARCHAR, EnumFirstFunction, BindEnumFunction);
+ScalarFunction EnumFirstFun::GetFunction() {
+	auto fun = ScalarFunction({LogicalType::ANY}, LogicalType::VARCHAR, EnumFirstFunction, BindEnumFunction);
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction(fun);
+	return fun;
 }
 
-void EnumLast::RegisterFunction(BuiltinFunctions &set) {
-	auto fun =
-	    ScalarFunction("enum_last", {LogicalType::ANY}, LogicalType::VARCHAR, EnumLastFunction, BindEnumFunction);
+ScalarFunction EnumLastFun::GetFunction() {
+	auto fun = ScalarFunction({LogicalType::ANY}, LogicalType::VARCHAR, EnumLastFunction, BindEnumFunction);
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction(fun);
+	return fun;
 }
 
-void EnumCode::RegisterFunction(BuiltinFunctions &set) {
-	auto fun =
-	    ScalarFunction("enum_code", {LogicalType::ANY}, LogicalType::ANY, EnumCodeFunction, BindEnumCodeFunction);
+ScalarFunction EnumCodeFun::GetFunction() {
+	auto fun = ScalarFunction({LogicalType::ANY}, LogicalType::ANY, EnumCodeFunction, BindEnumCodeFunction);
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction(fun);
+	return fun;
 }
 
-void EnumRange::RegisterFunction(BuiltinFunctions &set) {
-	auto fun = ScalarFunction("enum_range", {LogicalType::ANY}, LogicalType::LIST(LogicalType::VARCHAR),
-	                          EnumRangeFunction, BindEnumFunction);
+ScalarFunction EnumRangeFun::GetFunction() {
+	auto fun = ScalarFunction({LogicalType::ANY}, LogicalType::LIST(LogicalType::VARCHAR), EnumRangeFunction,
+	                          BindEnumFunction);
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction(fun);
+	return fun;
 }
 
-void EnumRangeBoundary::RegisterFunction(BuiltinFunctions &set) {
-	auto fun = ScalarFunction("enum_range_boundary", {LogicalType::ANY, LogicalType::ANY},
-	                          LogicalType::LIST(LogicalType::VARCHAR), EnumRangeBoundaryFunction,
-	                          BindEnumRangeBoundaryFunction);
+ScalarFunction EnumRangeBoundaryFun::GetFunction() {
+	auto fun = ScalarFunction({LogicalType::ANY, LogicalType::ANY}, LogicalType::LIST(LogicalType::VARCHAR),
+	                          EnumRangeBoundaryFunction, BindEnumRangeBoundaryFunction);
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction(fun);
+	return fun;
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/scalar/generic/alias.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/generic_functions.hpp"
+#include "duckdb/core_functions/scalar/generic_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 
 namespace duckdb {
@@ -9,10 +9,10 @@ static void AliasFunction(DataChunk &args, ExpressionState &state, Vector &resul
 	result.Reference(v);
 }
 
-void AliasFun::RegisterFunction(BuiltinFunctions &set) {
-	auto fun = ScalarFunction("alias", {LogicalType::ANY}, LogicalType::VARCHAR, AliasFunction);
+ScalarFunction AliasFun::GetFunction() {
+	auto fun = ScalarFunction({LogicalType::ANY}, LogicalType::VARCHAR, AliasFunction);
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction(fun);
+	return fun;
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/scalar/generic/current_setting.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/generic_functions.hpp"
+#include "duckdb/core_functions/scalar/generic_functions.hpp"
 
 #include "duckdb/main/database.hpp"
 #include "duckdb/main/client_context.hpp"
@@ -58,11 +58,10 @@ unique_ptr<FunctionData> CurrentSettingBind(ClientContext &context, ScalarFuncti
 	return make_uniq<CurrentSettingBindData>(val);
 }
 
-void CurrentSettingFun::RegisterFunction(BuiltinFunctions &set) {
-	auto fun = ScalarFunction("current_setting", {LogicalType::VARCHAR}, LogicalType::ANY, CurrentSettingFunction,
-	                          CurrentSettingBind);
+ScalarFunction CurrentSettingFun::GetFunction() {
+	auto fun = ScalarFunction({LogicalType::VARCHAR}, LogicalType::ANY, CurrentSettingFunction, CurrentSettingBind);
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction(fun);
+	return fun;
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/scalar/generic/error.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/generic_functions.hpp"
+#include "duckdb/core_functions/scalar/generic_functions.hpp"
 #include <iostream>
 
 namespace duckdb {
@@ -10,12 +10,12 @@ struct ErrorOperator {
 	}
 };
 
-void ErrorFun::RegisterFunction(BuiltinFunctions &set) {
-	auto fun = ScalarFunction("error", {LogicalType::VARCHAR}, LogicalType::BOOLEAN,
+ScalarFunction ErrorFun::GetFunction() {
+	auto fun = ScalarFunction({LogicalType::VARCHAR}, LogicalType::BOOLEAN,
 	                          ScalarFunction::UnaryFunction<string_t, bool, ErrorOperator>);
 	// Set the function with side effects to avoid the optimization.
 	fun.side_effects = FunctionSideEffects::HAS_SIDE_EFFECTS;
-	set.AddFunction(fun);
+	return fun;
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/scalar/generic/hash.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/generic_functions.hpp"
+#include "duckdb/core_functions/scalar/generic_functions.hpp"
 
 namespace duckdb {
 
@@ -6,11 +6,11 @@ static void HashFunction(DataChunk &args, ExpressionState &state, Vector &result
 	args.Hash(result);
 }
 
-void HashFun::RegisterFunction(BuiltinFunctions &set) {
-	auto hash_fun = ScalarFunction("hash", {LogicalType::ANY}, LogicalType::HASH, HashFunction);
+ScalarFunction HashFun::GetFunction() {
+	auto hash_fun = ScalarFunction({LogicalType::ANY}, LogicalType::HASH, HashFunction);
 	hash_fun.varargs = LogicalType::ANY;
 	hash_fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction(hash_fun);
+	return hash_fun;
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/scalar/generic/least.cpp

@@ -1,5 +1,5 @@
 #include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/function/scalar/generic_functions.hpp"
+#include "duckdb/core_functions/scalar/generic_functions.hpp"
 
 namespace duckdb {
 
@@ -101,8 +101,8 @@ ScalarFunction GetLeastGreatestFunction(const LogicalType &type) {
 }
 
 template <class OP>
-static void RegisterLeastGreatest(BuiltinFunctions &set, const string &fun_name) {
-	ScalarFunctionSet fun_set(fun_name);
+static ScalarFunctionSet GetLeastGreatestFunctions() {
+	ScalarFunctionSet fun_set;
 	fun_set.AddFunction(ScalarFunction({LogicalType::BIGINT}, LogicalType::BIGINT, LeastGreatestFunction<int64_t, OP>,
 	                                   nullptr, nullptr, nullptr, nullptr, LogicalType::BIGINT,
 	                                   FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
@@ -123,16 +123,15 @@ static void RegisterLeastGreatest(BuiltinFunctions &set, const string &fun_name)
 
 	fun_set.AddFunction(GetLeastGreatestFunction<timestamp_t, OP>(LogicalType::TIMESTAMP_TZ));
 	fun_set.AddFunction(GetLeastGreatestFunction<time_t, OP>(LogicalType::TIME_TZ));
-
-	set.AddFunction(fun_set);
+	return fun_set;
 }
 
-void LeastFun::RegisterFunction(BuiltinFunctions &set) {
-	RegisterLeastGreatest<duckdb::LessThan>(set, "least");
+ScalarFunctionSet LeastFun::GetFunctions() {
+	return GetLeastGreatestFunctions<duckdb::LessThan>();
 }
 
-void GreatestFun::RegisterFunction(BuiltinFunctions &set) {
-	RegisterLeastGreatest<duckdb::GreaterThan>(set, "greatest");
+ScalarFunctionSet GreatestFun::GetFunctions() {
+	return GetLeastGreatestFunctions<duckdb::GreaterThan>();
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/scalar/generic/stats.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/generic_functions.hpp"
+#include "duckdb/core_functions/scalar/generic_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 
 namespace duckdb {
@@ -43,12 +43,12 @@ static unique_ptr<BaseStatistics> StatsPropagateStats(ClientContext &context, Fu
 	return nullptr;
 }
 
-void StatsFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunction stats("stats", {LogicalType::ANY}, LogicalType::VARCHAR, StatsFunction, StatsBind, nullptr,
+ScalarFunction StatsFun::GetFunction() {
+	ScalarFunction stats({LogicalType::ANY}, LogicalType::VARCHAR, StatsFunction, StatsBind, nullptr,
 	                     StatsPropagateStats);
 	stats.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	stats.side_effects = FunctionSideEffects::HAS_SIDE_EFFECTS;
-	set.AddFunction(stats);
+	return stats;
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function/scalar/system → core_functions/scalar/generic}/system_functions.cpp

@@ -1,5 +1,5 @@
 #include "duckdb/catalog/catalog_search_path.hpp"
-#include "duckdb/function/scalar/generic_functions.hpp"
+#include "duckdb/core_functions/scalar/generic_functions.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/client_data.hpp"
@@ -64,20 +64,31 @@ static void VersionFunction(DataChunk &input, ExpressionState &state, Vector &re
 	result.Reference(val);
 }
 
-void SystemFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunction CurrentQueryFun::GetFunction() {
+	ScalarFunction current_query({}, LogicalType::VARCHAR, CurrentQueryFunction);
+	current_query.side_effects = FunctionSideEffects::HAS_SIDE_EFFECTS;
+	return current_query;
+}
+
+ScalarFunction CurrentSchemaFun::GetFunction() {
+	return ScalarFunction({}, LogicalType::VARCHAR, CurrentSchemaFunction);
+}
+
+ScalarFunction CurrentDatabaseFun::GetFunction() {
+	return ScalarFunction({}, LogicalType::VARCHAR, CurrentDatabaseFunction);
+}
+
+ScalarFunction CurrentSchemasFun::GetFunction() {
 	auto varchar_list_type = LogicalType::LIST(LogicalType::VARCHAR);
+	return ScalarFunction({LogicalType::BOOLEAN}, varchar_list_type, CurrentSchemasFunction);
+}
 
-	ScalarFunction current_query("current_query", {}, LogicalType::VARCHAR, CurrentQueryFunction);
-	current_query.side_effects = FunctionSideEffects::HAS_SIDE_EFFECTS;
-	set.AddFunction(current_query);
-	set.AddFunction(ScalarFunction("current_schema", {}, LogicalType::VARCHAR, CurrentSchemaFunction));
-	set.AddFunction(ScalarFunction("current_database", {}, LogicalType::VARCHAR, CurrentDatabaseFunction));
-	set.AddFunction(
-	    ScalarFunction("current_schemas", {LogicalType::BOOLEAN}, varchar_list_type, CurrentSchemasFunction));
-	set.AddFunction(ScalarFunction("txid_current", {}, LogicalType::BIGINT, TransactionIdCurrent));
-	set.AddFunction(ScalarFunction("version", {}, LogicalType::VARCHAR, VersionFunction));
-	set.AddFunction(ExportAggregateFunction::GetCombine());
-	set.AddFunction(ExportAggregateFunction::GetFinalize());
+ScalarFunction CurrentTransactionIdFun::GetFunction() {
+	return ScalarFunction({}, LogicalType::BIGINT, TransactionIdCurrent);
+}
+
+ScalarFunction VersionFun::GetFunction() {
+	return ScalarFunction({}, LogicalType::VARCHAR, VersionFunction);
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/scalar/generic/typeof.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/generic_functions.hpp"
+#include "duckdb/core_functions/scalar/generic_functions.hpp"
 
 namespace duckdb {
 
@@ -7,10 +7,10 @@ static void TypeOfFunction(DataChunk &args, ExpressionState &state, Vector &resu
 	result.Reference(v);
 }
 
-void TypeOfFun::RegisterFunction(BuiltinFunctions &set) {
-	auto fun = ScalarFunction("typeof", {LogicalType::ANY}, LogicalType::VARCHAR, TypeOfFunction);
+ScalarFunction TypeOfFun::GetFunction() {
+	auto fun = ScalarFunction({LogicalType::ANY}, LogicalType::VARCHAR, TypeOfFunction);
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction(fun);
+	return fun;
 }
 
 } // namespace duckdb