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

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

@@ -1,3 +1,4 @@
+#include "duckdb/core_functions/scalar/date_functions.hpp"
 #include "duckdb/common/case_insensitive_map.hpp"
 #include "duckdb/common/enums/date_part_specifier.hpp"
 #include "duckdb/common/exception.hpp"
@@ -6,7 +7,6 @@
 #include "duckdb/common/types/timestamp.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/scalar/date_functions.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 
@@ -14,82 +14,6 @@
 
 namespace duckdb {
 
-bool TryGetDatePartSpecifier(const string &specifier_p, DatePartSpecifier &result) {
-	auto specifier = StringUtil::Lower(specifier_p);
-	if (specifier == "year" || specifier == "yr" || specifier == "y" || specifier == "years" || specifier == "yrs") {
-		result = DatePartSpecifier::YEAR;
-	} else if (specifier == "month" || specifier == "mon" || specifier == "months" || specifier == "mons") {
-		result = DatePartSpecifier::MONTH;
-	} else if (specifier == "day" || specifier == "days" || specifier == "d" || specifier == "dayofmonth") {
-		result = DatePartSpecifier::DAY;
-	} else if (specifier == "decade" || specifier == "dec" || specifier == "decades" || specifier == "decs") {
-		result = DatePartSpecifier::DECADE;
-	} else if (specifier == "century" || specifier == "cent" || specifier == "centuries" || specifier == "c") {
-		result = DatePartSpecifier::CENTURY;
-	} else if (specifier == "millennium" || specifier == "mil" || specifier == "millenniums" ||
-	           specifier == "millennia" || specifier == "mils" || specifier == "millenium") {
-		result = DatePartSpecifier::MILLENNIUM;
-	} else if (specifier == "microseconds" || specifier == "microsecond" || specifier == "us" || specifier == "usec" ||
-	           specifier == "usecs" || specifier == "usecond" || specifier == "useconds") {
-		result = DatePartSpecifier::MICROSECONDS;
-	} else if (specifier == "milliseconds" || specifier == "millisecond" || specifier == "ms" || specifier == "msec" ||
-	           specifier == "msecs" || specifier == "msecond" || specifier == "mseconds") {
-		result = DatePartSpecifier::MILLISECONDS;
-	} else if (specifier == "second" || specifier == "sec" || specifier == "seconds" || specifier == "secs" ||
-	           specifier == "s") {
-		result = DatePartSpecifier::SECOND;
-	} else if (specifier == "minute" || specifier == "min" || specifier == "minutes" || specifier == "mins" ||
-	           specifier == "m") {
-		result = DatePartSpecifier::MINUTE;
-	} else if (specifier == "hour" || specifier == "hr" || specifier == "hours" || specifier == "hrs" ||
-	           specifier == "h") {
-		result = DatePartSpecifier::HOUR;
-	} else if (specifier == "epoch") {
-		// seconds since 1970-01-01
-		result = DatePartSpecifier::EPOCH;
-	} else if (specifier == "dow" || specifier == "dayofweek" || specifier == "weekday") {
-		// day of the week (Sunday = 0, Saturday = 6)
-		result = DatePartSpecifier::DOW;
-	} else if (specifier == "isodow") {
-		// isodow (Monday = 1, Sunday = 7)
-		result = DatePartSpecifier::ISODOW;
-	} else if (specifier == "week" || specifier == "weeks" || specifier == "w" || specifier == "weekofyear") {
-		// ISO week number
-		result = DatePartSpecifier::WEEK;
-	} else if (specifier == "doy" || specifier == "dayofyear") {
-		// day of the year (1-365/366)
-		result = DatePartSpecifier::DOY;
-	} else if (specifier == "quarter" || specifier == "quarters") {
-		// quarter of the year (1-4)
-		result = DatePartSpecifier::QUARTER;
-	} else if (specifier == "yearweek") {
-		// Combined isoyear and isoweek YYYYWW
-		result = DatePartSpecifier::YEARWEEK;
-	} else if (specifier == "isoyear") {
-		// ISO year (first week of the year may be in previous year)
-		result = DatePartSpecifier::ISOYEAR;
-	} else if (specifier == "era") {
-		result = DatePartSpecifier::ERA;
-	} else if (specifier == "timezone") {
-		result = DatePartSpecifier::TIMEZONE;
-	} else if (specifier == "timezone_hour") {
-		result = DatePartSpecifier::TIMEZONE_HOUR;
-	} else if (specifier == "timezone_minute") {
-		result = DatePartSpecifier::TIMEZONE_MINUTE;
-	} else {
-		return false;
-	}
-	return true;
-}
-
-DatePartSpecifier GetDatePartSpecifier(const string &specifier) {
-	DatePartSpecifier result;
-	if (!TryGetDatePartSpecifier(specifier, result)) {
-		throw ConversionException("extract specifier \"%s\" not recognized", specifier);
-	}
-	return result;
-}
-
 DatePartSpecifier GetDateTypePartSpecifier(const string &specifier, LogicalType &type) {
 	const auto part = GetDatePartSpecifier(specifier);
 	switch (type.id()) {
@@ -1204,31 +1128,31 @@ static void DatePartFunction(DataChunk &args, ExpressionState &state, Vector &re
 	    });
 }
 
-void AddGenericDatePartOperator(BuiltinFunctions &set, const string &name, scalar_function_t date_func,
-                                scalar_function_t ts_func, scalar_function_t interval_func,
-                                function_statistics_t date_stats, function_statistics_t ts_stats) {
-	ScalarFunctionSet operator_set(name);
+ScalarFunctionSet GetGenericDatePartFunction(scalar_function_t date_func, scalar_function_t ts_func,
+                                             scalar_function_t interval_func, function_statistics_t date_stats,
+                                             function_statistics_t ts_stats) {
+	ScalarFunctionSet operator_set;
 	operator_set.AddFunction(
 	    ScalarFunction({LogicalType::DATE}, LogicalType::BIGINT, std::move(date_func), nullptr, nullptr, date_stats));
 	operator_set.AddFunction(
 	    ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BIGINT, std::move(ts_func), nullptr, nullptr, ts_stats));
 	operator_set.AddFunction(ScalarFunction({LogicalType::INTERVAL}, LogicalType::BIGINT, std::move(interval_func)));
-	set.AddFunction(operator_set);
+	return operator_set;
 }
 
 template <class OP>
-static void AddDatePartOperator(BuiltinFunctions &set, string name) {
-	AddGenericDatePartOperator(set, name, DatePart::UnaryFunction<date_t, int64_t, OP>,
-	                           DatePart::UnaryFunction<timestamp_t, int64_t, OP>,
-	                           ScalarFunction::UnaryFunction<interval_t, int64_t, OP>,
-	                           OP::template PropagateStatistics<date_t>, OP::template PropagateStatistics<timestamp_t>);
-}
-
-void AddGenericTimePartOperator(BuiltinFunctions &set, const string &name, scalar_function_t date_func,
-                                scalar_function_t ts_func, scalar_function_t interval_func, scalar_function_t time_func,
-                                function_statistics_t date_stats, function_statistics_t ts_stats,
-                                function_statistics_t time_stats) {
-	ScalarFunctionSet operator_set(name);
+static ScalarFunctionSet GetDatePartFunction() {
+	return GetGenericDatePartFunction(
+	    DatePart::UnaryFunction<date_t, int64_t, OP>, DatePart::UnaryFunction<timestamp_t, int64_t, OP>,
+	    ScalarFunction::UnaryFunction<interval_t, int64_t, OP>, OP::template PropagateStatistics<date_t>,
+	    OP::template PropagateStatistics<timestamp_t>);
+}
+
+ScalarFunctionSet GetGenericTimePartFunction(scalar_function_t date_func, scalar_function_t ts_func,
+                                             scalar_function_t interval_func, scalar_function_t time_func,
+                                             function_statistics_t date_stats, function_statistics_t ts_stats,
+                                             function_statistics_t time_stats) {
+	ScalarFunctionSet operator_set;
 	operator_set.AddFunction(
 	    ScalarFunction({LogicalType::DATE}, LogicalType::BIGINT, std::move(date_func), nullptr, nullptr, date_stats));
 	operator_set.AddFunction(
@@ -1236,13 +1160,13 @@ void AddGenericTimePartOperator(BuiltinFunctions &set, const string &name, scala
 	operator_set.AddFunction(ScalarFunction({LogicalType::INTERVAL}, LogicalType::BIGINT, std::move(interval_func)));
 	operator_set.AddFunction(
 	    ScalarFunction({LogicalType::TIME}, LogicalType::BIGINT, std::move(time_func), nullptr, nullptr, time_stats));
-	set.AddFunction(operator_set);
+	return operator_set;
 }
 
 template <class OP>
-static void AddTimePartOperator(BuiltinFunctions &set, string name) {
-	AddGenericTimePartOperator(
-	    set, name, DatePart::UnaryFunction<date_t, int64_t, OP>, DatePart::UnaryFunction<timestamp_t, int64_t, OP>,
+static ScalarFunctionSet GetTimePartFunction() {
+	return GetGenericTimePartFunction(
+	    DatePart::UnaryFunction<date_t, int64_t, OP>, DatePart::UnaryFunction<timestamp_t, int64_t, OP>,
 	    ScalarFunction::UnaryFunction<interval_t, int64_t, OP>, ScalarFunction::UnaryFunction<dtime_t, int64_t, OP>,
 	    OP::template PropagateStatistics<date_t>, OP::template PropagateStatistics<timestamp_t>,
 	    OP::template PropagateStatistics<dtime_t>);
@@ -1470,68 +1394,142 @@ struct StructDatePart {
 	}
 };
 
-void DatePartFun::RegisterFunction(BuiltinFunctions &set) {
-	// register the individual operators
-	AddGenericDatePartOperator(set, "year", LastYearFunction<date_t>, LastYearFunction<timestamp_t>,
-	                           ScalarFunction::UnaryFunction<interval_t, int64_t, DatePart::YearOperator>,
-	                           DatePart::YearOperator::PropagateStatistics<date_t>,
-	                           DatePart::YearOperator::PropagateStatistics<timestamp_t>);
-	AddDatePartOperator<DatePart::MonthOperator>(set, "month");
-	AddDatePartOperator<DatePart::DayOperator>(set, "day");
-	AddDatePartOperator<DatePart::DecadeOperator>(set, "decade");
-	AddDatePartOperator<DatePart::CenturyOperator>(set, "century");
-	AddDatePartOperator<DatePart::MillenniumOperator>(set, "millennium");
-	AddDatePartOperator<DatePart::QuarterOperator>(set, "quarter");
-	AddDatePartOperator<DatePart::DayOfWeekOperator>(set, "dayofweek");
-	AddDatePartOperator<DatePart::ISODayOfWeekOperator>(set, "isodow");
-	AddDatePartOperator<DatePart::DayOfYearOperator>(set, "dayofyear");
-	AddDatePartOperator<DatePart::WeekOperator>(set, "week");
-	AddDatePartOperator<DatePart::ISOYearOperator>(set, "isoyear");
-	AddDatePartOperator<DatePart::EraOperator>(set, "era");
-	AddDatePartOperator<DatePart::TimezoneOperator>(set, "timezone");
-	AddDatePartOperator<DatePart::TimezoneHourOperator>(set, "timezone_hour");
-	AddDatePartOperator<DatePart::TimezoneMinuteOperator>(set, "timezone_minute");
-	AddTimePartOperator<DatePart::EpochOperator>(set, "epoch");
-	AddTimePartOperator<DatePart::MicrosecondsOperator>(set, "microsecond");
-	AddTimePartOperator<DatePart::MillisecondsOperator>(set, "millisecond");
-	AddTimePartOperator<DatePart::SecondsOperator>(set, "second");
-	AddTimePartOperator<DatePart::MinutesOperator>(set, "minute");
-	AddTimePartOperator<DatePart::HoursOperator>(set, "hour");
-
-	//  register combinations
-	AddDatePartOperator<DatePart::YearWeekOperator>(set, "yearweek");
-
-	//  register various aliases
-	AddDatePartOperator<DatePart::DayOperator>(set, "dayofmonth");
-	AddDatePartOperator<DatePart::DayOfWeekOperator>(set, "weekday");
-	AddDatePartOperator<DatePart::WeekOperator>(set, "weekofyear"); //  Note that WeekOperator is ISO-8601, not US
-
-	//  register the last_day function
-	ScalarFunctionSet last_day("last_day");
+ScalarFunctionSet YearFun::GetFunctions() {
+	return GetGenericDatePartFunction(LastYearFunction<date_t>, LastYearFunction<timestamp_t>,
+	                                  ScalarFunction::UnaryFunction<interval_t, int64_t, DatePart::YearOperator>,
+	                                  DatePart::YearOperator::PropagateStatistics<date_t>,
+	                                  DatePart::YearOperator::PropagateStatistics<timestamp_t>);
+}
+
+ScalarFunctionSet MonthFun::GetFunctions() {
+	return GetDatePartFunction<DatePart::MonthOperator>();
+}
+
+ScalarFunctionSet DayFun::GetFunctions() {
+	return GetDatePartFunction<DatePart::DayOperator>();
+}
+
+ScalarFunctionSet DecadeFun::GetFunctions() {
+	return GetDatePartFunction<DatePart::DecadeOperator>();
+}
+
+ScalarFunctionSet CenturyFun::GetFunctions() {
+	return GetDatePartFunction<DatePart::CenturyOperator>();
+}
+
+ScalarFunctionSet MillenniumFun::GetFunctions() {
+	return GetDatePartFunction<DatePart::MillenniumOperator>();
+}
+
+ScalarFunctionSet QuarterFun::GetFunctions() {
+	return GetDatePartFunction<DatePart::QuarterOperator>();
+}
+
+ScalarFunctionSet DayOfWeekFun::GetFunctions() {
+	return GetDatePartFunction<DatePart::DayOfWeekOperator>();
+}
+
+ScalarFunctionSet ISODayOfWeekFun::GetFunctions() {
+	return GetDatePartFunction<DatePart::ISODayOfWeekOperator>();
+}
+
+ScalarFunctionSet DayOfYearFun::GetFunctions() {
+	return GetDatePartFunction<DatePart::DayOfYearOperator>();
+}
+
+ScalarFunctionSet WeekFun::GetFunctions() {
+	return GetDatePartFunction<DatePart::WeekOperator>();
+}
+
+ScalarFunctionSet ISOYearFun::GetFunctions() {
+	return GetDatePartFunction<DatePart::ISOYearOperator>();
+}
+
+ScalarFunctionSet EraFun::GetFunctions() {
+	return GetDatePartFunction<DatePart::EraOperator>();
+}
+
+ScalarFunctionSet TimezoneFun::GetFunctions() {
+	return GetDatePartFunction<DatePart::TimezoneOperator>();
+}
+
+ScalarFunctionSet TimezoneHourFun::GetFunctions() {
+	return GetDatePartFunction<DatePart::TimezoneHourOperator>();
+}
+
+ScalarFunctionSet TimezoneMinuteFun::GetFunctions() {
+	return GetDatePartFunction<DatePart::TimezoneMinuteOperator>();
+}
+
+ScalarFunctionSet EpochFun::GetFunctions() {
+	return GetTimePartFunction<DatePart::EpochOperator>();
+}
+
+ScalarFunctionSet MicrosecondsFun::GetFunctions() {
+	return GetTimePartFunction<DatePart::MicrosecondsOperator>();
+}
+
+ScalarFunctionSet MillisecondsFun::GetFunctions() {
+	return GetTimePartFunction<DatePart::MillisecondsOperator>();
+}
+
+ScalarFunctionSet SecondsFun::GetFunctions() {
+	return GetTimePartFunction<DatePart::SecondsOperator>();
+}
+
+ScalarFunctionSet MinutesFun::GetFunctions() {
+	return GetTimePartFunction<DatePart::MinutesOperator>();
+}
+
+ScalarFunctionSet HoursFun::GetFunctions() {
+	return GetTimePartFunction<DatePart::HoursOperator>();
+}
+
+ScalarFunctionSet YearWeekFun::GetFunctions() {
+	return GetDatePartFunction<DatePart::YearWeekOperator>();
+}
+
+ScalarFunctionSet DayOfMonthFun::GetFunctions() {
+	return GetDatePartFunction<DatePart::DayOperator>();
+}
+
+ScalarFunctionSet WeekDayFun::GetFunctions() {
+	return GetDatePartFunction<DatePart::DayOfWeekOperator>();
+}
+
+ScalarFunctionSet WeekOfYearFun::GetFunctions() {
+	return GetDatePartFunction<DatePart::WeekOperator>();
+}
+
+ScalarFunctionSet LastDayFun::GetFunctions() {
+	ScalarFunctionSet last_day;
 	last_day.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::DATE,
 	                                    DatePart::UnaryFunction<date_t, date_t, LastDayOperator>));
 	last_day.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::DATE,
 	                                    DatePart::UnaryFunction<timestamp_t, date_t, LastDayOperator>));
-	set.AddFunction(last_day);
+	return last_day;
+}
 
-	//  register the monthname function
-	ScalarFunctionSet monthname("monthname");
+ScalarFunctionSet MonthNameFun::GetFunctions() {
+	ScalarFunctionSet monthname;
 	monthname.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::VARCHAR,
 	                                     DatePart::UnaryFunction<date_t, string_t, MonthNameOperator>));
 	monthname.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::VARCHAR,
 	                                     DatePart::UnaryFunction<timestamp_t, string_t, MonthNameOperator>));
