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

package/src/duckdb/src/{function → core_functions}/aggregate/algebraic/avg.cpp

@@ -1,5 +1,5 @@
-#include "duckdb/function/aggregate/algebraic_functions.hpp"
-#include "duckdb/function/aggregate/sum_helpers.hpp"
+#include "duckdb/core_functions/aggregate/algebraic_functions.hpp"
+#include "duckdb/core_functions/aggregate/sum_helpers.hpp"
 #include "duckdb/common/types/hugeint.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/function/function_set.hpp"
@@ -177,8 +177,8 @@ unique_ptr<FunctionData> BindDecimalAvg(ClientContext &context, AggregateFunctio
 	    Hugeint::Cast<double>(Hugeint::POWERS_OF_TEN[DecimalType::GetScale(decimal_type)]));
 }
 
-void AvgFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet avg("avg");
+AggregateFunctionSet AvgFun::GetFunctions() {
+	AggregateFunctionSet avg;
 
 	avg.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr,
 	                                  nullptr, nullptr, FunctionNullHandling::DEFAULT_NULL_HANDLING, nullptr,
@@ -189,15 +189,12 @@ void AvgFun::RegisterFunction(BuiltinFunctions &set) {
 	avg.AddFunction(GetAverageAggregate(PhysicalType::INT128));
 	avg.AddFunction(AggregateFunction::UnaryAggregate<AvgState<double>, double, double, NumericAverageOperation>(
 	    LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(avg);
-
-	avg.name = "mean";
-	set.AddFunction(avg);
+	return avg;
+}
 
-	AggregateFunctionSet favg("favg");
-	favg.AddFunction(AggregateFunction::UnaryAggregate<KahanAvgState, double, double, KahanAverageOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(favg);
+AggregateFunction FAvgFun::GetFunction() {
+	return AggregateFunction::UnaryAggregate<KahanAvgState, double, double, KahanAverageOperation>(LogicalType::DOUBLE,
+	                                                                                               LogicalType::DOUBLE);
 }
 
 } // namespace duckdb

package/src/duckdb/src/core_functions/aggregate/algebraic/corr.cpp

@@ -0,0 +1,13 @@
+#include "duckdb/core_functions/aggregate/algebraic_functions.hpp"
+#include "duckdb/core_functions/aggregate/algebraic/covar.hpp"
+#include "duckdb/core_functions/aggregate/algebraic/stddev.hpp"
+#include "duckdb/core_functions/aggregate/algebraic/corr.hpp"
+#include "duckdb/function/function_set.hpp"
+
+namespace duckdb {
+
+AggregateFunction CorrFun::GetFunction() {
+	return AggregateFunction::BinaryAggregate<CorrState, double, double, double, CorrOperation>(
+	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);
+}
+} // namespace duckdb

package/src/duckdb/src/core_functions/aggregate/algebraic/covar.cpp

@@ -0,0 +1,21 @@
+#include "duckdb/core_functions/aggregate/algebraic_functions.hpp"
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/types/null_value.hpp"
+#include "duckdb/common/vector_operations/vector_operations.hpp"
+#include "duckdb/function/function_set.hpp"
+#include "duckdb/core_functions/aggregate/algebraic/covar.hpp"
+#include <cmath>
+
+namespace duckdb {
+
+AggregateFunction CovarPopFun::GetFunction() {
+	return AggregateFunction::BinaryAggregate<CovarState, double, double, double, CovarPopOperation>(
+	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);
+}
+
+AggregateFunction CovarSampFun::GetFunction() {
+	return AggregateFunction::BinaryAggregate<CovarState, double, double, double, CovarSampOperation>(
+	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);
+}
+
+} // namespace duckdb

package/src/duckdb/src/core_functions/aggregate/algebraic/stddev.cpp

@@ -0,0 +1,34 @@
+#include "duckdb/core_functions/aggregate/algebraic_functions.hpp"
+#include "duckdb/common/vector_operations/vector_operations.hpp"
+#include "duckdb/function/function_set.hpp"
+#include "duckdb/core_functions/aggregate/algebraic/stddev.hpp"
+#include <cmath>
+
+namespace duckdb {
+
+AggregateFunction StdDevSampFun::GetFunction() {
+	return AggregateFunction::UnaryAggregate<StddevState, double, double, STDDevSampOperation>(LogicalType::DOUBLE,
+	                                                                                           LogicalType::DOUBLE);
+}
+
+AggregateFunction StdDevPopFun::GetFunction() {
+	return AggregateFunction::UnaryAggregate<StddevState, double, double, STDDevPopOperation>(LogicalType::DOUBLE,
+	                                                                                          LogicalType::DOUBLE);
+}
+
+AggregateFunction VarPopFun::GetFunction() {
+	return AggregateFunction::UnaryAggregate<StddevState, double, double, VarPopOperation>(LogicalType::DOUBLE,
+	                                                                                       LogicalType::DOUBLE);
+}
+
+AggregateFunction VarSampFun::GetFunction() {
+	return AggregateFunction::UnaryAggregate<StddevState, double, double, VarSampOperation>(LogicalType::DOUBLE,
+	                                                                                        LogicalType::DOUBLE);
+}
+
+AggregateFunction StandardErrorOfTheMeanFun::GetFunction() {
+	return AggregateFunction::UnaryAggregate<StddevState, double, double, StandardErrorOfTheMeanOperation>(
+	    LogicalType::DOUBLE, LogicalType::DOUBLE);
+}
+
+} // namespace duckdb

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

@@ -1,8 +1,8 @@
+#include "duckdb/core_functions/aggregate/distributive_functions.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/types/hyperloglog.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/aggregate/distributive_functions.hpp"
 #include "duckdb/function/function_set.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 
@@ -127,7 +127,7 @@ AggregateFunction GetApproxCountDistinctFunction(const LogicalType &input_type)
 	return fun;
 }
 
-void ApproxCountDistinctFun::RegisterFunction(BuiltinFunctions &set) {
+AggregateFunctionSet ApproxCountDistinctFun::GetFunctions() {
 	AggregateFunctionSet approx_count("approx_count_distinct");
 	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::UTINYINT));
 	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::USMALLINT));
