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

package/src/duckdb/src/{function → core_functions}/aggregate/distributive/string_agg.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/function/aggregate/distributive_functions.hpp"
+#include "duckdb/core_functions/aggregate/distributive_functions.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/types/null_value.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
@@ -151,8 +151,8 @@ unique_ptr<FunctionData> StringAggDeserialize(ClientContext &context, FieldReade
 	return make_uniq<StringAggBindData>(std::move(sep));
 }
 
-void StringAggFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet string_agg("string_agg");
+AggregateFunctionSet StringAggFun::GetFunctions() {
+	AggregateFunctionSet string_agg;
 	AggregateFunction string_agg_param(
 	    {LogicalType::VARCHAR}, LogicalType::VARCHAR, AggregateFunction::StateSize<StringAggState>,
 	    AggregateFunction::StateInitialize<StringAggState, StringAggFunction>,
@@ -166,9 +166,7 @@ void StringAggFun::RegisterFunction(BuiltinFunctions &set) {
 	string_agg.AddFunction(string_agg_param);
 	string_agg_param.arguments.emplace_back(LogicalType::VARCHAR);
 	string_agg.AddFunction(string_agg_param);
-	set.AddFunction(string_agg);
-	string_agg.name = "group_concat";
-	set.AddFunction(string_agg);
+	return string_agg;
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/aggregate/distributive/sum.cpp

@@ -1,9 +1,8 @@
-#include "duckdb/function/aggregate/distributive_functions.hpp"
-#include "duckdb/function/aggregate/sum_helpers.hpp"
+#include "duckdb/core_functions/aggregate/distributive_functions.hpp"
+#include "duckdb/core_functions/aggregate/sum_helpers.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/types/decimal.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/function/aggregate/algebraic_functions.hpp"
 
 namespace duckdb {
 
@@ -70,6 +69,27 @@ struct HugeintSumOperation : public BaseSumOperation<SumSetOperation, RegularAdd
 	}
 };
 
+AggregateFunction GetSumAggregateNoOverflow(PhysicalType type) {
+	switch (type) {
+	case PhysicalType::INT32: {
+		auto function = AggregateFunction::UnaryAggregate<SumState<int64_t>, int32_t, hugeint_t, IntegerSumOperation>(
+		    LogicalType::INTEGER, LogicalType::HUGEINT);
+		function.name = "sum_no_overflow";
+		function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
+		return function;
+	}
+	case PhysicalType::INT64: {
+		auto function = AggregateFunction::UnaryAggregate<SumState<int64_t>, int64_t, hugeint_t, IntegerSumOperation>(
+		    LogicalType::BIGINT, LogicalType::HUGEINT);
+		function.name = "sum_no_overflow";
+		function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
+		return function;
+	}
+	default:
+		throw BinderException("Unsupported internal type for sum_no_overflow");
+	}
+}
+
 unique_ptr<BaseStatistics> SumPropagateStats(ClientContext &context, BoundAggregateExpression &expr,
                                              AggregateStatisticsInput &input) {
 	if (input.node_stats && input.node_stats->has_max_cardinality) {
@@ -100,12 +120,12 @@ unique_ptr<BaseStatistics> SumPropagateStats(ClientContext &context, BoundAggreg
 			return nullptr;
 		}
 		// total sum is guaranteed to fit in a single int64: use int64 sum instead of hugeint sum
-		expr.function = SumFun::GetSumAggregateNoOverflow(internal_type);
+		expr.function = GetSumAggregateNoOverflow(internal_type);
 	}
 	return nullptr;
 }
 
-AggregateFunction SumFun::GetSumAggregate(PhysicalType type) {
+AggregateFunction GetSumAggregate(PhysicalType type) {
 	switch (type) {
 	case PhysicalType::INT16: {
 		auto function = AggregateFunction::UnaryAggregate<SumState<int64_t>, int16_t, hugeint_t, IntegerSumOperation>(
@@ -142,31 +162,10 @@ AggregateFunction SumFun::GetSumAggregate(PhysicalType type) {
 	}
 }
 
-AggregateFunction SumFun::GetSumAggregateNoOverflow(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::INT32: {
-		auto function = AggregateFunction::UnaryAggregate<SumState<int64_t>, int32_t, hugeint_t, IntegerSumOperation>(
-		    LogicalType::INTEGER, LogicalType::HUGEINT);
-		function.name = "sum_no_overflow";
-		function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-		return function;
-	}
-	case PhysicalType::INT64: {
-		auto function = AggregateFunction::UnaryAggregate<SumState<int64_t>, int64_t, hugeint_t, IntegerSumOperation>(
-		    LogicalType::BIGINT, LogicalType::HUGEINT);
-		function.name = "sum_no_overflow";
-		function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-		return function;
-	}
-	default:
-		throw BinderException("Unsupported internal type for sum_no_overflow");
-	}
-}
-
 unique_ptr<FunctionData> BindDecimalSum(ClientContext &context, AggregateFunction &function,
                                         vector<unique_ptr<Expression>> &arguments) {
 	auto decimal_type = arguments[0]->return_type;
-	function = SumFun::GetSumAggregate(decimal_type.InternalType());
+	function = GetSumAggregate(decimal_type.InternalType());
 	function.name = "sum";
 	function.arguments[0] = decimal_type;
 	function.return_type = LogicalType::DECIMAL(Decimal::MAX_WIDTH_DECIMAL, DecimalType::GetScale(decimal_type));
@@ -177,7 +176,7 @@ unique_ptr<FunctionData> BindDecimalSum(ClientContext &context, AggregateFunctio
 unique_ptr<FunctionData> BindDecimalSumNoOverflow(ClientContext &context, AggregateFunction &function,
                                                   vector<unique_ptr<Expression>> &arguments) {
 	auto decimal_type = arguments[0]->return_type;
-	function = SumFun::GetSumAggregateNoOverflow(decimal_type.InternalType());
+	function = GetSumAggregateNoOverflow(decimal_type.InternalType());
 	function.name = "sum_no_overflow";
 	function.arguments[0] = decimal_type;
 	function.return_type = LogicalType::DECIMAL(Decimal::MAX_WIDTH_DECIMAL, DecimalType::GetScale(decimal_type));
@@ -185,8 +184,8 @@ unique_ptr<FunctionData> BindDecimalSumNoOverflow(ClientContext &context, Aggreg
 	return nullptr;
 }
 
-void SumFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet sum("sum");
+AggregateFunctionSet SumFun::GetFunctions() {
+	AggregateFunctionSet sum;
 	// decimal
 	sum.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr,
 	                                  nullptr, nullptr, FunctionNullHandling::DEFAULT_NULL_HANDLING, nullptr,
@@ -197,29 +196,22 @@ void SumFun::RegisterFunction(BuiltinFunctions &set) {
 	sum.AddFunction(GetSumAggregate(PhysicalType::INT128));
 	sum.AddFunction(AggregateFunction::UnaryAggregate<SumState<double>, double, double, NumericSumOperation>(
 	    LogicalType::DOUBLE, LogicalType::DOUBLE));
+	return sum;
+}
 
-	set.AddFunction(sum);
-
-	AggregateFunctionSet sum_no_overflow("sum_no_overflow");
+AggregateFunctionSet SumNoOverflowFun::GetFunctions() {
+	AggregateFunctionSet sum_no_overflow;
 	sum_no_overflow.AddFunction(GetSumAggregateNoOverflow(PhysicalType::INT32));
 	sum_no_overflow.AddFunction(GetSumAggregateNoOverflow(PhysicalType::INT64));
 	sum_no_overflow.AddFunction(
 	    AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr, nullptr, nullptr,
 	                      FunctionNullHandling::DEFAULT_NULL_HANDLING, nullptr, BindDecimalSumNoOverflow));
-	set.AddFunction(sum_no_overflow);
-
-	// fsum
-	AggregateFunctionSet fsum("fsum");
-	fsum.AddFunction(AggregateFunction::UnaryAggregate<KahanSumState, double, double, KahanSumOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE));
-
-	set.AddFunction(fsum);
-
-	fsum.name = "kahan_sum";
-	set.AddFunction(fsum);
+	return sum_no_overflow;
+}
 
-	fsum.name = "sumKahan";
-	set.AddFunction(fsum);
+AggregateFunction KahanSumFun::GetFunction() {
+	return AggregateFunction::UnaryAggregate<KahanSumState, double, double, KahanSumOperation>(LogicalType::DOUBLE,
+	                                                                                           LogicalType::DOUBLE);
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/aggregate/holistic/approximate_quantile.cpp

@@ -1,5 +1,5 @@
 #include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/aggregate/holistic_functions.hpp"
+#include "duckdb/core_functions/aggregate/holistic_functions.hpp"
 #include "t_digest.hpp"
 #include "duckdb/planner/expression.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
@@ -350,8 +350,8 @@ AggregateFunction GetApproxQuantileListAggregate(const LogicalType &type) {
 	return fun;
 }
 
-void ApproximateQuantileFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet approx_quantile("approx_quantile");
+AggregateFunctionSet ApproxQuantileFun::GetFunctions() {
+	AggregateFunctionSet approx_quantile;
 	approx_quantile.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL, LogicalType::FLOAT}, LogicalTypeId::DECIMAL,
 	                                              nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
 	                                              BindApproxQuantileDecimal));
@@ -374,8 +374,7 @@ void ApproximateQuantileFun::RegisterFunction(BuiltinFunctions &set) {
 	approx_quantile.AddFunction(GetApproxQuantileListAggregate(LogicalTypeId::HUGEINT));
 	approx_quantile.AddFunction(GetApproxQuantileListAggregate(LogicalTypeId::FLOAT));
 	approx_quantile.AddFunction(GetApproxQuantileListAggregate(LogicalTypeId::DOUBLE));
-
-	set.AddFunction(approx_quantile);
+	return approx_quantile;
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/aggregate/holistic/mode.cpp

@@ -5,7 +5,7 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/function/aggregate/holistic_functions.hpp"
+#include "duckdb/core_functions/aggregate/holistic_functions.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/common/unordered_map.hpp"
 
@@ -318,11 +318,11 @@ unique_ptr<FunctionData> BindModeDecimal(ClientContext &context, AggregateFuncti
 	return nullptr;
 }
 
-void ModeFun::RegisterFunction(BuiltinFunctions &set) {
+AggregateFunctionSet ModeFun::GetFunctions() {
 	const vector<LogicalType> TEMPORAL = {LogicalType::DATE,         LogicalType::TIMESTAMP, LogicalType::TIME,
 	                                      LogicalType::TIMESTAMP_TZ, LogicalType::TIME_TZ,   LogicalType::INTERVAL};
 
-	AggregateFunctionSet mode("mode");
+	AggregateFunctionSet mode;
 	mode.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr,
 	                                   nullptr, nullptr, nullptr, BindModeDecimal));
 
@@ -337,7 +337,6 @@ void ModeFun::RegisterFunction(BuiltinFunctions &set) {
 	}
 
 	mode.AddFunction(GetModeAggregate(LogicalType::VARCHAR));
-
-	set.AddFunction(mode);
+	return mode;
 }
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/aggregate/holistic/quantile.cpp

@@ -1,5 +1,5 @@
 #include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/aggregate/holistic_functions.hpp"
+#include "duckdb/core_functions/aggregate/holistic_functions.hpp"
 #include "duckdb/planner/expression.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
 #include "duckdb/common/operator/abs.hpp"
@@ -1375,24 +1375,39 @@ AggregateFunction GetQuantileDecimalAggregate(const vector<LogicalType> &argumen
 	return fun;
 }
 
-void QuantileFun::RegisterFunction(BuiltinFunctions &set) {
-	const vector<LogicalType> QUANTILES = {LogicalType::TINYINT,  LogicalType::SMALLINT,     LogicalType::INTEGER,
-	                                       LogicalType::BIGINT,   LogicalType::HUGEINT,      LogicalType::FLOAT,
-	                                       LogicalType::DOUBLE,   LogicalType::DATE,         LogicalType::TIMESTAMP,
-	                                       LogicalType::TIME,     LogicalType::TIMESTAMP_TZ, LogicalType::TIME_TZ,
-	                                       LogicalType::INTERVAL, LogicalType::VARCHAR};
+vector<LogicalType> GetQuantileTypes() {
+	return {LogicalType::TINYINT,   LogicalType::SMALLINT, LogicalType::INTEGER,      LogicalType::BIGINT,
+	        LogicalType::HUGEINT,   LogicalType::FLOAT,    LogicalType::DOUBLE,       LogicalType::DATE,
+	        LogicalType::TIMESTAMP, LogicalType::TIME,     LogicalType::TIMESTAMP_TZ, LogicalType::TIME_TZ,
+	        LogicalType::INTERVAL,  LogicalType::VARCHAR};
+}
 
+AggregateFunctionSet MedianFun::GetFunctions() {
 	AggregateFunctionSet median("median");
 	median.AddFunction(
 	    GetQuantileDecimalAggregate({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, BindMedianDecimal));
+	for (const auto &type : GetQuantileTypes()) {
+		median.AddFunction(GetMedianAggregate(type));
+	}
+	return median;
+}
 
+AggregateFunctionSet QuantileDiscFun::GetFunctions() {
 	AggregateFunctionSet quantile_disc("quantile_disc");
 	quantile_disc.AddFunction(GetQuantileDecimalAggregate({LogicalTypeId::DECIMAL, LogicalType::DOUBLE},
 	                                                      LogicalTypeId::DECIMAL, BindDiscreteQuantileDecimal));
 	quantile_disc.AddFunction(
 	    GetQuantileDecimalAggregate({LogicalTypeId::DECIMAL, LogicalType::LIST(LogicalType::DOUBLE)},
 	                                LogicalType::LIST(LogicalTypeId::DECIMAL), BindDiscreteQuantileDecimalList));
+	for (const auto &type : GetQuantileTypes()) {
+		quantile_disc.AddFunction(GetDiscreteQuantileAggregate(type));
+		quantile_disc.AddFunction(GetDiscreteQuantileListAggregate(type));
+	}
+	return quantile_disc;
+	// quantile
+}
 
+AggregateFunctionSet QuantileContFun::GetFunctions() {
 	AggregateFunctionSet quantile_cont("quantile_cont");
 	quantile_cont.AddFunction(GetQuantileDecimalAggregate({LogicalTypeId::DECIMAL, LogicalType::DOUBLE},
 	                                                      LogicalTypeId::DECIMAL, BindContinuousQuantileDecimal));
@@ -1400,34 +1415,27 @@ void QuantileFun::RegisterFunction(BuiltinFunctions &set) {
 	    GetQuantileDecimalAggregate({LogicalTypeId::DECIMAL, LogicalType::LIST(LogicalType::DOUBLE)},
 	                                LogicalType::LIST(LogicalTypeId::DECIMAL), BindContinuousQuantileDecimalList));
 
-	for (const auto &type : QUANTILES) {
-		median.AddFunction(GetMedianAggregate(type));
-		quantile_disc.AddFunction(GetDiscreteQuantileAggregate(type));
-		quantile_disc.AddFunction(GetDiscreteQuantileListAggregate(type));
+	for (const auto &type : GetQuantileTypes()) {
 		if (CanInterpolate(type)) {
 			quantile_cont.AddFunction(GetContinuousQuantileAggregate(type));
 			quantile_cont.AddFunction(GetContinuousQuantileListAggregate(type));
 		}
 	}
+	return quantile_cont;
+}
 
-	set.AddFunction(median);
-	set.AddFunction(quantile_disc);
-	set.AddFunction(quantile_cont);
-
-	quantile_disc.name = "quantile";
-	set.AddFunction(quantile_disc);
-
+AggregateFunctionSet MadFun::GetFunctions() {
 	AggregateFunctionSet mad("mad");
 	mad.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr,
 	                                  nullptr, nullptr, nullptr, BindMedianAbsoluteDeviationDecimal));
 
-	const vector<LogicalType> MADS = {LogicalType::FLOAT,     LogicalType::DOUBLE, LogicalType::DATE,
-	                                  LogicalType::TIMESTAMP, LogicalType::TIME,   LogicalType::TIMESTAMP_TZ,
-	                                  LogicalType::TIME_TZ};
-	for (const auto &type : MADS) {
+	const vector<LogicalType> MAD_TYPES = {LogicalType::FLOAT,     LogicalType::DOUBLE, LogicalType::DATE,
+	                                       LogicalType::TIMESTAMP, LogicalType::TIME,   LogicalType::TIMESTAMP_TZ,
+	                                       LogicalType::TIME_TZ};
+	for (const auto &type : MAD_TYPES) {
 		mad.AddFunction(GetMedianAbsoluteDeviationAggregateFunction(type));
 	}
-	set.AddFunction(mad);
+	return mad;
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/aggregate/holistic/reservoir_quantile.cpp

@@ -1,6 +1,6 @@
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/execution/reservoir_sample.hpp"
-#include "duckdb/function/aggregate/holistic_functions.hpp"
+#include "duckdb/core_functions/aggregate/holistic_functions.hpp"
 #include "duckdb/planner/expression.hpp"
 #include "duckdb/common/queue.hpp"
 #include "duckdb/common/field_writer.hpp"
@@ -452,8 +452,8 @@ static void GetReservoirQuantileDecimalFunction(AggregateFunctionSet &set, const
 	set.AddFunction(fun);
 }
 
-void ReservoirQuantileFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet reservoir_quantile("reservoir_quantile");
+AggregateFunctionSet ReservoirQuantileFun::GetFunctions() {
+	AggregateFunctionSet reservoir_quantile;
 
 	// DECIMAL
 	GetReservoirQuantileDecimalFunction(reservoir_quantile, {LogicalTypeId::DECIMAL, LogicalType::DOUBLE},
@@ -469,8 +469,7 @@ void ReservoirQuantileFun::RegisterFunction(BuiltinFunctions &set) {
 	DefineReservoirQuantile(reservoir_quantile, LogicalTypeId::HUGEINT);
 	DefineReservoirQuantile(reservoir_quantile, LogicalTypeId::FLOAT);
 	DefineReservoirQuantile(reservoir_quantile, LogicalTypeId::DOUBLE);
-
-	set.AddFunction(reservoir_quantile);
+	return reservoir_quantile;
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/aggregate/nested/histogram.cpp

@@ -1,5 +1,5 @@
 #include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/function/aggregate/nested_functions.hpp"
+#include "duckdb/core_functions/aggregate/nested_functions.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/common/pair.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
@@ -233,8 +233,8 @@ AggregateFunction GetHistogramFunction(const LogicalType &type) {
 	}
 }
 
-void HistogramFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet fun("histogram");
+AggregateFunctionSet HistogramFun::GetFunctions() {
+	AggregateFunctionSet fun;
 	fun.AddFunction(GetHistogramFunction<>(LogicalType::BOOLEAN));
 	fun.AddFunction(GetHistogramFunction<>(LogicalType::UTINYINT));
 	fun.AddFunction(GetHistogramFunction<>(LogicalType::USMALLINT));
@@ -255,7 +255,7 @@ void HistogramFun::RegisterFunction(BuiltinFunctions &set) {
 	fun.AddFunction(GetHistogramFunction<>(LogicalType::TIME));
 	fun.AddFunction(GetHistogramFunction<>(LogicalType::TIME_TZ));
 	fun.AddFunction(GetHistogramFunction<>(LogicalType::DATE));
-	set.AddFunction(fun);
+	return fun;
 }
 
 AggregateFunction HistogramFun::GetHistogramUnorderedMap(LogicalType &type) {

package/src/duckdb/src/{function → core_functions}/aggregate/nested/list.cpp

@@ -1,6 +1,6 @@
 #include "duckdb/common/pair.hpp"
 #include "duckdb/common/types/list_segment.hpp"
-#include "duckdb/function/aggregate/nested_functions.hpp"
+#include "duckdb/core_functions/aggregate/nested_functions.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 
 namespace duckdb {
@@ -180,15 +180,11 @@ unique_ptr<FunctionData> ListBindFunction(ClientContext &context, AggregateFunct
 	return make_uniq<ListBindData>(function.return_type);
 }
 
-void ListFun::RegisterFunction(BuiltinFunctions &set) {
-	auto agg =
-	    AggregateFunction("list", {LogicalType::ANY}, LogicalTypeId::LIST, AggregateFunction::StateSize<ListAggState>,
-	                      AggregateFunction::StateInitialize<ListAggState, ListFunction>, ListUpdateFunction,
-	                      ListCombineFunction, ListFinalize, nullptr, ListBindFunction,
-	                      AggregateFunction::StateDestroy<ListAggState, ListFunction>, nullptr, nullptr);
-	set.AddFunction(agg);
-	agg.name = "array_agg";
-	set.AddFunction(agg);
+AggregateFunction ListFun::GetFunction() {
+	return AggregateFunction({LogicalType::ANY}, LogicalTypeId::LIST, AggregateFunction::StateSize<ListAggState>,
+	                         AggregateFunction::StateInitialize<ListAggState, ListFunction>, ListUpdateFunction,
+	                         ListCombineFunction, ListFinalize, nullptr, ListBindFunction,
+	                         AggregateFunction::StateDestroy<ListAggState, ListFunction>, nullptr, nullptr);
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/aggregate/regression/regr_avg.cpp

@@ -1,6 +1,6 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/aggregate/regression_functions.hpp"
+#include "duckdb/core_functions/aggregate/regression_functions.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/function/function_set.hpp"
 
@@ -53,18 +53,14 @@ struct RegrAvgYFunction : RegrAvgFunction {
 	}
 };
 
-void RegrAvgxFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet corr("regr_avgx");
-	corr.AddFunction(AggregateFunction::BinaryAggregate<RegrState, double, double, double, RegrAvgXFunction>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(corr);
+AggregateFunction RegrAvgxFun::GetFunction() {
+	return AggregateFunction::BinaryAggregate<RegrState, double, double, double, RegrAvgXFunction>(
+	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);
 }
 
-void RegrAvgyFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet corr("regr_avgy");
-	corr.AddFunction(AggregateFunction::BinaryAggregate<RegrState, double, double, double, RegrAvgYFunction>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(corr);
+AggregateFunction RegrAvgyFun::GetFunction() {
+	return AggregateFunction::BinaryAggregate<RegrState, double, double, double, RegrAvgYFunction>(
+	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/aggregate/regression/regr_count.cpp

@@ -1,18 +1,18 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/aggregate/regression_functions.hpp"
+#include "duckdb/core_functions/aggregate/regression_functions.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/function/aggregate/regression/regr_count.hpp"
+#include "duckdb/core_functions/aggregate/regression/regr_count.hpp"
 #include "duckdb/function/function_set.hpp"
 
 namespace duckdb {
 
-void RegrCountFun::RegisterFunction(BuiltinFunctions &set) {
+AggregateFunction RegrCountFun::GetFunction() {
 	auto regr_count = AggregateFunction::BinaryAggregate<size_t, double, double, uint32_t, RegrCountFunction>(
 	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::UINTEGER);
 	regr_count.name = "regr_count";
 	regr_count.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction(regr_count);
+	return regr_count;
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/aggregate/regression/regr_intercept.cpp

@@ -1,7 +1,7 @@
 //! AVG(y)-REGR_SLOPE(y,x)*AVG(x)
 
-#include "duckdb/function/aggregate/regression_functions.hpp"
-#include "duckdb/function/aggregate/regression/regr_slope.hpp"
+#include "duckdb/core_functions/aggregate/regression_functions.hpp"
+#include "duckdb/core_functions/aggregate/regression/regr_slope.hpp"
 #include "duckdb/function/function_set.hpp"
 
 namespace duckdb {
@@ -58,12 +58,9 @@ struct RegrInterceptOperation {
 	}
 };
 
-void RegrInterceptFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet fun("regr_intercept");
-	fun.AddFunction(
-	    AggregateFunction::BinaryAggregate<RegrInterceptState, double, double, double, RegrInterceptOperation>(
-	        LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(fun);
+AggregateFunction RegrInterceptFun::GetFunction() {
+	return AggregateFunction::BinaryAggregate<RegrInterceptState, double, double, double, RegrInterceptOperation>(
+	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/aggregate/regression/regr_r2.cpp

@@ -4,9 +4,9 @@
 // 1                    if var_pop(y) = 0 and var_pop(x) <> 0, else
 // power(corr(y,x), 2)
 
-#include "duckdb/function/aggregate/algebraic/corr.hpp"
+#include "duckdb/core_functions/aggregate/algebraic/corr.hpp"
 #include "duckdb/function/function_set.hpp"
-#include "duckdb/function/aggregate/regression_functions.hpp"
+#include "duckdb/core_functions/aggregate/regression_functions.hpp"
 
 namespace duckdb {
 struct RegrR2State {
@@ -69,10 +69,8 @@ struct RegrR2Operation {
 	}
 };
 
-void RegrR2Fun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet fun("regr_r2");
-	fun.AddFunction(AggregateFunction::BinaryAggregate<RegrR2State, double, double, double, RegrR2Operation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(fun);
+AggregateFunction RegrR2Fun::GetFunction() {
+	return AggregateFunction::BinaryAggregate<RegrR2State, double, double, double, RegrR2Operation>(
+	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);
 }
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/aggregate/regression/regr_slope.cpp

@@ -6,17 +6,15 @@
 //! Input : Any numeric type
 //! Output : Double
 
-#include "duckdb/function/aggregate/regression/regr_slope.hpp"
+#include "duckdb/core_functions/aggregate/regression/regr_slope.hpp"
 #include "duckdb/function/function_set.hpp"
-#include "duckdb/function/aggregate/regression_functions.hpp"
+#include "duckdb/core_functions/aggregate/regression_functions.hpp"
 
 namespace duckdb {
 
-void RegrSlopeFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet fun("regr_slope");
-	fun.AddFunction(AggregateFunction::BinaryAggregate<RegrSlopeState, double, double, double, RegrSlopeOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(fun);
+AggregateFunction RegrSlopeFun::GetFunction() {
+	return AggregateFunction::BinaryAggregate<RegrSlopeState, double, double, double, RegrSlopeOperation>(
+	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/aggregate/regression/regr_sxx_syy.cpp

@@ -3,9 +3,9 @@
 // regrsyy
 // Returns REGR_COUNT(y, x) * VAR_POP(y) for non-null pairs.
 
-#include "duckdb/function/aggregate/regression/regr_count.hpp"
+#include "duckdb/core_functions/aggregate/regression/regr_count.hpp"
 #include "duckdb/function/function_set.hpp"
-#include "duckdb/function/aggregate/regression_functions.hpp"
+#include "duckdb/core_functions/aggregate/regression_functions.hpp"
 
 namespace duckdb {
 
@@ -67,18 +67,14 @@ struct RegrSYYOperation : RegrBaseOperation {
 	}
 };
 
-void RegrSXXFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet fun("regr_sxx");
-	fun.AddFunction(AggregateFunction::BinaryAggregate<RegrSState, double, double, double, RegrSXXOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(fun);
+AggregateFunction RegrSXXFun::GetFunction() {
+	return AggregateFunction::BinaryAggregate<RegrSState, double, double, double, RegrSXXOperation>(
+	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);
 }
 
-void RegrSYYFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet fun("regr_syy");
-	fun.AddFunction(AggregateFunction::BinaryAggregate<RegrSState, double, double, double, RegrSYYOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(fun);
+AggregateFunction RegrSYYFun::GetFunction() {
+	return AggregateFunction::BinaryAggregate<RegrSState, double, double, double, RegrSYYOperation>(
+	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/aggregate/regression/regr_sxy.cpp

@@ -1,8 +1,8 @@
 // Returns REGR_COUNT(expr1, expr2) * COVAR_POP(expr1, expr2) for non-null pairs.
 
-#include "duckdb/function/aggregate/regression/regr_count.hpp"
-#include "duckdb/function/aggregate/algebraic/covar.hpp"
-#include "duckdb/function/aggregate/regression_functions.hpp"
+#include "duckdb/core_functions/aggregate/regression/regr_count.hpp"
+#include "duckdb/core_functions/aggregate/algebraic/covar.hpp"
+#include "duckdb/core_functions/aggregate/regression_functions.hpp"
 #include "duckdb/function/function_set.hpp"
 
 namespace duckdb {
@@ -48,11 +48,9 @@ struct RegrSXYOperation {
 	}
 };
 
-void RegrSXYFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet fun("regr_sxy");
-	fun.AddFunction(AggregateFunction::BinaryAggregate<RegrSXyState, double, double, double, RegrSXYOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(fun);
+AggregateFunction RegrSXYFun::GetFunction() {
+	return AggregateFunction::BinaryAggregate<RegrSXyState, double, double, double, RegrSXYOperation>(
+	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);
 }
 
 } // namespace duckdb