-	set.AddFunction(monthname);
+	return monthname;
+}
 
-	//  register the dayname function
-	ScalarFunctionSet dayname("dayname");
+ScalarFunctionSet DayNameFun::GetFunctions() {
+	ScalarFunctionSet dayname;
 	dayname.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::VARCHAR,
 	                                   DatePart::UnaryFunction<date_t, string_t, DayNameOperator>));
 	dayname.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::VARCHAR,
 	                                   DatePart::UnaryFunction<timestamp_t, string_t, DayNameOperator>));
-	set.AddFunction(dayname);
+	return dayname;
+}
 
-	// finally the actual date_part function
-	ScalarFunctionSet date_part("date_part");
+ScalarFunctionSet DatePartFun::GetFunctions() {
+	ScalarFunctionSet date_part;
 	date_part.AddFunction(
 	    ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE}, LogicalType::BIGINT, DatePartFunction<date_t>));
 	date_part.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP}, LogicalType::BIGINT,
@@ -1547,9 +1545,7 @@ void DatePartFun::RegisterFunction(BuiltinFunctions &set) {
 	date_part.AddFunction(StructDatePart::GetFunction<dtime_t>(LogicalType::TIME));
 	date_part.AddFunction(StructDatePart::GetFunction<interval_t>(LogicalType::INTERVAL));
 
-	set.AddFunction(date_part);
-	date_part.name = "datepart";
-	set.AddFunction(date_part);
+	return date_part;
 }
 
 } // namespace duckdb

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

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/date_functions.hpp"
+#include "duckdb/core_functions/scalar/date_functions.hpp"
 #include "duckdb/common/enums/date_part_specifier.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/operator/subtract.hpp"