@@ -142,7 +142,7 @@ void ApproxCountDistinctFun::RegisterFunction(BuiltinFunctions &set) {
 	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::VARCHAR));
 	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::TIMESTAMP));
 	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::TIMESTAMP_TZ));
-	set.AddFunction(approx_count);
+	return approx_count;
 }
 
 } // namespace duckdb

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

@@ -1,6 +1,6 @@
+#include "duckdb/core_functions/aggregate/distributive_functions.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/aggregate/distributive_functions.hpp"
 #include "duckdb/function/function_set.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/common/operator/comparison_operators.hpp"
@@ -336,32 +336,16 @@ static void AddArgMinMaxFunctions(AggregateFunctionSet &fun) {
 	AddVectorArgMinMaxFunctionBy<VECTOR_OP, Vector *>(fun, LogicalType::ANY);
 }
 
-void ArgMinFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet fun("argmin");
+AggregateFunctionSet ArgMinFun::GetFunctions() {
+	AggregateFunctionSet fun;
 	AddArgMinMaxFunctions<LessThan>(fun);
-	set.AddFunction(fun);
-
-	//! Add min_by alias
-	fun.name = "min_by";
-	set.AddFunction(fun);
-
-	//! Add arg_min alias
-	fun.name = "arg_min";
-	set.AddFunction(fun);
+	return fun;
 }
 
-void ArgMaxFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet fun("argmax");
+AggregateFunctionSet ArgMaxFun::GetFunctions() {
+	AggregateFunctionSet fun;
 	AddArgMinMaxFunctions<GreaterThan>(fun);
-	set.AddFunction(fun);
-
-	//! Add max_by alias
-	fun.name = "max_by";
-	set.AddFunction(fun);
-
-	//! Add arg_max alias
-	fun.name = "arg_max";
-	set.AddFunction(fun);
+	return fun;
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/aggregate/distributive/bitagg.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"
@@ -189,8 +189,8 @@ struct BitStringXorOperation : public BitStringBitwiseOperation {
 	}
 };
 
