duckdb 0.7.2-dev2740.0 → 0.7.2-dev2820.0

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

package/src/duckdb/src/core_functions/core_functions.cpp

@@ -0,0 +1,50 @@
+#include "duckdb/core_functions/core_functions.hpp"
+#include "duckdb/core_functions/function_list.hpp"
+#include "duckdb/parser/parsed_data/create_aggregate_function_info.hpp"
+#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
+
+namespace duckdb {
+
+template <class T>
+void FillExtraInfo(StaticFunctionDefinition &function, T &info) {
+	info.internal = true;
+	info.description = function.description;
+	info.parameter_names = StringUtil::Split(function.parameters, ",");
+	info.example = function.example;
+}
+
+void CoreFunctions::RegisterFunctions(Catalog &catalog, CatalogTransaction transaction) {
+	auto functions = StaticFunctionDefinition::GetFunctionList();
+	for (idx_t i = 0; functions[i].name; i++) {
+		auto &function = functions[i];
+		if (function.get_function || function.get_function_set) {
+			// scalar function
+			ScalarFunctionSet result;
+			if (function.get_function) {
+				result.AddFunction(function.get_function());
+			} else {
+				result = function.get_function_set();
+			}
+			result.name = function.name;
+			CreateScalarFunctionInfo info(result);
+			FillExtraInfo(function, info);
+			catalog.CreateFunction(transaction, info);
+		} else if (function.get_aggregate_function || function.get_aggregate_function_set) {
+			// aggregate function
+			AggregateFunctionSet result;
+			if (function.get_aggregate_function) {
+				result.AddFunction(function.get_aggregate_function());
+			} else {
+				result = function.get_aggregate_function_set();
+			}
+			result.name = function.name;
+			CreateAggregateFunctionInfo info(result);
+			FillExtraInfo(function, info);
+			catalog.CreateFunction(transaction, info);
+		} else {
+			throw InternalException("Do not know how to register function of this type");
+		}
+	}
+}
+
+} // namespace duckdb