@@ -438,7 +438,7 @@ static void DateSubFunction(DataChunk &args, ExpressionState &state, Vector &res
 	}
 }
 
-void DateSubFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunctionSet DateSubFun::GetFunctions() {
 	ScalarFunctionSet date_sub("date_sub");
 	date_sub.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE, LogicalType::DATE},
 	                                    LogicalType::BIGINT, DateSubFunction<date_t>));
@@ -446,10 +446,7 @@ void DateSubFun::RegisterFunction(BuiltinFunctions &set) {
 	                                    LogicalType::BIGINT, DateSubFunction<timestamp_t>));
 	date_sub.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIME, LogicalType::TIME},
 	                                    LogicalType::BIGINT, DateSubFunction<dtime_t>));
-	set.AddFunction(date_sub);
-
-	date_sub.name = "datesub";
-	set.AddFunction(date_sub);
+	return date_sub;
 }
 
 } // namespace duckdb

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

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/date_functions.hpp"
+#include "duckdb/core_functions/scalar/date_functions.hpp"
 #include "duckdb/common/enums/date_part_specifier.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
@@ -6,7 +6,6 @@
 #include "duckdb/common/types/time.hpp"
 #include "duckdb/common/types/timestamp.hpp"
 #include "duckdb/common/types/value.hpp"
