duckdb 0.7.2-dev314.0 → 0.7.2-dev3154.0

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,16 +120,17 @@ 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>(
 		    LogicalType::SMALLINT, LogicalType::HUGEINT);
+		function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 		return function;
 	}
 
@@ -118,6 +139,7 @@ AggregateFunction SumFun::GetSumAggregate(PhysicalType type) {
 		    AggregateFunction::UnaryAggregate<SumState<hugeint_t>, int32_t, hugeint_t, SumToHugeintOperation>(
 		        LogicalType::INTEGER, LogicalType::HUGEINT);
 		function.statistics = SumPropagateStats;
+		function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 		return function;
 	}
 	case PhysicalType::INT64: {
@@ -125,12 +147,14 @@ AggregateFunction SumFun::GetSumAggregate(PhysicalType type) {
 		    AggregateFunction::UnaryAggregate<SumState<hugeint_t>, int64_t, hugeint_t, SumToHugeintOperation>(
 		        LogicalType::BIGINT, LogicalType::HUGEINT);
 		function.statistics = SumPropagateStats;
+		function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 		return function;
 	}
 	case PhysicalType::INT128: {
 		auto function =
 		    AggregateFunction::UnaryAggregate<SumState<hugeint_t>, hugeint_t, hugeint_t, HugeintSumOperation>(
 		        LogicalType::HUGEINT, LogicalType::HUGEINT);
+		function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 		return function;
 	}
 	default:
@@ -138,47 +162,30 @@ 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";
-		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";
-		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));
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return nullptr;
 }
 
 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));
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	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,
@@ -189,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"
@@ -24,11 +24,11 @@ struct ApproximateQuantileBindData : public FunctionData {
 	}
 
 	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<ApproximateQuantileBindData>(quantiles);
