duckdb 1.3.3-dev4.0 → 1.3.3

package/src/duckdb/src/execution/physical_plan/plan_recursive_cte.cpp

@@ -104,23 +104,25 @@ PhysicalOperator &PhysicalPlanGenerator::CreatePlan(LogicalCTERef &op) {
 	D_ASSERT(op.children.empty());
 
 	// Check if this LogicalCTERef is supposed to scan a materialized CTE.
-	// Lookup if there is a materialized CTE for the cte_index.
-	auto materialized_cte = materialized_ctes.find(op.cte_index);
-
-	// If this check fails, this is a reference to a materialized recursive CTE.
-	if (materialized_cte != materialized_ctes.end()) {
-		auto &chunk_scan = Make<PhysicalColumnDataScan>(op.chunk_types, PhysicalOperatorType::CTE_SCAN,
-		                                                op.estimated_cardinality, op.cte_index);
-
-		auto cte = recursive_cte_tables.find(op.cte_index);
-		if (cte == recursive_cte_tables.end()) {
-			throw InvalidInputException("Referenced materialized CTE does not exist.");
+	if (op.materialized_cte == CTEMaterialize::CTE_MATERIALIZE_ALWAYS) {
+		// Lookup if there is a materialized CTE for the cte_index.
+		auto materialized_cte = materialized_ctes.find(op.cte_index);
+
+		// If this check fails, this is a reference to a materialized recursive CTE.
+		if (materialized_cte != materialized_ctes.end()) {
+			auto &chunk_scan = Make<PhysicalColumnDataScan>(op.chunk_types, PhysicalOperatorType::CTE_SCAN,
+			                                                op.estimated_cardinality, op.cte_index);
+
+			auto cte = recursive_cte_tables.find(op.cte_index);
+			if (cte == recursive_cte_tables.end()) {
+				throw InvalidInputException("Referenced materialized CTE does not exist.");
+			}
+
+			auto &cast_chunk_scan = chunk_scan.Cast<PhysicalColumnDataScan>();
+			cast_chunk_scan.collection = cte->second.get();
+			materialized_cte->second.push_back(cast_chunk_scan);
+			return chunk_scan;
 		}
-
-		auto &cast_chunk_scan = chunk_scan.Cast<PhysicalColumnDataScan>();
-		cast_chunk_scan.collection = cte->second.get();
-		materialized_cte->second.push_back(cast_chunk_scan);
-		return chunk_scan;
 	}
 
 	// CreatePlan of a LogicalRecursiveCTE must have happened before.

package/src/duckdb/src/execution/physical_plan_generator.cpp

@@ -10,7 +10,6 @@
 #include "duckdb/planner/operator/logical_extension_operator.hpp"
 #include "duckdb/planner/operator/list.hpp"
 #include "duckdb/execution/operator/helper/physical_verify_vector.hpp"
-#include "duckdb/main/settings.hpp"
 
 namespace duckdb {
 
@@ -57,11 +56,11 @@ unique_ptr<PhysicalPlan> PhysicalPlanGenerator::PlanInternal(LogicalOperator &op
 	physical_plan->SetRoot(CreatePlan(op));
 	physical_plan->Root().estimated_cardinality = op.estimated_cardinality;
 
-	auto debug_verify_vector = DBConfig::GetSetting<DebugVerifyVectorSetting>(context);
-	if (debug_verify_vector != DebugVectorVerification::NONE) {
-		if (debug_verify_vector != DebugVectorVerification::DICTIONARY_EXPRESSION &&
-		    debug_verify_vector != DebugVectorVerification::VARIANT_VECTOR) {
-			physical_plan->SetRoot(Make<PhysicalVerifyVector>(physical_plan->Root(), debug_verify_vector));
+	auto &config = DBConfig::GetConfig(context);
+	if (config.options.debug_verify_vector != DebugVectorVerification::NONE) {
+		if (config.options.debug_verify_vector != DebugVectorVerification::DICTIONARY_EXPRESSION) {
+			physical_plan->SetRoot(
+			    Make<PhysicalVerifyVector>(physical_plan->Root(), config.options.debug_verify_vector));
 		}
 	}
 	return std::move(physical_plan);
@@ -121,8 +120,6 @@ PhysicalOperator &PhysicalPlanGenerator::CreatePlan(LogicalOperator &op) {
 		return CreatePlan(op.Cast<LogicalExpressionGet>());
 	case LogicalOperatorType::LOGICAL_UPDATE:
 		return CreatePlan(op.Cast<LogicalUpdate>());
-	case LogicalOperatorType::LOGICAL_MERGE_INTO:
-		return CreatePlan(op.Cast<LogicalMergeInto>());
 	case LogicalOperatorType::LOGICAL_CREATE_TABLE:
 		return CreatePlan(op.Cast<LogicalCreateTable>());
 	case LogicalOperatorType::LOGICAL_CREATE_INDEX:

package/src/duckdb/src/execution/radix_partitioned_hashtable.cpp

@@ -13,9 +13,8 @@
 
 namespace duckdb {
 
-RadixPartitionedHashTable::RadixPartitionedHashTable(GroupingSet &grouping_set_p, const GroupedAggregateData &op_p,
-                                                     TupleDataValidityType group_validity_p)
-    : grouping_set(grouping_set_p), op(op_p), group_validity(group_validity_p) {
+RadixPartitionedHashTable::RadixPartitionedHashTable(GroupingSet &grouping_set_p, const GroupedAggregateData &op_p)
+    : grouping_set(grouping_set_p), op(op_p) {
 	auto groups_count = op.GroupCount();
 	for (idx_t i = 0; i < groups_count; i++) {
 		if (grouping_set.find(i) == grouping_set.end()) {
@@ -36,8 +35,7 @@ RadixPartitionedHashTable::RadixPartitionedHashTable(GroupingSet &grouping_set_p
 	group_types_copy.emplace_back(LogicalType::HASH);
 
 	auto layout = make_shared_ptr<TupleDataLayout>();
-	auto aggregate_objects = AggregateObject::CreateAggregateObjects(op.bindings);
-	layout->Initialize(std::move(group_types_copy), std::move(aggregate_objects), group_validity);
+	layout->Initialize(std::move(group_types_copy), AggregateObject::CreateAggregateObjects(op.bindings));
 	layout_ptr = std::move(layout);
 }
 
@@ -71,7 +69,7 @@ const TupleDataLayout &RadixPartitionedHashTable::GetLayout() const {
 unique_ptr<GroupedAggregateHashTable> RadixPartitionedHashTable::CreateHT(ClientContext &context, const idx_t capacity,
                                                                           const idx_t radix_bits) const {
 	return make_uniq<GroupedAggregateHashTable>(context, BufferAllocator::Get(context), group_types, op.payload_types,
-	                                            op.bindings, capacity, radix_bits, group_validity);
+	                                            op.bindings, capacity, radix_bits);
 }
 
 //===--------------------------------------------------------------------===//
@@ -128,6 +126,13 @@ public:
 	const idx_t sink_capacity;
 
 private:
+	//! Assume (1 << 15) = 32KB L1 cache per core, divided by two because hyperthreading
+	static constexpr idx_t L1_CACHE_SIZE = 32768 / 2;
+	//! Assume (1 << 20) = 1MB L2 cache per core, divided by two because hyperthreading
+	static constexpr idx_t L2_CACHE_SIZE = 1048576 / 2;
+	//! Assume (1 << 20) + (1 << 19) = 1.5MB L3 cache per core (shared), divided by two because hyperthreading
+	static constexpr idx_t L3_CACHE_SIZE = 1572864 / 2;
+
 	//! Sink radix bits to initialize with
 	static constexpr idx_t MAXIMUM_INITIAL_SINK_RADIX_BITS = 4;
 	//! Maximum Sink radix bits (independent of threads)
@@ -147,7 +152,7 @@ public:
 	//! If we have this many or less threads, we grow the HT, otherwise we abandon
 	static constexpr idx_t GROW_STRATEGY_THREAD_THRESHOLD = 2;
 	//! If we fill this many blocks per partition, we trigger a repartition
-	static constexpr double BLOCK_FILL_FACTOR = 0.5;
+	static constexpr double BLOCK_FILL_FACTOR = 1.8;
 	//! By how many bits to repartition if a repartition is triggered
 	static constexpr idx_t REPARTITION_RADIX_BITS = 2;
 };
@@ -332,12 +337,17 @@ idx_t RadixHTConfig::MaximumSinkRadixBits() const {
 }
 
 idx_t RadixHTConfig::SinkCapacity() const {
-	if (number_of_threads <= GROW_STRATEGY_THREAD_THRESHOLD) {
-		// Grow strategy, start off a bit bigger
-		return 262144;
-	}
-	// Start off tiny, we can adapt with DecideAdaptation later
-	return 32768;
+	// Compute cache size per active thread (assuming cache is shared)
+	const auto total_shared_cache_size = number_of_threads * L3_CACHE_SIZE;
+	const auto cache_per_active_thread = L1_CACHE_SIZE + L2_CACHE_SIZE + total_shared_cache_size / number_of_threads;
+
+	// Divide cache per active thread by entry size, round up to next power of two, to get capacity
+	const auto size_per_entry = LossyNumericCast<idx_t>(sizeof(ht_entry_t) * GroupedAggregateHashTable::LOAD_FACTOR) +
+	                            MinValue(row_width, ROW_WIDTH_THRESHOLD_TWO);
+	const auto capacity = NextPowerOfTwo(cache_per_active_thread / size_per_entry);
+
+	// Capacity must be at least the minimum capacity
+	return MaxValue<idx_t>(capacity, GroupedAggregateHashTable::InitialCapacity());
 }
 
 class RadixHTLocalSinkState : public LocalSinkState {
@@ -683,7 +693,7 @@ public:
 	vector<column_t> column_ids;
 
 	//! For synchronizing tasks
-	atomic<idx_t> task_idx;
+	idx_t task_idx;
 	atomic<idx_t> task_done;
 };
 
@@ -743,11 +753,12 @@ RadixHTGlobalSourceState::RadixHTGlobalSourceState(ClientContext &context_p, con
 SourceResultType RadixHTGlobalSourceState::AssignTask(RadixHTGlobalSinkState &sink, RadixHTLocalSourceState &lstate,
                                                       InterruptState &interrupt_state) {
 	// First, try to get a partition index
-	lstate.task_idx = task_idx++;
-	if (finished || lstate.task_idx >= sink.partitions.size()) {
+	auto guard = sink.Lock();
+	if (finished || task_idx == sink.partitions.size()) {
 		lstate.ht.reset();
 		return SourceResultType::FINISHED;
 	}
+	lstate.task_idx = task_idx++;
 
 	// We got a partition index
 	auto &partition = *sink.partitions[lstate.task_idx];

package/src/duckdb/src/execution/sample/base_reservoir_sample.cpp

@@ -3,6 +3,24 @@
 
 namespace duckdb {
 
+double BaseReservoirSampling::GetMinWeightFromTuplesSeen(idx_t rows_seen_total) {
+	// this function was obtained using https://mycurvefit.com. Inputting multiple x, y values into
+	// The
+	switch (rows_seen_total) {
+	case 0:
+		return 0;
+	case 1:
+		return 0.000161;
+	case 2:
+		return 0.530136;
+	case 3:
+		return 0.693454;
+	default: {
+		return (0.99 - 0.355 * std::exp(-0.07 * static_cast<double>(rows_seen_total)));
+	}
+	}
+}
+
 BaseReservoirSampling::BaseReservoirSampling(int64_t seed) : random(seed) {
 	next_index_to_sample = 0;
 	min_weight_threshold = 0;
@@ -55,7 +73,7 @@ void BaseReservoirSampling::SetNextEntry() {
 	//! since all our weights are 1 (uniform sampling), we can just determine the amount of elements to skip
 	min_weight_threshold = t_w;
 	min_weighted_entry_index = min_key.second;
-	next_index_to_sample = idx_t(ceil(x_w));
+	next_index_to_sample = MaxValue<idx_t>(1, idx_t(round(x_w)));
 	num_entries_to_skip_b4_next_sample = 0;
 }
 
@@ -100,33 +118,15 @@ void BaseReservoirSampling::UpdateMinWeightThreshold() {
 	min_weight_threshold = 1;
 }
 
-// Generate top k order statistics from n Uniform(0, 1) samples in O(k) time
-// This method leverages two key properties of order statistics from a Uniform(0, 1) distribution:
-// 1. The maximum of n independent Uniform(0, 1) samples, denoted as U(n), follows a Beta(n, 1) distribution.
-// 2. U(n-i) / U(n-i+1) ~ Beta(n-i, 1)
-// So we can use a recursive approach to generate the top k order statistics
-// (See: https://www.math.ntu.edu.tw/~hchen/teaching/LargeSample/notes/noteorder.pdf)
-static vector<double> GenerateTopKFromUniform(ReservoirRNG &random, idx_t n, idx_t k) {
-	vector<double> top_k_values(k);
-	double current_bound = 1.0;
-	for (idx_t i = 0; i < k; i++) {
-		// generate a sample from Beta(n - i, 1)
-		double beta = std::pow(random.NextRandom(), 1.0 / double(n - i));
-		current_bound *= beta;
-		top_k_values[i] = current_bound;
-	}
-	return top_k_values;
-}
-
 void BaseReservoirSampling::FillWeights(SelectionVector &sel, idx_t &sel_size) {
 	if (!reservoir_weights.empty()) {
 		return;
 	}
 	D_ASSERT(reservoir_weights.empty());
-	auto weights = GenerateTopKFromUniform(random, num_entries_seen_total, sel_size);
-	std::shuffle(weights.begin(), weights.end(), random);
+	auto num_entries_seen_normalized = num_entries_seen_total / FIXED_SAMPLE_SIZE;
+	auto min_weight = GetMinWeightFromTuplesSeen(num_entries_seen_normalized);
 	for (idx_t i = 0; i < sel_size; i++) {
-		auto weight = weights[i];
+		auto weight = random.NextRandom(min_weight, 1);
 		reservoir_weights.emplace(-weight, i);
 	}
 	D_ASSERT(reservoir_weights.size() <= sel_size);

package/src/duckdb/src/function/aggregate/distributive/count.cpp

@@ -6,7 +6,6 @@
 
 namespace duckdb {
 
-namespace {
 struct BaseCountFunction {
 	template <class STATE>
 	static void Initialize(STATE &state) {
@@ -212,19 +211,6 @@ struct CountFunction : public BaseCountFunction {
 	}
 };
 
-unique_ptr<BaseStatistics> CountPropagateStats(ClientContext &context, BoundAggregateExpression &expr,
-                                               AggregateStatisticsInput &input) {
-	if (!expr.IsDistinct() && !input.child_stats[0].CanHaveNull()) {
-		// count on a column without null values: use count star
-		expr.function = CountStarFun::GetFunction();
-		expr.function.name = "count_star";
-		expr.children.clear();
-	}
-	return nullptr;
-}
-
-} // namespace
-
 AggregateFunction CountFunctionBase::GetFunction() {
 	AggregateFunction fun({LogicalType(LogicalTypeId::ANY)}, LogicalType::BIGINT, AggregateFunction::StateSize<int64_t>,
 	                      AggregateFunction::StateInitialize<int64_t, CountFunction>, CountFunction::CountScatter,
@@ -245,6 +231,17 @@ AggregateFunction CountStarFun::GetFunction() {
 	return fun;
 }
 
+unique_ptr<BaseStatistics> CountPropagateStats(ClientContext &context, BoundAggregateExpression &expr,
+                                               AggregateStatisticsInput &input) {
+	if (!expr.IsDistinct() && !input.child_stats[0].CanHaveNull()) {
+		// count on a column without null values: use count star
+		expr.function = CountStarFun::GetFunction();
+		expr.function.name = "count_star";
+		expr.children.clear();
+	}
+	return nullptr;
+}
+
 AggregateFunctionSet CountFun::GetFunctions() {
 	AggregateFunction count_function = CountFunctionBase::GetFunction();
 	count_function.statistics = CountPropagateStats;

package/src/duckdb/src/function/aggregate/distributive/first_last_any.cpp

@@ -7,8 +7,6 @@
 
 namespace duckdb {
 
-namespace {
-
 template <class T>
 struct FirstState {
 	T value;
@@ -219,8 +217,8 @@ struct FirstVectorFunction : FirstFunctionStringBase<LAST, SKIP_NULLS> {
 };
 
 template <class T, bool LAST, bool SKIP_NULLS>
-void FirstFunctionSimpleUpdate(Vector inputs[], AggregateInputData &aggregate_input_data, idx_t input_count,
-                               data_ptr_t state, idx_t count) {
+static void FirstFunctionSimpleUpdate(Vector inputs[], AggregateInputData &aggregate_input_data, idx_t input_count,
+                                      data_ptr_t state, idx_t count) {
 	auto agg_state = reinterpret_cast<FirstState<T> *>(state);
 	if (LAST || !agg_state->is_set) {
 		// For FIRST, this skips looping over the input once the aggregate state has been set
@@ -231,14 +229,14 @@ void FirstFunctionSimpleUpdate(Vector inputs[], AggregateInputData &aggregate_in
 }
 
 template <class T, bool LAST, bool SKIP_NULLS>
-AggregateFunction GetFirstAggregateTemplated(LogicalType type) {
+static AggregateFunction GetFirstAggregateTemplated(LogicalType type) {
 	auto result = AggregateFunction::UnaryAggregate<FirstState<T>, T, T, FirstFunction<LAST, SKIP_NULLS>>(type, type);
 	result.simple_update = FirstFunctionSimpleUpdate<T, LAST, SKIP_NULLS>;
 	return result;
 }
 
 template <bool LAST, bool SKIP_NULLS>
-AggregateFunction GetFirstFunction(const LogicalType &type);
+static AggregateFunction GetFirstFunction(const LogicalType &type);
 
 template <bool LAST, bool SKIP_NULLS>
 AggregateFunction GetDecimalFirstFunction(const LogicalType &type) {
@@ -255,7 +253,7 @@ AggregateFunction GetDecimalFirstFunction(const LogicalType &type) {
 	}
 }
 template <bool LAST, bool SKIP_NULLS>
-AggregateFunction GetFirstFunction(const LogicalType &type) {
+static AggregateFunction GetFirstFunction(const LogicalType &type) {
 	if (type.id() == LogicalTypeId::DECIMAL) {
 		type.Verify();
 		AggregateFunction function = GetDecimalFirstFunction<LAST, SKIP_NULLS>(type);
@@ -310,6 +308,18 @@ AggregateFunction GetFirstFunction(const LogicalType &type) {
 	}
 }
 
+AggregateFunction FirstFunctionGetter::GetFunction(const LogicalType &type) {
+	auto fun = GetFirstFunction<false, false>(type);
+	fun.name = "first";
+	return fun;
+}
+
+AggregateFunction LastFunctionGetter::GetFunction(const LogicalType &type) {
+	auto fun = GetFirstFunction<true, false>(type);
+	fun.name = "last";
+	return fun;
+}
+
 template <bool LAST, bool SKIP_NULLS>
 unique_ptr<FunctionData> BindDecimalFirst(ClientContext &context, AggregateFunction &function,
                                           vector<unique_ptr<Expression>> &arguments) {
@@ -323,7 +333,7 @@ unique_ptr<FunctionData> BindDecimalFirst(ClientContext &context, AggregateFunct
 }
 
 template <bool LAST, bool SKIP_NULLS>
-AggregateFunction GetFirstOperator(const LogicalType &type) {
+static AggregateFunction GetFirstOperator(const LogicalType &type) {
 	if (type.id() == LogicalTypeId::DECIMAL) {
 		throw InternalException("FIXME: this shouldn't happen...");
 	}
@@ -346,27 +356,13 @@ unique_ptr<FunctionData> BindFirst(ClientContext &context, AggregateFunction &fu
 }
 
 template <bool LAST, bool SKIP_NULLS>
-void AddFirstOperator(AggregateFunctionSet &set) {
+static void AddFirstOperator(AggregateFunctionSet &set) {
 	set.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr,
 	                                  nullptr, nullptr, nullptr, BindDecimalFirst<LAST, SKIP_NULLS>));
 	set.AddFunction(AggregateFunction({LogicalType::ANY}, LogicalType::ANY, nullptr, nullptr, nullptr, nullptr, nullptr,
 	                                  nullptr, BindFirst<LAST, SKIP_NULLS>));
 }
 
-} // namespace
-
-AggregateFunction FirstFunctionGetter::GetFunction(const LogicalType &type) {
-	auto fun = GetFirstFunction<false, false>(type);
-	fun.name = "first";
-	return fun;
-}
-
-AggregateFunction LastFunctionGetter::GetFunction(const LogicalType &type) {
-	auto fun = GetFirstFunction<true, false>(type);
-	fun.name = "last";
-	return fun;
-}
-
 AggregateFunctionSet FirstFun::GetFunctions() {
 	AggregateFunctionSet first("first");
 	AddFirstOperator<false, false>(first);

package/src/duckdb/src/function/aggregate/distributive/minmax.cpp

@@ -12,12 +12,9 @@
 #include "duckdb/planner/expression.hpp"
 #include "duckdb/planner/expression/bound_comparison_expression.hpp"
 #include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/main/settings.hpp"
 
 namespace duckdb {
 
-namespace {
-
 template <class T>
 struct MinMaxState {
 	T value;
@@ -335,7 +332,7 @@ unique_ptr<FunctionData> BindMinMax(ClientContext &context, AggregateFunction &f
                                     vector<unique_ptr<Expression>> &arguments) {
 	if (arguments[0]->return_type.id() == LogicalTypeId::VARCHAR) {
 		auto str_collation = StringType::GetCollation(arguments[0]->return_type);
-		if (!str_collation.empty() || !DBConfig::GetSetting<DefaultCollationSetting>(context).empty()) {
+		if (!str_collation.empty() || !DBConfig::GetConfig(context).options.collation.empty()) {
 			// If aggr function is min/max and uses collations, replace bound_function with arg_min/arg_max
 			// to make sure the result's correctness.
 			string function_name = function.name == "min" ? "arg_min" : "arg_max";
@@ -389,13 +386,11 @@ unique_ptr<FunctionData> BindMinMax(ClientContext &context, AggregateFunction &f
 }
 
 template <class OP, class OP_STRING, class OP_VECTOR>
-AggregateFunction GetMinMaxOperator(string name) {
+static AggregateFunction GetMinMaxOperator(string name) {
 	return AggregateFunction(std::move(name), {LogicalType::ANY}, LogicalType::ANY, nullptr, nullptr, nullptr, nullptr,
 	                         nullptr, nullptr, BindMinMax<OP, OP_STRING, OP_VECTOR>);
 }
 
-} // namespace
-
 AggregateFunction MinFunction::GetFunction() {
 	return GetMinMaxOperator<MinOperation, MinOperationString, MinOperationVector>("min");
 }
@@ -407,7 +402,6 @@ AggregateFunction MaxFunction::GetFunction() {
 //---------------------------------------------------
 // MinMaxN
 //---------------------------------------------------
-namespace {
 
 template <class A, class COMPARATOR>
 class MinMaxNState {
@@ -429,8 +423,8 @@ public:
 };
 
 template <class STATE>
-void MinMaxNUpdate(Vector inputs[], AggregateInputData &aggr_input, idx_t input_count, Vector &state_vector,
-                   idx_t count) {
+static void MinMaxNUpdate(Vector inputs[], AggregateInputData &aggr_input, idx_t input_count, Vector &state_vector,
+                          idx_t count) {
 
 	auto &val_vector = inputs[0];
 	auto &n_vector = inputs[1];
@@ -480,7 +474,7 @@ void MinMaxNUpdate(Vector inputs[], AggregateInputData &aggr_input, idx_t input_
 }
 
 template <class VAL_TYPE, class COMPARATOR>
-void SpecializeMinMaxNFunction(AggregateFunction &function) {
+static void SpecializeMinMaxNFunction(AggregateFunction &function) {
 	using STATE = MinMaxNState<VAL_TYPE, COMPARATOR>;
 	using OP = MinMaxNOperation;
 
@@ -494,7 +488,7 @@ void SpecializeMinMaxNFunction(AggregateFunction &function) {
 }
 
 template <class COMPARATOR>
-void SpecializeMinMaxNFunction(PhysicalType arg_type, AggregateFunction &function) {
+static void SpecializeMinMaxNFunction(PhysicalType arg_type, AggregateFunction &function) {
 	switch (arg_type) {
 	case PhysicalType::VARCHAR:
 		SpecializeMinMaxNFunction<MinMaxStringValue, COMPARATOR>(function);
@@ -537,12 +531,11 @@ unique_ptr<FunctionData> MinMaxNBind(ClientContext &context, AggregateFunction &
 }
 
 template <class COMPARATOR>
-AggregateFunction GetMinMaxNFunction() {
+static AggregateFunction GetMinMaxNFunction() {
 	return AggregateFunction({LogicalTypeId::ANY, LogicalType::BIGINT}, LogicalType::LIST(LogicalType::ANY), nullptr,
 	                         nullptr, nullptr, nullptr, nullptr, nullptr, MinMaxNBind<COMPARATOR>, nullptr);
 }
 
-} // namespace
 //---------------------------------------------------
 // Function Registration
 //---------------------------------------------------s