-#include "duckdb/common/string_util.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 
 namespace duckdb {
@@ -717,7 +716,7 @@ static unique_ptr<FunctionData> DateTruncBind(ClientContext &context, ScalarFunc
 	return nullptr;
 }
 
-void DateTruncFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunctionSet DateTruncFun::GetFunctions() {
 	ScalarFunctionSet date_trunc("date_trunc");
 	date_trunc.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP}, LogicalType::TIMESTAMP,
 	                                      DateTruncFunction<timestamp_t, timestamp_t>, DateTruncBind));
@@ -725,9 +724,7 @@ void DateTruncFun::RegisterFunction(BuiltinFunctions &set) {
 	                                      DateTruncFunction<date_t, timestamp_t>, DateTruncBind));
 	date_trunc.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::INTERVAL}, LogicalType::INTERVAL,
 	                                      DateTruncFunction<interval_t, interval_t>));
-	set.AddFunction(date_trunc);
-	date_trunc.name = "datetrunc";
-	set.AddFunction(date_trunc);
+	return date_trunc;
 }
 
 } // namespace duckdb

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

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/date_functions.hpp"
+#include "duckdb/core_functions/scalar/date_functions.hpp"
 #include "duckdb/common/types/time.hpp"
 #include "duckdb/common/types/date.hpp"
 #include "duckdb/common/types/timestamp.hpp"
