duckdb 1.3.4 → 1.4.0

package/src/duckdb/extension/core_functions/aggregate/holistic/mad.cpp

@@ -1,4 +1,3 @@
-#include "duckdb/execution/expression_executor.hpp"
 #include "core_functions/aggregate/holistic_functions.hpp"
 #include "duckdb/planner/expression.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
@@ -7,6 +6,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct FrameSet {
 	inline explicit FrameSet(const SubFrames &frames_p) : frames(frames_p) {
 	}
@@ -182,7 +183,7 @@ struct MedianAbsoluteDeviationOperation : QuantileOperation {
 		auto &bind_data = finalize_data.input.bind_data->Cast<QuantileBindData>();
 		D_ASSERT(bind_data.quantiles.size() == 1);
 		const auto &q = bind_data.quantiles[0];
-		Interpolator<false> interp(q, state.v.size(), false);
+		QuantileInterpolator<false> interp(q, state.v.size(), false);
 		const auto med = interp.template Operation<INPUT_TYPE, MEDIAN_TYPE>(state.v.data(), finalize_data.result);
 
 		MadAccessor<INPUT_TYPE, T, MEDIAN_TYPE> accessor(med);
@@ -237,7 +238,7 @@ struct MedianAbsoluteDeviationOperation : QuantileOperation {
 		ReuseIndexes(index2, frames, prevs);
 		std::partition(index2, index2 + window_state.count, included);
 
-		Interpolator<false> interp(quantile, n, false);
+		QuantileInterpolator<false> interp(quantile, n, false);
 
 		// Compute mad from the second index
 		using ID = QuantileIndirect<INPUT_TYPE>;
@@ -328,6 +329,8 @@ unique_ptr<FunctionData> BindMedianAbsoluteDeviationDecimal(ClientContext &conte
 	return BindMAD(context, function, arguments);
 }
 
+} // namespace
+
 AggregateFunctionSet MadFun::GetFunctions() {
 	AggregateFunctionSet mad("mad");
 	mad.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr,

package/src/duckdb/extension/core_functions/aggregate/holistic/mode.cpp

@@ -21,6 +21,7 @@ namespace std {} // namespace std
 
 namespace duckdb {
 
+namespace {
 struct ModeAttr {
 	ModeAttr() : count(0), first_row(std::numeric_limits<idx_t>::max()) {
 	}
@@ -466,6 +467,8 @@ unique_ptr<FunctionData> BindModeAggregate(ClientContext &context, AggregateFunc
 	return nullptr;
 }
 
+} // namespace
+
 AggregateFunctionSet ModeFun::GetFunctions() {
 	AggregateFunctionSet mode("mode");
 	mode.AddFunction(AggregateFunction({LogicalTypeId::ANY}, LogicalTypeId::ANY, nullptr, nullptr, nullptr, nullptr,
@@ -476,8 +479,10 @@ AggregateFunctionSet ModeFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // Entropy
 //===--------------------------------------------------------------------===//
+namespace {
+
 template <class STATE>
-static double FinalizeEntropy(STATE &state) {
+double FinalizeEntropy(STATE &state) {
 	if (!state.frequency_map) {
 		return 0;
 	}
@@ -563,6 +568,8 @@ unique_ptr<FunctionData> BindEntropyAggregate(ClientContext &context, AggregateF
 	return nullptr;
 }
 
+} // namespace
+
 AggregateFunctionSet EntropyFun::GetFunctions() {
 	AggregateFunctionSet entropy("entropy");
 	entropy.AddFunction(AggregateFunction({LogicalTypeId::ANY}, LogicalType::DOUBLE, nullptr, nullptr, nullptr, nullptr,

package/src/duckdb/extension/core_functions/aggregate/holistic/quantile.cpp

@@ -137,54 +137,15 @@ unique_ptr<FunctionData> QuantileBindData::Deserialize(Deserializer &deserialize
 }
 
 //===--------------------------------------------------------------------===//
-// Cast Interpolation
+// Quantile Casts
 //===--------------------------------------------------------------------===//
 template <>
-interval_t CastInterpolation::Cast(const dtime_t &src, Vector &result) {
+interval_t QuantileCast::Operation(const dtime_t &src, Vector &result) {
 	return {0, 0, src.micros};
 }
 
 template <>
-double CastInterpolation::Interpolate(const double &lo, const double d, const double &hi) {
-	return lo * (1.0 - d) + hi * d;
-}
-
-template <>
-dtime_t CastInterpolation::Interpolate(const dtime_t &lo, const double d, const dtime_t &hi) {
-	return dtime_t(std::llround(static_cast<double>(lo.micros) * (1.0 - d) + static_cast<double>(hi.micros) * d));
-}
-
-template <>
-timestamp_t CastInterpolation::Interpolate(const timestamp_t &lo, const double d, const timestamp_t &hi) {
-	return timestamp_t(std::llround(static_cast<double>(lo.value) * (1.0 - d) + static_cast<double>(hi.value) * d));
-}
-
-template <>
-hugeint_t CastInterpolation::Interpolate(const hugeint_t &lo, const double d, const hugeint_t &hi) {
-	return Hugeint::Convert(Interpolate(Hugeint::Cast<double>(lo), d, Hugeint::Cast<double>(hi)));
-}
-
-static interval_t MultiplyByDouble(const interval_t &i, const double &d) { // NOLINT
-	D_ASSERT(d >= 0 && d <= 1);
-	return Interval::FromMicro(std::llround(static_cast<double>(Interval::GetMicro(i)) * d));
-}
-
-inline interval_t operator+(const interval_t &lhs, const interval_t &rhs) {
-	return Interval::FromMicro(Interval::GetMicro(lhs) + Interval::GetMicro(rhs));
-}
-
-inline interval_t operator-(const interval_t &lhs, const interval_t &rhs) {
-	return Interval::FromMicro(Interval::GetMicro(lhs) - Interval::GetMicro(rhs));
-}
-
-template <>
-interval_t CastInterpolation::Interpolate(const interval_t &lo, const double d, const interval_t &hi) {
-	const interval_t delta = hi - lo;
-	return lo + MultiplyByDouble(delta, d);
-}
-
-template <>
-string_t CastInterpolation::Cast(const string_t &src, Vector &result) {
+string_t QuantileCast::Operation(const string_t &src, Vector &result) {
 	return StringVector::AddStringOrBlob(result, src);
 }
 
@@ -202,7 +163,7 @@ struct QuantileScalarOperation : public QuantileOperation {
 		D_ASSERT(finalize_data.input.bind_data);
 		auto &bind_data = finalize_data.input.bind_data->Cast<QuantileBindData>();
 		D_ASSERT(bind_data.quantiles.size() == 1);
-		Interpolator<DISCRETE> interp(bind_data.quantiles[0], state.v.size(), bind_data.desc);
+		QuantileInterpolator<DISCRETE> interp(bind_data.quantiles[0], state.v.size(), bind_data.desc);
 		target = interp.template Operation<typename STATE::InputType, T>(state.v.data(), finalize_data.result);
 	}
 
@@ -264,7 +225,7 @@ struct QuantileScalarFallback : QuantileOperation {
 		D_ASSERT(finalize_data.input.bind_data);
 		auto &bind_data = finalize_data.input.bind_data->Cast<QuantileBindData>();
 		D_ASSERT(bind_data.quantiles.size() == 1);
-		Interpolator<true> interp(bind_data.quantiles[0], state.v.size(), bind_data.desc);
+		QuantileInterpolator<true> interp(bind_data.quantiles[0], state.v.size(), bind_data.desc);
 		auto interpolation_result = interp.InterpolateInternal<string_t>(state.v.data());
 		CreateSortKeyHelpers::DecodeSortKey(interpolation_result, finalize_data.result, finalize_data.result_idx,
 		                                    OrderModifiers(OrderType::ASCENDING, OrderByNullType::NULLS_LAST));
@@ -299,7 +260,7 @@ struct QuantileListOperation : QuantileOperation {
 		idx_t lower = 0;
 		for (const auto &q : bind_data.order) {
 			const auto &quantile = bind_data.quantiles[q];
-			Interpolator<DISCRETE> interp(quantile, state.v.size(), bind_data.desc);
+			QuantileInterpolator<DISCRETE> interp(quantile, state.v.size(), bind_data.desc);
 			interp.begin = lower;
 			rdata[ridx + q] = interp.template Operation<typename STATE::InputType, CHILD_TYPE>(v_t, result);
 			lower = interp.FRN;
@@ -370,7 +331,7 @@ struct QuantileListFallback : QuantileOperation {
 		idx_t lower = 0;
 		for (const auto &q : bind_data.order) {
 			const auto &quantile = bind_data.quantiles[q];
-			Interpolator<true> interp(quantile, state.v.size(), bind_data.desc);
+			QuantileInterpolator<true> interp(quantile, state.v.size(), bind_data.desc);
 			interp.begin = lower;
 			auto interpolation_result = interp.InterpolateInternal<string_t>(state.v.data());
 			CreateSortKeyHelpers::DecodeSortKey(interpolation_result, result, ridx + q,

package/src/duckdb/extension/core_functions/aggregate/holistic/reservoir_quantile.cpp

@@ -11,6 +11,8 @@
 
 namespace duckdb {
 
+namespace {
+
 template <typename T>
 struct ReservoirQuantileState {
 	T *v;
@@ -242,7 +244,7 @@ struct ReservoirQuantileListOperation : public ReservoirQuantileOperation {
 };
 
 template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP>
-static AggregateFunction ReservoirQuantileListAggregate(const LogicalType &input_type, const LogicalType &child_type) {
+AggregateFunction ReservoirQuantileListAggregate(const LogicalType &input_type, const LogicalType &child_type) {
 	LogicalType result_type = LogicalType::LIST(child_type);
 	return AggregateFunction(
 	    {input_type}, result_type, AggregateFunction::StateSize<STATE>, AggregateFunction::StateInitialize<STATE, OP>,
@@ -294,7 +296,7 @@ AggregateFunction GetReservoirQuantileListAggregateFunction(const LogicalType &t
 	}
 }
 
-static double CheckReservoirQuantile(const Value &quantile_val) {
+double CheckReservoirQuantile(const Value &quantile_val) {
 	if (quantile_val.IsNull()) {
 		throw BinderException("RESERVOIR_QUANTILE QUANTILE parameter cannot be NULL");
 	}
@@ -377,16 +379,6 @@ AggregateFunction GetReservoirQuantileAggregate(PhysicalType type) {
 	return fun;
 }
 
-unique_ptr<FunctionData> BindReservoirQuantileDecimalList(ClientContext &context, AggregateFunction &function,
-                                                          vector<unique_ptr<Expression>> &arguments) {
-	function = GetReservoirQuantileListAggregateFunction(arguments[0]->return_type);
-	auto bind_data = BindReservoirQuantile(context, function, arguments);
-	function.serialize = ReservoirQuantileBindData::Serialize;
-	function.deserialize = ReservoirQuantileBindData::Deserialize;
-	function.name = "reservoir_quantile";
-	return bind_data;
-}
-
 AggregateFunction GetReservoirQuantileListAggregate(const LogicalType &type) {
 	auto fun = GetReservoirQuantileListAggregateFunction(type);
 	fun.bind = BindReservoirQuantile;
@@ -398,7 +390,7 @@ AggregateFunction GetReservoirQuantileListAggregate(const LogicalType &type) {
 	return fun;
 }
 
-static void DefineReservoirQuantile(AggregateFunctionSet &set, const LogicalType &type) {
+void DefineReservoirQuantile(AggregateFunctionSet &set, const LogicalType &type) {
 	//	Four versions: type, scalar/list[, count]
 	auto fun = GetReservoirQuantileAggregate(type.InternalType());
 	set.AddFunction(fun);
@@ -414,8 +406,8 @@ static void DefineReservoirQuantile(AggregateFunctionSet &set, const LogicalType
 	set.AddFunction(fun);
 }
 
-static void GetReservoirQuantileDecimalFunction(AggregateFunctionSet &set, const vector<LogicalType> &arguments,
-                                                const LogicalType &return_value) {
+void GetReservoirQuantileDecimalFunction(AggregateFunctionSet &set, const vector<LogicalType> &arguments,
+                                         const LogicalType &return_value) {
 	AggregateFunction fun(arguments, return_value, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
 	                      BindReservoirQuantileDecimal);
 	fun.serialize = ReservoirQuantileBindData::Serialize;
@@ -426,6 +418,8 @@ static void GetReservoirQuantileDecimalFunction(AggregateFunctionSet &set, const
 	set.AddFunction(fun);
 }
 
+} // namespace
+
 AggregateFunctionSet ReservoirQuantileFun::GetFunctions() {
 	AggregateFunctionSet reservoir_quantile;
 

package/src/duckdb/extension/core_functions/aggregate/nested/binned_histogram.cpp

@@ -9,6 +9,8 @@
 
 namespace duckdb {
 
+namespace {
+
 template <class T>
 struct HistogramBinState {
 	using TYPE = T;
@@ -147,8 +149,8 @@ struct HistogramExact {
 };
 
 template <class OP, class T, class HIST>
-static void HistogramBinUpdateFunction(Vector inputs[], AggregateInputData &aggr_input, idx_t input_count,
-                                       Vector &state_vector, idx_t count) {
+void HistogramBinUpdateFunction(Vector inputs[], AggregateInputData &aggr_input, idx_t input_count,
+                                Vector &state_vector, idx_t count) {
 	auto &input = inputs[0];
 	UnifiedVectorFormat sdata;
 	state_vector.ToUnifiedFormat(count, sdata);
@@ -175,7 +177,7 @@ static void HistogramBinUpdateFunction(Vector inputs[], AggregateInputData &aggr
 	}
 }
 
-static bool SupportsOtherBucket(const LogicalType &type) {
+bool SupportsOtherBucket(const LogicalType &type) {
 	if (type.HasAlias()) {
 		return false;
 	}
@@ -210,7 +212,7 @@ static bool SupportsOtherBucket(const LogicalType &type) {
 		return false;
 	}
 }
-static Value OtherBucketValue(const LogicalType &type) {
+Value OtherBucketValue(const LogicalType &type) {
 	switch (type.id()) {
 	case LogicalTypeId::TINYINT:
 	case LogicalTypeId::SMALLINT:
@@ -255,7 +257,7 @@ static Value OtherBucketValue(const LogicalType &type) {
 	}
 }
 
-static void IsHistogramOtherBinFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void IsHistogramOtherBinFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &input_type = args.data[0].GetType();
 	if (!SupportsOtherBucket(input_type)) {
 		result.Reference(Value::BOOLEAN(false));
@@ -267,8 +269,8 @@ static void IsHistogramOtherBinFunction(DataChunk &args, ExpressionState &state,
 }
 
 template <class OP, class T>
-static void HistogramBinFinalizeFunction(Vector &state_vector, AggregateInputData &, Vector &result, idx_t count,
-                                         idx_t offset) {
+void HistogramBinFinalizeFunction(Vector &state_vector, AggregateInputData &, Vector &result, idx_t count,
+                                  idx_t offset) {
 	UnifiedVectorFormat sdata;
 	state_vector.ToUnifiedFormat(count, sdata);
 	auto states = UnifiedVectorFormat::GetData<HistogramBinState<T> *>(sdata);
@@ -327,7 +329,7 @@ static void HistogramBinFinalizeFunction(Vector &state_vector, AggregateInputDat
 }
 
 template <class OP, class T, class HIST>
-static AggregateFunction GetHistogramBinFunction(const LogicalType &type) {
+AggregateFunction GetHistogramBinFunction(const LogicalType &type) {
 	using STATE_TYPE = HistogramBinState<T>;
 
 	const char *function_name = HIST::EXACT ? "histogram_exact" : "histogram";
@@ -390,6 +392,8 @@ unique_ptr<FunctionData> HistogramBinBindFunction(ClientContext &context, Aggreg
 	return nullptr;
 }
 
+} // namespace
+
 AggregateFunction HistogramFun::BinnedHistogramFunction() {
 	return AggregateFunction("histogram", {LogicalType::ANY, LogicalType::LIST(LogicalType::ANY)}, LogicalTypeId::MAP,
 	                         nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

package/src/duckdb/extension/core_functions/aggregate/nested/histogram.cpp

@@ -7,6 +7,7 @@
 
 namespace duckdb {
 
+namespace {
 template <class MAP_TYPE>
 struct HistogramFunction {
 	template <class STATE>
@@ -58,8 +59,8 @@ struct StringMapType {
 };
 
 template <class OP, class T, class MAP_TYPE>
-static void HistogramUpdateFunction(Vector inputs[], AggregateInputData &aggr_input, idx_t input_count,
-                                    Vector &state_vector, idx_t count) {
+void HistogramUpdateFunction(Vector inputs[], AggregateInputData &aggr_input, idx_t input_count, Vector &state_vector,
+                             idx_t count) {
 
 	D_ASSERT(input_count == 1);
 
@@ -88,8 +89,7 @@ static void HistogramUpdateFunction(Vector inputs[], AggregateInputData &aggr_in
 }
 
 template <class OP, class T, class MAP_TYPE>
-static void HistogramFinalizeFunction(Vector &state_vector, AggregateInputData &, Vector &result, idx_t count,
-                                      idx_t offset) {
+void HistogramFinalizeFunction(Vector &state_vector, AggregateInputData &, Vector &result, idx_t count, idx_t offset) {
 	using HIST_STATE = HistogramAggState<T, typename MAP_TYPE::MAP_TYPE>;
 
 	UnifiedVectorFormat sdata;
@@ -138,7 +138,7 @@ static void HistogramFinalizeFunction(Vector &state_vector, AggregateInputData &
 }
 
 template <class OP, class T, class MAP_TYPE>
-static AggregateFunction GetHistogramFunction(const LogicalType &type) {
+AggregateFunction GetHistogramFunction(const LogicalType &type) {
 	using STATE_TYPE = HistogramAggState<T, typename MAP_TYPE::MAP_TYPE>;
 	using HIST_FUNC = HistogramFunction<MAP_TYPE>;
 
@@ -219,6 +219,8 @@ unique_ptr<FunctionData> HistogramBindFunction(ClientContext &context, Aggregate
 	return make_uniq<VariableReturnBindData>(function.return_type);
 }
 
+} // namespace
+
 AggregateFunctionSet HistogramFun::GetFunctions() {
 	AggregateFunctionSet fun;
 	AggregateFunction histogram_function("histogram", {LogicalType::ANY}, LogicalTypeId::MAP, nullptr, nullptr, nullptr,

package/src/duckdb/extension/core_functions/aggregate/nested/list.cpp

@@ -5,9 +5,10 @@
 
 namespace duckdb {
 
+namespace {
+
 struct ListBindData : public FunctionData {
 	explicit ListBindData(const LogicalType &stype_p);
-	~ListBindData() override;
 
 	LogicalType stype;
 	ListSegmentFunctions functions;
@@ -28,9 +29,6 @@ ListBindData::ListBindData(const LogicalType &stype_p) : stype(stype_p) {
 	GetSegmentDataFunctions(functions, type);
 }
 
-ListBindData::~ListBindData() {
-}
-
 struct ListAggState {
 	LinkedList linked_list;
 };
@@ -47,8 +45,8 @@ struct ListFunction {
 	}
 };
 
-static void ListUpdateFunction(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count,
-                               Vector &state_vector, idx_t count) {
+void ListUpdateFunction(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count, Vector &state_vector,
+                        idx_t count) {
 
 	D_ASSERT(input_count == 1);
 	auto &input = inputs[0];
@@ -68,8 +66,7 @@ static void ListUpdateFunction(Vector inputs[], AggregateInputData &aggr_input_d
 	}
 }
 
-static void ListAbsorbFunction(Vector &states_vector, Vector &combined, AggregateInputData &aggr_input_data,
-                               idx_t count) {
+void ListAbsorbFunction(Vector &states_vector, Vector &combined, AggregateInputData &aggr_input_data, idx_t count) {
 	D_ASSERT(aggr_input_data.combine_type == AggregateCombineType::ALLOW_DESTRUCTIVE);
 
 	UnifiedVectorFormat states_data;
@@ -99,8 +96,8 @@ static void ListAbsorbFunction(Vector &states_vector, Vector &combined, Aggregat
 	}
 }
 
-static void ListFinalize(Vector &states_vector, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
-                         idx_t offset) {
+void ListFinalize(Vector &states_vector, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
+                  idx_t offset) {
 
 	UnifiedVectorFormat states_data;
 	states_vector.ToUnifiedFormat(count, states_data);
@@ -149,8 +146,7 @@ static void ListFinalize(Vector &states_vector, AggregateInputData &aggr_input_d
 	ListVector::SetListSize(result, total_len);
 }
 
-static void ListCombineFunction(Vector &states_vector, Vector &combined, AggregateInputData &aggr_input_data,
-                                idx_t count) {
+void ListCombineFunction(Vector &states_vector, Vector &combined, AggregateInputData &aggr_input_data, idx_t count) {
 
 	//	Can we use destructive combining?
 	if (aggr_input_data.combine_type == AggregateCombineType::ALLOW_DESTRUCTIVE) {
@@ -186,24 +182,18 @@ static void ListCombineFunction(Vector &states_vector, Vector &combined, Aggrega
 
 unique_ptr<FunctionData> ListBindFunction(ClientContext &context, AggregateFunction &function,
                                           vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(arguments.size() == 1);
-	D_ASSERT(function.arguments.size() == 1);
-
-	if (arguments[0]->return_type.id() == LogicalTypeId::UNKNOWN) {
-		function.arguments[0] = LogicalTypeId::UNKNOWN;
-		function.return_type = LogicalType::SQLNULL;
-		return nullptr;
-	}
 
 	function.return_type = LogicalType::LIST(arguments[0]->return_type);
 	return make_uniq<ListBindData>(function.return_type);
 }
 
+} // namespace
+
 AggregateFunction ListFun::GetFunction() {
-	auto func =
-	    AggregateFunction({LogicalType::ANY}, LogicalTypeId::LIST, AggregateFunction::StateSize<ListAggState>,
-	                      AggregateFunction::StateInitialize<ListAggState, ListFunction>, ListUpdateFunction,
-	                      ListCombineFunction, ListFinalize, nullptr, ListBindFunction, nullptr, nullptr, nullptr);
+	auto func = AggregateFunction(
+	    {LogicalType::TEMPLATE("T")}, LogicalType::LIST(LogicalType::TEMPLATE("T")),
+	    AggregateFunction::StateSize<ListAggState>, AggregateFunction::StateInitialize<ListAggState, ListFunction>,
+	    ListUpdateFunction, ListCombineFunction, ListFinalize, nullptr, ListBindFunction, nullptr, nullptr, nullptr);
 
 	return func;
 }

package/src/duckdb/extension/core_functions/aggregate/regression/regr_avg.cpp

@@ -5,6 +5,9 @@
 #include "duckdb/function/function_set.hpp"
 
 namespace duckdb {
+
+namespace {
+
 struct RegrState {
 	double sum;
 	size_t count;
@@ -51,6 +54,8 @@ struct RegrAvgYFunction : RegrAvgFunction {
 	}
 };
 
+} // namespace
+
 AggregateFunction RegrAvgxFun::GetFunction() {
 	return AggregateFunction::BinaryAggregate<RegrState, double, double, double, RegrAvgXFunction>(
 	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);

package/src/duckdb/extension/core_functions/aggregate/regression/regr_intercept.cpp

@@ -6,6 +6,7 @@
 
 namespace duckdb {
 
+namespace {
 struct RegrInterceptState {
 	size_t count;
 	double sum_x;
@@ -59,6 +60,8 @@ struct RegrInterceptOperation {
 	}
 };
 
+} // namespace
+
 AggregateFunction RegrInterceptFun::GetFunction() {
 	return AggregateFunction::BinaryAggregate<RegrInterceptState, double, double, double, RegrInterceptOperation>(
 	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);

package/src/duckdb/extension/core_functions/aggregate/regression/regr_r2.cpp

@@ -10,6 +10,8 @@
 #include "core_functions/aggregate/regression_functions.hpp"
 
 namespace duckdb {
+
+namespace {
 struct RegrR2State {
 	CorrState corr;
 	StddevState var_pop_x;
@@ -65,8 +67,11 @@ struct RegrR2Operation {
 	}
 };
 
+} // namespace
+
 AggregateFunction RegrR2Fun::GetFunction() {
 	return AggregateFunction::BinaryAggregate<RegrR2State, double, double, double, RegrR2Operation>(
 	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);
 }
+
 } // namespace duckdb

package/src/duckdb/extension/core_functions/aggregate/regression/regr_sxx_syy.cpp

@@ -9,6 +9,7 @@
 
 namespace duckdb {
 
+namespace {
 struct RegrSState {
 	size_t count;
 	StddevState var_pop;
@@ -62,6 +63,8 @@ struct RegrSYYOperation : RegrBaseOperation {
 	}
 };
 
+} // namespace
+
 AggregateFunction RegrSXXFun::GetFunction() {
 	return AggregateFunction::BinaryAggregate<RegrSState, double, double, double, RegrSXXOperation>(
 	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);

package/src/duckdb/extension/core_functions/aggregate/regression/regr_sxy.cpp

@@ -8,6 +8,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct RegrSXyState {
 	size_t count;
 	CovarState cov_pop;
@@ -45,6 +47,8 @@ struct RegrSXYOperation {
 	}
 };
 
+} // namespace
+
 AggregateFunction RegrSXYFun::GetFunction() {
 	return AggregateFunction::BinaryAggregate<RegrSXyState, double, double, double, RegrSXYOperation>(
 	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE);

package/src/duckdb/extension/core_functions/core_functions_extension.cpp

@@ -1,17 +1,14 @@
-#define DUCKDB_EXTENSION_MAIN
 #include "core_functions_extension.hpp"
-
 #include "core_functions/function_list.hpp"
-#include "duckdb/main/extension_util.hpp"
 
 namespace duckdb {
 
-void LoadInternal(DuckDB &db) {
-	FunctionList::RegisterExtensionFunctions(*db.instance, CoreFunctionList::GetFunctionList());
+static void LoadInternal(ExtensionLoader &loader) {
+	FunctionList::RegisterExtensionFunctions(loader, CoreFunctionList::GetFunctionList());
 }
 
-void CoreFunctionsExtension::Load(DuckDB &db) {
-	LoadInternal(db);
+void CoreFunctionsExtension::Load(ExtensionLoader &loader) {
+	LoadInternal(loader);
 }
 
 std::string CoreFunctionsExtension::Name() {
@@ -30,16 +27,7 @@ std::string CoreFunctionsExtension::Version() const {
 
 extern "C" {
 
-DUCKDB_EXTENSION_API void core_functions_init(duckdb::DatabaseInstance &db) {
-	duckdb::DuckDB db_wrapper(db);
-	duckdb::LoadInternal(db_wrapper);
-}
-
-DUCKDB_EXTENSION_API const char *core_functions_version() {
-	return duckdb::DuckDB::LibraryVersion();
+DUCKDB_CPP_EXTENSION_ENTRY(core_functions, loader) {
+	duckdb::LoadInternal(loader);
 }
 }
-
-#ifndef DUCKDB_EXTENSION_MAIN
-#error DUCKDB_EXTENSION_MAIN not defined
-#endif

package/src/duckdb/extension/core_functions/function_list.cpp

@@ -243,14 +243,14 @@ static const StaticFunctionDefinition core_functions[] = {
 	DUCKDB_SCALAR_FUNCTION_SET(ListInnerProductFun),
 	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ListNegativeDotProductFun),
 	DUCKDB_SCALAR_FUNCTION_SET(ListNegativeInnerProductFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ListPackFun),
+	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ListPackFun),
 	DUCKDB_SCALAR_FUNCTION_SET(ListReduceFun),
 	DUCKDB_SCALAR_FUNCTION_SET(ListReverseSortFun),
 	DUCKDB_SCALAR_FUNCTION_SET(ListSliceFun),
 	DUCKDB_SCALAR_FUNCTION_SET(ListSortFun),
 	DUCKDB_SCALAR_FUNCTION(ListTransformFun),
 	DUCKDB_SCALAR_FUNCTION(ListUniqueFun),
-	DUCKDB_SCALAR_FUNCTION(ListValueFun),
+	DUCKDB_SCALAR_FUNCTION_SET(ListValueFun),
 	DUCKDB_AGGREGATE_FUNCTION_SET_ALIAS(ListaggFun),
 	DUCKDB_SCALAR_FUNCTION(LnFun),
 	DUCKDB_SCALAR_FUNCTION_SET(LogFun),
@@ -262,8 +262,9 @@ static const StaticFunctionDefinition core_functions[] = {
 	DUCKDB_SCALAR_FUNCTION_SET(MakeDateFun),
 	DUCKDB_SCALAR_FUNCTION(MakeTimeFun),
 	DUCKDB_SCALAR_FUNCTION_SET(MakeTimestampFun),
+	DUCKDB_SCALAR_FUNCTION_SET(MakeTimestampMsFun),
 	DUCKDB_SCALAR_FUNCTION_SET(MakeTimestampNsFun),
-	DUCKDB_SCALAR_FUNCTION(MapFun),
+	DUCKDB_SCALAR_FUNCTION_SET(MapFun),
 	DUCKDB_SCALAR_FUNCTION(MapConcatFun),
 	DUCKDB_SCALAR_FUNCTION(MapEntriesFun),
 	DUCKDB_SCALAR_FUNCTION(MapExtractFun),
@@ -317,6 +318,7 @@ static const StaticFunctionDefinition core_functions[] = {
 	DUCKDB_AGGREGATE_FUNCTION(RegrSYYFun),
 	DUCKDB_SCALAR_FUNCTION_SET(RepeatFun),
 	DUCKDB_SCALAR_FUNCTION(ReplaceFun),
+	DUCKDB_SCALAR_FUNCTION(ReplaceTypeFun),
 	DUCKDB_AGGREGATE_FUNCTION_SET(ReservoirQuantileFun),
 	DUCKDB_SCALAR_FUNCTION(ReverseFun),
 	DUCKDB_SCALAR_FUNCTION(RightFun),
@@ -342,6 +344,7 @@ static const StaticFunctionDefinition core_functions[] = {
 	DUCKDB_AGGREGATE_FUNCTION_SET(StringAggFun),
 	DUCKDB_SCALAR_FUNCTION_ALIAS(StrposFun),
 	DUCKDB_SCALAR_FUNCTION(StructInsertFun),
+	DUCKDB_SCALAR_FUNCTION(StructUpdateFun),
 	DUCKDB_AGGREGATE_FUNCTION_SET(SumFun),
 	DUCKDB_AGGREGATE_FUNCTION_SET(SumNoOverflowFun),
 	DUCKDB_AGGREGATE_FUNCTION_ALIAS(SumkahanFun),

package/src/duckdb/extension/core_functions/include/core_functions/aggregate/algebraic/stddev.hpp

@@ -65,8 +65,8 @@ struct STDDevBaseOperation {
 			const double target_count = static_cast<double>(target.count);
 			const double source_count = static_cast<double>(source.count);
 			const double total_count = static_cast<double>(count);
-			const auto mean = (source_count * source.mean + target_count * target.mean) / total_count;
 			const auto delta = source.mean - target.mean;
+			const auto mean = std::fma(source_count / total_count, delta, target.mean);
 			target.dsquared =
 			    source.dsquared + target.dsquared + delta * delta * source_count * target_count / total_count;
 			target.mean = mean;

package/src/duckdb/extension/core_functions/include/core_functions/aggregate/algebraic_functions.hpp

@@ -34,7 +34,7 @@ struct MeanFun {
 struct CorrFun {
 	static constexpr const char *Name = "corr";
 	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "Returns the correlation coefficient for non-null pairs in a group.";
+	static constexpr const char *Description = "Returns the correlation coefficient for non-NULL pairs in a group.";
 	static constexpr const char *Example = "COVAR_POP(y, x) / (STDDEV_POP(x) * STDDEV_POP(y))";
 	static constexpr const char *Categories = "";
 
@@ -54,7 +54,7 @@ struct CovarPopFun {
 struct CovarSampFun {
 	static constexpr const char *Name = "covar_samp";
 	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "Returns the sample covariance for non-null pairs in a group.";
+	static constexpr const char *Description = "Returns the sample covariance for non-NULL pairs in a group.";
 	static constexpr const char *Example = "(SUM(x*y) - SUM(x) * SUM(y) / COUNT(*)) / (COUNT(*) - 1)";
 	static constexpr const char *Categories = "";