+		return make_uniq<ApproximateQuantileBindData>(quantiles);
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (ApproximateQuantileBindData &)other_p;
+		auto &other = other_p.Cast<ApproximateQuantileBindData>();
 		//		return quantiles == other.quantiles;
 		if (quantiles != other.quantiles) {
 			return false;
@@ -45,7 +45,7 @@ struct ApproximateQuantileBindData : public FunctionData {
 	static unique_ptr<FunctionData> Deserialize(ClientContext &context, FieldReader &reader,
 	                                            AggregateFunction &bound_function) {
 		auto quantiles = reader.ReadRequiredList<float>();
-		return make_unique<ApproximateQuantileBindData>(std::move(quantiles));
+		return make_uniq<ApproximateQuantileBindData>(std::move(quantiles));
 	}
 
 	vector<float> quantiles;
@@ -70,11 +70,14 @@ struct ApproxQuantileOperation {
 
 	template <class INPUT_TYPE, class STATE, class OP>
 	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
+		auto val = Cast::template Operation<INPUT_TYPE, SAVE_TYPE>(data[idx]);
+		if (!Value::DoubleIsFinite(val)) {
+			return;
+		}
 		if (!state->h) {
 			state->h = new duckdb_tdigest::TDigest(100);
 		}
-
-		state->h->add(Cast::template Operation<INPUT_TYPE, SAVE_TYPE>(data[idx]));
+		state->h->add(val);
 		state->pos++;
 	}
 
@@ -92,7 +95,7 @@ struct ApproxQuantileOperation {
 	}
 
 	template <class STATE>
-	static void Destroy(STATE *state) {
+	static void Destroy(AggregateInputData &aggr_input_data, STATE *state) {
 		if (state->h) {
 			delete state->h;
 		}
@@ -182,7 +185,7 @@ unique_ptr<FunctionData> BindApproxQuantile(ClientContext &context, AggregateFun
 
 	// remove the quantile argument so we can use the unary aggregate
 	Function::EraseArgument(function, arguments, arguments.size() - 1);
-	return make_unique<ApproximateQuantileBindData>(quantiles);
+	return make_uniq<ApproximateQuantileBindData>(quantiles);
 }
 
 unique_ptr<FunctionData> BindApproxQuantileDecimal(ClientContext &context, AggregateFunction &function,
@@ -347,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));
@@ -371,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"
 
@@ -176,7 +176,7 @@ struct ModeFunction {
 		}
 		auto highest_frequency = state->Scan();
 		if (highest_frequency != state->frequency_map->end()) {
-			target[idx] = INPUT_TYPE(highest_frequency->first);
+			target[idx] = ASSIGN_OP::template Assign<INPUT_TYPE, INPUT_TYPE>(result, highest_frequency->first);
 		} else {
 			mask.SetInvalid(idx);
 		}
@@ -260,7 +260,7 @@ struct ModeFunction {
 	}
 
 	template <class STATE>
-	static void Destroy(STATE *state) {
+	static void Destroy(AggregateInputData &aggr_input_data, STATE *state) {
 		state->Destroy();
 	}
 };
@@ -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"
@@ -42,14 +42,14 @@ struct QuantileState {
 	using SaveType = SAVE_TYPE;
 
 	// Regular aggregation
-	std::vector<SaveType> v;
+	vector<SaveType> v;
 
 	// Windowed Quantile indirection
-	std::vector<idx_t> w;
+	vector<idx_t> w;
 	idx_t pos;
 
 	// Windowed MAD indirection
-	std::vector<idx_t> m;
+	vector<idx_t> m;
 
 	QuantileState() : pos(0) {
 	}
@@ -414,7 +414,7 @@ struct QuantileBindData : public FunctionData {
 		size_t pos = 0;
 		size_t neg = 0;
 		for (idx_t i = 0; i < quantiles_p.size(); ++i) {
-			const auto q = quantiles_p[i];
+			const auto &q = quantiles_p[i];
 			pos += (q > 0);
 			neg += (q < 0);
 			quantiles.emplace_back(QuantileAbs(q));
@@ -436,11 +436,11 @@ struct QuantileBindData : public FunctionData {
 	}
 
 	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<QuantileBindData>(*this);
+		return make_uniq<QuantileBindData>(*this);
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (QuantileBindData &)other_p;
+		auto &other = other_p.Cast<QuantileBindData>();
 		return desc == other.desc && quantiles == other.quantiles && order == other.order;
 	}
 
@@ -477,7 +477,7 @@ struct QuantileOperation {
 	}
 
 	template <class STATE>
-	static void Destroy(STATE *state) {
+	static void Destroy(AggregateInputData &aggr_input_data, STATE *state) {
 		state->~STATE();
 	}
 
@@ -795,6 +795,7 @@ AggregateFunction GetTypedDiscreteQuantileListAggregateFunction(const LogicalTyp
 	using STATE = QuantileState<SAVE_TYPE>;
 	using OP = QuantileListOperation<INPUT_TYPE, true>;
 	auto fun = QuantileListAggregate<STATE, INPUT_TYPE, list_entry_t, OP>(type, type);
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	fun.window = AggregateFunction::UnaryWindow<STATE, INPUT_TYPE, list_entry_t, OP>;
 	return fun;
 }
@@ -851,6 +852,7 @@ AggregateFunction GetTypedContinuousQuantileAggregateFunction(const LogicalType
 	using STATE = QuantileState<INPUT_TYPE>;
 	using OP = QuantileScalarOperation<false>;
 	auto fun = AggregateFunction::UnaryAggregateDestructor<STATE, INPUT_TYPE, TARGET_TYPE, OP>(input_type, target_type);
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	fun.window = AggregateFunction::UnaryWindow<STATE, INPUT_TYPE, TARGET_TYPE, OP>;
 	return fun;
 }
@@ -904,6 +906,7 @@ AggregateFunction GetTypedContinuousQuantileListAggregateFunction(const LogicalT
 	using STATE = QuantileState<INPUT_TYPE>;
 	using OP = QuantileListOperation<CHILD_TYPE, false>;
 	auto fun = QuantileListAggregate<STATE, INPUT_TYPE, list_entry_t, OP>(input_type, result_type);
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	fun.window = AggregateFunction::UnaryWindow<STATE, INPUT_TYPE, list_entry_t, OP>;
 	return fun;
 }
@@ -1129,6 +1132,7 @@ AggregateFunction GetTypedMedianAbsoluteDeviationAggregateFunction(const Logical
 	using STATE = QuantileState<INPUT_TYPE>;
 	using OP = MedianAbsoluteDeviationOperation<MEDIAN_TYPE>;
 	auto fun = AggregateFunction::UnaryAggregateDestructor<STATE, INPUT_TYPE, TARGET_TYPE, OP>(input_type, target_type);
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	fun.window = AggregateFunction::UnaryWindow<STATE, INPUT_TYPE, TARGET_TYPE, OP>;
 	return fun;
 }
@@ -1182,12 +1186,12 @@ static void QuantileSerialize(FieldWriter &writer, const FunctionData *bind_data
 unique_ptr<FunctionData> QuantileDeserialize(ClientContext &context, FieldReader &reader,
                                              AggregateFunction &bound_function) {
 	auto quantiles = reader.ReadRequiredList<Value>();
-	return make_unique<QuantileBindData>(std::move(quantiles));
+	return make_uniq<QuantileBindData>(std::move(quantiles));
 }
 
 unique_ptr<FunctionData> BindMedian(ClientContext &context, AggregateFunction &function,
                                     vector<unique_ptr<Expression>> &arguments) {
-	return make_unique<QuantileBindData>(Value::DECIMAL(int16_t(5), 2, 1));
+	return make_uniq<QuantileBindData>(Value::DECIMAL(int16_t(5), 2, 1));
 }
 
 unique_ptr<FunctionData> BindMedianDecimal(ClientContext &context, AggregateFunction &function,
@@ -1198,6 +1202,7 @@ unique_ptr<FunctionData> BindMedianDecimal(ClientContext &context, AggregateFunc
 	function.name = "median";
 	function.serialize = QuantileSerialize;
 	function.deserialize = QuantileDeserialize;
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
 
@@ -1205,6 +1210,7 @@ unique_ptr<FunctionData> BindMedianAbsoluteDeviationDecimal(ClientContext &conte
                                                             vector<unique_ptr<Expression>> &arguments) {
 	function = GetMedianAbsoluteDeviationAggregateFunction(arguments[0]->return_type);
 	function.name = "mad";
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return nullptr;
 }
 
@@ -1242,7 +1248,7 @@ unique_ptr<FunctionData> BindQuantile(ClientContext &context, AggregateFunction
 	}
 
 	Function::EraseArgument(function, arguments, arguments.size() - 1);
-	return make_unique<QuantileBindData>(quantiles);
+	return make_uniq<QuantileBindData>(quantiles);
 }
 
 static void QuantileDecimalSerialize(FieldWriter &writer, const FunctionData *bind_data_p,
@@ -1257,6 +1263,7 @@ unique_ptr<FunctionData> BindDiscreteQuantileDecimal(ClientContext &context, Agg
 	function.name = "quantile_disc";
 	function.serialize = QuantileDecimalSerialize;
 	function.deserialize = QuantileDeserialize;
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
 
@@ -1267,6 +1274,7 @@ unique_ptr<FunctionData> BindDiscreteQuantileDecimalList(ClientContext &context,
 	function.name = "quantile_disc";
 	function.serialize = QuantileDecimalSerialize;
 	function.deserialize = QuantileDeserialize;
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
 
@@ -1277,6 +1285,7 @@ unique_ptr<FunctionData> BindContinuousQuantileDecimal(ClientContext &context, A
 	function.name = "quantile_cont";
 	function.serialize = QuantileDecimalSerialize;
 	function.deserialize = QuantileDeserialize;
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
 
@@ -1287,6 +1296,7 @@ unique_ptr<FunctionData> BindContinuousQuantileDecimalList(ClientContext &contex
 	function.name = "quantile_cont";
 	function.serialize = QuantileDecimalSerialize;
 	function.deserialize = QuantileDeserialize;
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
 
@@ -1316,6 +1326,7 @@ AggregateFunction GetDiscreteQuantileAggregate(const LogicalType &type) {
 	fun.deserialize = QuantileDeserialize;
 	// temporarily push an argument so we can bind the actual quantile
 	fun.arguments.emplace_back(LogicalType::DOUBLE);
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }
 
@@ -1327,6 +1338,7 @@ AggregateFunction GetDiscreteQuantileListAggregate(const LogicalType &type) {
 	// temporarily push an argument so we can bind the actual quantile
 	auto list_of_double = LogicalType::LIST(LogicalType::DOUBLE);
 	fun.arguments.push_back(list_of_double);
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }
 
@@ -1337,6 +1349,7 @@ AggregateFunction GetContinuousQuantileAggregate(const LogicalType &type) {
 	fun.deserialize = QuantileDeserialize;
 	// temporarily push an argument so we can bind the actual quantile
 	fun.arguments.emplace_back(LogicalType::DOUBLE);
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }
 
@@ -1348,6 +1361,7 @@ AggregateFunction GetContinuousQuantileListAggregate(const LogicalType &type) {
 	// temporarily push an argument so we can bind the actual quantile
 	auto list_of_double = LogicalType::LIST(LogicalType::DOUBLE);
 	fun.arguments.push_back(list_of_double);
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }
 
@@ -1357,27 +1371,43 @@ AggregateFunction GetQuantileDecimalAggregate(const vector<LogicalType> &argumen
 	fun.bind = bind;
 	fun.serialize = QuantileSerialize;
 	fun.deserialize = QuantileDeserialize;
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	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));
@@ -1385,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"
@@ -56,11 +56,11 @@ struct ReservoirQuantileBindData : public FunctionData {
 	}
 
 	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<ReservoirQuantileBindData>(quantiles, sample_size);
+		return make_uniq<ReservoirQuantileBindData>(quantiles, sample_size);
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (ReservoirQuantileBindData &)other_p;
+		auto &other = other_p.Cast<ReservoirQuantileBindData>();
 		return quantiles == other.quantiles && sample_size == other.sample_size;
 	}
 
@@ -75,7 +75,7 @@ struct ReservoirQuantileBindData : public FunctionData {
 	                                            AggregateFunction &bound_function) {
 		auto quantiles = reader.ReadRequiredList<double>();
 		auto sample_size = reader.ReadRequired<int32_t>();
-		return make_unique<ReservoirQuantileBindData>(std::move(quantiles), sample_size);
+		return make_uniq<ReservoirQuantileBindData>(std::move(quantiles), sample_size);
 	}
 
 	vector<double> quantiles;
@@ -131,7 +131,7 @@ struct ReservoirQuantileOperation {
 	}
 
 	template <class STATE>
-	static void Destroy(STATE *state) {
+	static void Destroy(AggregateInputData &aggr_input_data, STATE *state) {
 		if (state->v) {
 			free(state->v);
 			state->v = nullptr;
@@ -362,7 +362,7 @@ unique_ptr<FunctionData> BindReservoirQuantile(ClientContext &context, Aggregate
 		} else {
 			arguments.pop_back();
 		}
-		return make_unique<ReservoirQuantileBindData>(quantiles, 8192);
+		return make_uniq<ReservoirQuantileBindData>(quantiles, 8192);
 	}
 	if (!arguments[2]->IsFoldable()) {
 		throw BinderException("RESERVOIR_QUANTILE can only take constant sample size parameters");
@@ -380,7 +380,7 @@ unique_ptr<FunctionData> BindReservoirQuantile(ClientContext &context, Aggregate
 	// remove the quantile argument so we can use the unary aggregate
 	Function::EraseArgument(function, arguments, arguments.size() - 1);
 	Function::EraseArgument(function, arguments, arguments.size() - 1);
-	return make_unique<ReservoirQuantileBindData>(quantiles, sample_size);
+	return make_uniq<ReservoirQuantileBindData>(quantiles, sample_size);
 }
 
 unique_ptr<FunctionData> BindReservoirQuantileDecimal(ClientContext &context, AggregateFunction &function,
@@ -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