@@ -33,14 +33,13 @@ static void EpochMillisFunction(DataChunk &input, ExpressionState &state, Vector
 	UnaryExecutor::Execute<int64_t, timestamp_t, EpochMillisOperator>(input.data[0], result, input.size());
 }
 
-void EpochFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet epoch("epoch_ms");
-	epoch.AddFunction(ScalarFunction({LogicalType::BIGINT}, LogicalType::TIMESTAMP, EpochMillisFunction));
-	set.AddFunction(epoch);
+ScalarFunction EpochMsFun::GetFunction() {
+	return ScalarFunction({LogicalType::BIGINT}, LogicalType::TIMESTAMP, EpochMillisFunction);
+}
+
+ScalarFunction ToTimestampFun::GetFunction() {
 	// to_timestamp is an alias from Postgres that converts the time in seconds to a timestamp
-	ScalarFunctionSet to_timestamp("to_timestamp");
-	to_timestamp.AddFunction(ScalarFunction({LogicalType::BIGINT}, LogicalType::TIMESTAMP, EpochSecFunction));
-	set.AddFunction(to_timestamp);
+	return ScalarFunction({LogicalType::BIGINT}, LogicalType::TIMESTAMP, EpochSecFunction);
 }
 
 } // namespace duckdb

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

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/date_functions.hpp"
+#include "duckdb/core_functions/scalar/date_functions.hpp"
 #include "duckdb/common/types/date.hpp"
 #include "duckdb/common/types/time.hpp"
 #include "duckdb/common/types/timestamp.hpp"