-void BitAndFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet bit_and("bit_and");
+AggregateFunctionSet BitAndFun::GetFunctions() {
+	AggregateFunctionSet bit_and;
 	for (auto &type : LogicalType::Integral()) {
 		bit_and.AddFunction(GetBitfieldUnaryAggregate<BitAndOperation>(type));
 	}
@@ -198,29 +198,29 @@ void BitAndFun::RegisterFunction(BuiltinFunctions &set) {
 	bit_and.AddFunction(
 	    AggregateFunction::UnaryAggregateDestructor<BitState<string_t>, string_t, string_t, BitStringAndOperation>(
 	        LogicalType::BIT, LogicalType::BIT));
-	set.AddFunction(bit_and);
+	return bit_and;
 }
 
-void BitOrFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet bit_or("bit_or");
+AggregateFunctionSet BitOrFun::GetFunctions() {
+	AggregateFunctionSet bit_or;
 	for (auto &type : LogicalType::Integral()) {
 		bit_or.AddFunction(GetBitfieldUnaryAggregate<BitOrOperation>(type));
 	}
 	bit_or.AddFunction(
 	    AggregateFunction::UnaryAggregateDestructor<BitState<string_t>, string_t, string_t, BitStringOrOperation>(
 	        LogicalType::BIT, LogicalType::BIT));
-	set.AddFunction(bit_or);
+	return bit_or;
 }
 
-void BitXorFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet bit_xor("bit_xor");
+AggregateFunctionSet BitXorFun::GetFunctions() {
+	AggregateFunctionSet bit_xor;
 	for (auto &type : LogicalType::Integral()) {
 		bit_xor.AddFunction(GetBitfieldUnaryAggregate<BitXorOperation>(type));
 	}
 	bit_xor.AddFunction(
 	    AggregateFunction::UnaryAggregateDestructor<BitState<string_t>, string_t, string_t, BitStringXorOperation>(
 	        LogicalType::BIT, LogicalType::BIT));
-	set.AddFunction(bit_xor);
+	return bit_xor;
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/aggregate/distributive/bitstring_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/aggregate_executor.hpp"
@@ -224,7 +224,7 @@ static void BindBitString(AggregateFunctionSet &bitstring_agg, const LogicalType
 	bitstring_agg.AddFunction(function);
 }
 
-void BitStringAggFun::GetBitStringAggregate(const LogicalType &type, AggregateFunctionSet &bitstring_agg) {
+void GetBitStringAggregate(const LogicalType &type, AggregateFunctionSet &bitstring_agg) {
 	switch (type.id()) {
 	case LogicalType::TINYINT: {
 		return BindBitString<int8_t>(bitstring_agg, type.id());
@@ -258,12 +258,12 @@ void BitStringAggFun::GetBitStringAggregate(const LogicalType &type, AggregateFu
 	}
 }
 
-void BitStringAggFun::RegisterFunction(BuiltinFunctions &set) {
+AggregateFunctionSet BitstringAggFun::GetFunctions() {
 	AggregateFunctionSet bitstring_agg("bitstring_agg");
 	for (auto &type : LogicalType::Integral()) {
 		GetBitStringAggregate(type, bitstring_agg);
 	}
-	set.AddFunction(bitstring_agg);
+	return bitstring_agg;
 }
 
 } // namespace duckdb

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

@@ -1,6 +1,6 @@
+#include "duckdb/core_functions/aggregate/distributive_functions.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/aggregate/distributive_functions.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/function/function_set.hpp"
 
@@ -94,7 +94,6 @@ struct BoolOrFunFunction {
 AggregateFunction BoolOrFun::GetFunction() {
 	auto fun = AggregateFunction::UnaryAggregate<BoolState, bool, bool, BoolOrFunFunction>(
 	    LogicalType(LogicalTypeId::BOOLEAN), LogicalType::BOOLEAN);
-	fun.name = "bool_or";
 	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }
@@ -102,23 +101,8 @@ AggregateFunction BoolOrFun::GetFunction() {
 AggregateFunction BoolAndFun::GetFunction() {
 	auto fun = AggregateFunction::UnaryAggregate<BoolState, bool, bool, BoolAndFunFunction>(
 	    LogicalType(LogicalTypeId::BOOLEAN), LogicalType::BOOLEAN);
-	fun.name = "bool_and";
 	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }
 
-void BoolOrFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunction bool_or_function = BoolOrFun::GetFunction();
-	AggregateFunctionSet bool_or("bool_or");
-	bool_or.AddFunction(bool_or_function);
-	set.AddFunction(bool_or);
-}
-
-void BoolAndFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunction bool_and_function = BoolAndFun::GetFunction();
-	AggregateFunctionSet bool_and("bool_and");
-	bool_and.AddFunction(bool_and_function);
-	set.AddFunction(bool_and);
-}
-
 } // namespace duckdb

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

@@ -1,9 +1,10 @@
+#include "duckdb/core_functions/aggregate/distributive_functions.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/aggregate/distributive_functions.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/function/function_set.hpp"
-#include <unordered_map>
+#include "duckdb/common/algorithm.hpp"
+#include "duckdb/common/unordered_map.hpp"
 
 namespace duckdb {
 
@@ -161,7 +162,7 @@ AggregateFunction GetEntropyFunction(PhysicalType type) {
 	return fun;
 }
 
-void EntropyFun::RegisterFunction(BuiltinFunctions &set) {
+AggregateFunctionSet EntropyFun::GetFunctions() {
 	AggregateFunctionSet entropy("entropy");
 	entropy.AddFunction(GetEntropyFunction(PhysicalType::UINT16));
 	entropy.AddFunction(GetEntropyFunction(PhysicalType::UINT32));
@@ -174,7 +175,7 @@ void EntropyFun::RegisterFunction(BuiltinFunctions &set) {
 	entropy.AddFunction(GetEntropyFunction(PhysicalType::VARCHAR));
 	entropy.AddFunction(GetEntropyFunction<int64_t, double>(LogicalType::TIMESTAMP, LogicalType::DOUBLE));
 	entropy.AddFunction(GetEntropyFunction<int64_t, double>(LogicalType::TIMESTAMP_TZ, LogicalType::DOUBLE));
-	set.AddFunction(entropy);
+	return entropy;
 }
 
 } // namespace duckdb

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

@@ -1,7 +1,8 @@
+#include "duckdb/core_functions/aggregate/distributive_functions.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/aggregate/distributive_functions.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
+#include "duckdb/common/algorithm.hpp"
 
 namespace duckdb {
 
@@ -85,11 +86,9 @@ struct KurtosisOperation {
 	}
 };
 
-void KurtosisFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet function_set("kurtosis");
-	function_set.AddFunction(AggregateFunction::UnaryAggregate<KurtosisState, double, double, KurtosisOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(function_set);
+AggregateFunction KurtosisFun::GetFunction() {
+	return AggregateFunction::UnaryAggregate<KurtosisState, double, double, KurtosisOperation>(LogicalType::DOUBLE,
+	                                                                                           LogicalType::DOUBLE);
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/aggregate/distributive/minmax.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/vector_operations/vector_operations.hpp"
 #include "duckdb/common/operator/comparison_operators.hpp"
@@ -560,16 +560,16 @@ static void AddMinMaxOperator(AggregateFunctionSet &set) {
 	                                  nullptr, BindMinMax<OP, OP_STRING, OP_VECTOR>));
 }
 
-void MinFun::RegisterFunction(BuiltinFunctions &set) {
+AggregateFunctionSet MinFun::GetFunctions() {
 	AggregateFunctionSet min("min");
 	AddMinMaxOperator<MinOperation, MinOperationString, MinOperationVector>(min);
-	set.AddFunction(min);
+	return min;
 }
 
-void MaxFun::RegisterFunction(BuiltinFunctions &set) {
+AggregateFunctionSet MaxFun::GetFunctions() {
 	AggregateFunctionSet max("max");
 	AddMinMaxOperator<MaxOperation, MaxOperationString, MaxOperationVector>(max);
-	set.AddFunction(max);
+	return max;
 }
 
 } // namespace duckdb

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

@@ -1,6 +1,6 @@
+#include "duckdb/core_functions/aggregate/distributive_functions.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/aggregate/distributive_functions.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/function/function_set.hpp"
 
@@ -54,17 +54,8 @@ struct ProductFunction {
 };
 
 AggregateFunction ProductFun::GetFunction() {
-	auto fun = AggregateFunction::UnaryAggregate<ProductState, double, double, ProductFunction>(
+	return AggregateFunction::UnaryAggregate<ProductState, double, double, ProductFunction>(
 	    LogicalType(LogicalTypeId::DOUBLE), LogicalType::DOUBLE);
-	fun.name = "product";
-	return fun;
-}
-
-void ProductFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunction product_function = ProductFun::GetFunction();
-	AggregateFunctionSet product("product");
-	product.AddFunction(product_function);
-	set.AddFunction(product);
 }
 
 } // namespace duckdb

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

@@ -1,7 +1,8 @@
+#include "duckdb/core_functions/aggregate/distributive_functions.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/aggregate/distributive_functions.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
+#include "duckdb/common/algorithm.hpp"
 
 namespace duckdb {
 
@@ -79,11 +80,9 @@ struct SkewnessOperation {
 	}
 };
 
-void SkewFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet function_set("skewness");
-	function_set.AddFunction(AggregateFunction::UnaryAggregate<SkewState, double, double, SkewnessOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(function_set);
+AggregateFunction SkewnessFun::GetFunction() {
+	return AggregateFunction::UnaryAggregate<SkewState, double, double, SkewnessOperation>(LogicalType::DOUBLE,
+	                                                                                       LogicalType::DOUBLE);
 }
 
 } // namespace duckdb

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