@@ -79,7 +79,7 @@ static void ExecuteMakeTimestamp(DataChunk &input, ExpressionState &state, Vecto
 	SenaryExecutor::Execute<T, T, T, T, T, double, timestamp_t>(input, result, func);
 }
 
-void MakeDateFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunctionSet MakeDateFun::GetFunctions() {
 	ScalarFunctionSet make_date("make_date");
 	make_date.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT},
 	                                     LogicalType::DATE, ExecuteMakeDate<int64_t>));
@@ -88,18 +88,18 @@ void MakeDateFun::RegisterFunction(BuiltinFunctions &set) {
 	    {"year", LogicalType::BIGINT}, {"month", LogicalType::BIGINT}, {"day", LogicalType::BIGINT}};
 	make_date.AddFunction(
 	    ScalarFunction({LogicalType::STRUCT(make_date_children)}, LogicalType::DATE, ExecuteStructMakeDate<int64_t>));
-	set.AddFunction(make_date);
-
-	ScalarFunctionSet make_time("make_time");
-	make_time.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::DOUBLE},
-	                                     LogicalType::TIME, ExecuteMakeTime<int64_t>));
-	set.AddFunction(make_time);
-
-	ScalarFunctionSet make_timestamp("make_timestamp");
-	make_timestamp.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT,
-	                                           LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::DOUBLE},
-	                                          LogicalType::TIMESTAMP, ExecuteMakeTimestamp<int64_t>));
-	set.AddFunction(make_timestamp);
+	return make_date;
+}
+
+ScalarFunction MakeTimeFun::GetFunction() {
+	return ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::DOUBLE}, LogicalType::TIME,
+	                      ExecuteMakeTime<int64_t>);
+}
+
+ScalarFunction MakeTimestampFun::GetFunction() {
+	return ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT,
+	                       LogicalType::BIGINT, LogicalType::DOUBLE},
+	                      LogicalType::TIMESTAMP, ExecuteMakeTimestamp<int64_t>);
 }
 
 } // namespace duckdb