duckdb 1.3.3-dev4.0 → 1.3.3

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

@@ -5,10 +5,9 @@
 
 namespace duckdb {
 
-namespace {
-
 struct ListBindData : public FunctionData {
 	explicit ListBindData(const LogicalType &stype_p);
+	~ListBindData() override;
 
 	LogicalType stype;
 	ListSegmentFunctions functions;
@@ -29,6 +28,9 @@ ListBindData::ListBindData(const LogicalType &stype_p) : stype(stype_p) {
 	GetSegmentDataFunctions(functions, type);
 }
 
+ListBindData::~ListBindData() {
+}
+
 struct ListAggState {
 	LinkedList linked_list;
 };
@@ -45,8 +47,8 @@ struct ListFunction {
 	}
 };
 
-void ListUpdateFunction(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count, Vector &state_vector,
-                        idx_t count) {
+static 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];
@@ -66,7 +68,8 @@ void ListUpdateFunction(Vector inputs[], AggregateInputData &aggr_input_data, id
 	}
 }
 
-void ListAbsorbFunction(Vector &states_vector, Vector &combined, AggregateInputData &aggr_input_data, idx_t count) {
+static 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;
@@ -96,8 +99,8 @@ void ListAbsorbFunction(Vector &states_vector, Vector &combined, AggregateInputD
 	}
 }
 
-void ListFinalize(Vector &states_vector, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
-                  idx_t offset) {
+static 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);
@@ -146,7 +149,8 @@ void ListFinalize(Vector &states_vector, AggregateInputData &aggr_input_data, Ve
 	ListVector::SetListSize(result, total_len);
 }
 
-void ListCombineFunction(Vector &states_vector, Vector &combined, AggregateInputData &aggr_input_data, idx_t count) {
+static 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) {
@@ -182,18 +186,24 @@ void ListCombineFunction(Vector &states_vector, Vector &combined, AggregateInput
 
 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::TEMPLATE("T")}, LogicalType::LIST(LogicalType::TEMPLATE("T")),
-	    AggregateFunction::StateSize<ListAggState>, AggregateFunction::StateInitialize<ListAggState, ListFunction>,
-	    ListUpdateFunction, ListCombineFunction, ListFinalize, nullptr, ListBindFunction, nullptr, nullptr, nullptr);
+	auto func =
+	    AggregateFunction({LogicalType::ANY}, LogicalTypeId::LIST, 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,9 +5,6 @@
 #include "duckdb/function/function_set.hpp"
 
 namespace duckdb {
-
-namespace {
-
 struct RegrState {
 	double sum;
 	size_t count;
@@ -54,8 +51,6 @@ 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,7 +6,6 @@
 
 namespace duckdb {
 
-namespace {
 struct RegrInterceptState {
 	size_t count;
 	double sum_x;
@@ -60,8 +59,6 @@ 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,8 +10,6 @@
 #include "core_functions/aggregate/regression_functions.hpp"
 
 namespace duckdb {
-
-namespace {
 struct RegrR2State {
 	CorrState corr;
 	StddevState var_pop_x;
@@ -67,11 +65,8 @@ 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,7 +9,6 @@
 
 namespace duckdb {
 
-namespace {
 struct RegrSState {
 	size_t count;
 	StddevState var_pop;
@@ -63,8 +62,6 @@ 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,8 +8,6 @@
 
 namespace duckdb {
 
-namespace {
-
 struct RegrSXyState {
 	size_t count;
 	CovarState cov_pop;
@@ -47,8 +45,6 @@ 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,14 +1,17 @@
+#define DUCKDB_EXTENSION_MAIN
 #include "core_functions_extension.hpp"
+
 #include "core_functions/function_list.hpp"
+#include "duckdb/main/extension_util.hpp"
 
 namespace duckdb {
 
-static void LoadInternal(ExtensionLoader &loader) {
-	FunctionList::RegisterExtensionFunctions(loader, CoreFunctionList::GetFunctionList());
+void LoadInternal(DuckDB &db) {
+	FunctionList::RegisterExtensionFunctions(*db.instance, CoreFunctionList::GetFunctionList());
 }
 
-void CoreFunctionsExtension::Load(ExtensionLoader &loader) {
-	LoadInternal(loader);
+void CoreFunctionsExtension::Load(DuckDB &db) {
+	LoadInternal(db);
 }
 
 std::string CoreFunctionsExtension::Name() {
@@ -27,7 +30,16 @@ std::string CoreFunctionsExtension::Version() const {
 
 extern "C" {
 
-DUCKDB_CPP_EXTENSION_ENTRY(core_functions, loader) {
-	duckdb::LoadInternal(loader);
+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();
 }
 }
+
+#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_SET_ALIAS(ListPackFun),
+	DUCKDB_SCALAR_FUNCTION_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_SET(ListValueFun),
+	DUCKDB_SCALAR_FUNCTION(ListValueFun),
 	DUCKDB_AGGREGATE_FUNCTION_SET_ALIAS(ListaggFun),
 	DUCKDB_SCALAR_FUNCTION(LnFun),
 	DUCKDB_SCALAR_FUNCTION_SET(LogFun),
@@ -262,9 +262,8 @@ 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_SET(MapFun),
+	DUCKDB_SCALAR_FUNCTION(MapFun),
 	DUCKDB_SCALAR_FUNCTION(MapConcatFun),
 	DUCKDB_SCALAR_FUNCTION(MapEntriesFun),
 	DUCKDB_SCALAR_FUNCTION(MapExtractFun),
@@ -318,7 +317,6 @@ 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),
@@ -344,7 +342,6 @@ 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 = "";
 

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

@@ -29,7 +29,7 @@ struct ArgMinFun {
 	static constexpr const char *Name = "arg_min";
 	static constexpr const char *Parameters = "arg,val";
 	static constexpr const char *Description = "Finds the row with the minimum val. Calculates the non-NULL arg expression at that row.";
-	static constexpr const char *Example = "arg_min(A, B)";
+	static constexpr const char *Example = "arg_min(A,B)";
 	static constexpr const char *Categories = "";
 
 	static AggregateFunctionSet GetFunctions();
@@ -51,7 +51,7 @@ struct ArgMinNullFun {
 	static constexpr const char *Name = "arg_min_null";
 	static constexpr const char *Parameters = "arg,val";
 	static constexpr const char *Description = "Finds the row with the minimum val. Calculates the arg expression at that row.";
-	static constexpr const char *Example = "arg_min_null(A, B)";
+	static constexpr const char *Example = "arg_min_null(A,B)";
 	static constexpr const char *Categories = "";
 
 	static AggregateFunctionSet GetFunctions();
@@ -61,7 +61,7 @@ struct ArgMaxFun {
 	static constexpr const char *Name = "arg_max";
 	static constexpr const char *Parameters = "arg,val";
 	static constexpr const char *Description = "Finds the row with the maximum val. Calculates the non-NULL arg expression at that row.";
-	static constexpr const char *Example = "arg_max(A, B)";
+	static constexpr const char *Example = "arg_max(A,B)";
 	static constexpr const char *Categories = "";
 
 	static AggregateFunctionSet GetFunctions();
@@ -83,7 +83,7 @@ struct ArgMaxNullFun {
 	static constexpr const char *Name = "arg_max_null";
 	static constexpr const char *Parameters = "arg,val";
 	static constexpr const char *Description = "Finds the row with the maximum val. Calculates the arg expression at that row.";
-	static constexpr const char *Example = "arg_max_null(A, B)";
+	static constexpr const char *Example = "arg_max_null(A,B)";
 	static constexpr const char *Categories = "";
 
 	static AggregateFunctionSet GetFunctions();

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

@@ -85,7 +85,7 @@ struct ReservoirQuantileFun {
 	static constexpr const char *Name = "reservoir_quantile";
 	static constexpr const char *Parameters = "x,quantile,sample_size";
 	static constexpr const char *Description = "Gives the approximate quantile using reservoir sampling, the sample size is optional and uses 8192 as a default size.";
-	static constexpr const char *Example = "reservoir_quantile(A, 0.5, 1024)";
+	static constexpr const char *Example = "reservoir_quantile(A,0.5,1024)";
 	static constexpr const char *Categories = "";
 
 	static AggregateFunctionSet GetFunctions();

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

@@ -11,7 +11,6 @@
 #include "duckdb/common/types/column/column_data_collection.hpp"
 #include "core_functions/aggregate/quantile_helpers.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/operator/interpolate.hpp"
 #include "duckdb/common/operator/multiply.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/function/window/window_index_tree.hpp"
@@ -149,22 +148,37 @@ struct QuantileCompare {
 	}
 };
 
-struct QuantileCast {
+struct CastInterpolation {
 	template <class INPUT_TYPE, class TARGET_TYPE>
-	static inline TARGET_TYPE Operation(const INPUT_TYPE &src, Vector &result) {
+	static inline TARGET_TYPE Cast(const INPUT_TYPE &src, Vector &result) {
 		return Cast::Operation<INPUT_TYPE, TARGET_TYPE>(src);
 	}
+	template <typename TARGET_TYPE>
+	static inline TARGET_TYPE Interpolate(const TARGET_TYPE &lo, const double d, const TARGET_TYPE &hi) {
+		const auto delta = hi - lo;
+		return LossyNumericCast<TARGET_TYPE>(lo + delta * d);
+	}
 };
 
 template <>
-interval_t QuantileCast::Operation(const dtime_t &src, Vector &result);
+interval_t CastInterpolation::Cast(const dtime_t &src, Vector &result);
+template <>
+double CastInterpolation::Interpolate(const double &lo, const double d, const double &hi);
+template <>
+dtime_t CastInterpolation::Interpolate(const dtime_t &lo, const double d, const dtime_t &hi);
+template <>
+timestamp_t CastInterpolation::Interpolate(const timestamp_t &lo, const double d, const timestamp_t &hi);
+template <>
+hugeint_t CastInterpolation::Interpolate(const hugeint_t &lo, const double d, const hugeint_t &hi);
+template <>
+interval_t CastInterpolation::Interpolate(const interval_t &lo, const double d, const interval_t &hi);
 template <>
-string_t QuantileCast::Operation(const string_t &src, Vector &result);
+string_t CastInterpolation::Cast(const string_t &src, Vector &result);
 
 // Continuous interpolation
 template <bool DISCRETE>
-struct QuantileInterpolator {
-	QuantileInterpolator(const QuantileValue &q, const idx_t n_p, const bool desc_p)
+struct Interpolator {
+	Interpolator(const QuantileValue &q, const idx_t n_p, const bool desc_p)
 	    : desc(desc_p), RN((double)(n_p - 1) * q.dbl), FRN(ExactNumericCast<idx_t>(floor(RN))),
 	      CRN(ExactNumericCast<idx_t>(ceil(RN))), begin(0), end(n_p) {
 	}
@@ -173,11 +187,11 @@ struct QuantileInterpolator {
 	TARGET_TYPE Interpolate(INPUT_TYPE lidx, INPUT_TYPE hidx, Vector &result, const ACCESSOR &accessor) const {
 		using ACCESS_TYPE = typename ACCESSOR::RESULT_TYPE;
 		if (lidx == hidx) {
-			return QuantileCast::Operation<ACCESS_TYPE, TARGET_TYPE>(accessor(lidx), result);
+			return CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(lidx), result);
 		} else {
-			auto lo = QuantileCast::Operation<ACCESS_TYPE, TARGET_TYPE>(accessor(lidx), result);
-			auto hi = QuantileCast::Operation<ACCESS_TYPE, TARGET_TYPE>(accessor(hidx), result);
-			return InterpolateOperator::Operation<TARGET_TYPE>(lo, RN - FRN, hi);
+			auto lo = CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(lidx), result);
+			auto hi = CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(hidx), result);
+			return CastInterpolation::Interpolate<TARGET_TYPE>(lo, RN - FRN, hi);
 		}
 	}
 
@@ -187,24 +201,24 @@ struct QuantileInterpolator {
 		QuantileCompare<ACCESSOR> comp(accessor, desc);
 		if (CRN == FRN) {
 			std::nth_element(v_t + begin, v_t + FRN, v_t + end, comp);
-			return QuantileCast::Operation<ACCESS_TYPE, TARGET_TYPE>(accessor(v_t[FRN]), result);
+			return CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(v_t[FRN]), result);
 		} else {
 			std::nth_element(v_t + begin, v_t + FRN, v_t + end, comp);
 			std::nth_element(v_t + FRN, v_t + CRN, v_t + end, comp);
-			auto lo = QuantileCast::Operation<ACCESS_TYPE, TARGET_TYPE>(accessor(v_t[FRN]), result);
-			auto hi = QuantileCast::Operation<ACCESS_TYPE, TARGET_TYPE>(accessor(v_t[CRN]), result);
-			return InterpolateOperator::Operation<TARGET_TYPE>(lo, RN - FRN, hi);
+			auto lo = CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(v_t[FRN]), result);
+			auto hi = CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(v_t[CRN]), result);
+			return CastInterpolation::Interpolate<TARGET_TYPE>(lo, RN - FRN, hi);
 		}
 	}
 
 	template <class INPUT_TYPE, class TARGET_TYPE>
 	inline TARGET_TYPE Extract(const INPUT_TYPE *dest, Vector &result) const {
 		if (CRN == FRN) {
-			return QuantileCast::Operation<INPUT_TYPE, TARGET_TYPE>(dest[0], result);
+			return CastInterpolation::Cast<INPUT_TYPE, TARGET_TYPE>(dest[0], result);
 		} else {
-			auto lo = QuantileCast::Operation<INPUT_TYPE, TARGET_TYPE>(dest[0], result);
-			auto hi = QuantileCast::Operation<INPUT_TYPE, TARGET_TYPE>(dest[1], result);
-			return InterpolateOperator::Operation<TARGET_TYPE>(lo, RN - FRN, hi);
+			auto lo = CastInterpolation::Cast<INPUT_TYPE, TARGET_TYPE>(dest[0], result);
+			auto hi = CastInterpolation::Cast<INPUT_TYPE, TARGET_TYPE>(dest[1], result);
+			return CastInterpolation::Interpolate<TARGET_TYPE>(lo, RN - FRN, hi);
 		}
 	}
 
@@ -219,7 +233,7 @@ struct QuantileInterpolator {
 
 // Discrete "interpolation"
 template <>
-struct QuantileInterpolator<true> {
+struct Interpolator<true> {
 	static inline idx_t Index(const QuantileValue &q, const idx_t n) {
 		idx_t floored;
 		switch (q.val.type().id()) {
@@ -243,14 +257,14 @@ struct QuantileInterpolator<true> {
 		return MaxValue<idx_t>(1, n - floored) - 1;
 	}
 
-	QuantileInterpolator(const QuantileValue &q, const idx_t n_p, bool desc_p)
+	Interpolator(const QuantileValue &q, const idx_t n_p, bool desc_p)
 	    : desc(desc_p), FRN(Index(q, n_p)), CRN(FRN), begin(0), end(n_p) {
 	}
 
 	template <class INPUT_TYPE, class TARGET_TYPE, typename ACCESSOR = QuantileDirect<INPUT_TYPE>>
 	TARGET_TYPE Interpolate(INPUT_TYPE lidx, INPUT_TYPE hidx, Vector &result, const ACCESSOR &accessor) const {
 		using ACCESS_TYPE = typename ACCESSOR::RESULT_TYPE;
-		return QuantileCast::Operation<ACCESS_TYPE, TARGET_TYPE>(accessor(lidx), result);
+		return CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(lidx), result);
 	}
 
 	template <class INPUT_TYPE, typename ACCESSOR = QuantileDirect<INPUT_TYPE>>
@@ -263,12 +277,12 @@ struct QuantileInterpolator<true> {
 	template <class INPUT_TYPE, class TARGET_TYPE, typename ACCESSOR = QuantileDirect<INPUT_TYPE>>
 	TARGET_TYPE Operation(INPUT_TYPE *v_t, Vector &result, const ACCESSOR &accessor = ACCESSOR()) const {
 		using ACCESS_TYPE = typename ACCESSOR::RESULT_TYPE;
-		return QuantileCast::Operation<ACCESS_TYPE, TARGET_TYPE>(InterpolateInternal(v_t, accessor), result);
+		return CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(InterpolateInternal(v_t, accessor), result);
 	}
 
 	template <class INPUT_TYPE, class TARGET_TYPE>
 	TARGET_TYPE Extract(const INPUT_TYPE *dest, Vector &result) const {
-		return QuantileCast::Operation<INPUT_TYPE, TARGET_TYPE>(dest[0], result);
+		return CastInterpolation::Cast<INPUT_TYPE, TARGET_TYPE>(dest[0], result);
 	}
 
 	const bool desc;
@@ -306,7 +320,6 @@ struct QuantileSortTree {
 	QuantileSortTree(AggregateInputData &aggr_input_data, const WindowPartitionInput &partition) {
 		// TODO: Two pass parallel sorting using Build
 		auto &inputs = *partition.inputs;
-		auto &interrupt = partition.interrupt_state;
 		ColumnDataScanState scan;
 		DataChunk sort;
 		inputs.InitializeScan(scan, partition.column_ids);
@@ -321,8 +334,8 @@ struct QuantileSortTree {
 		vector<column_t> sort_idx(1, 0);
 		const auto count = partition.count;
 
-		index_tree = make_uniq<WindowIndexTree>(partition.context.client, order_bys, sort_idx, count);
-		auto index_state = index_tree->GetLocalState(partition.context);
+		index_tree = make_uniq<WindowIndexTree>(partition.context, order_bys, sort_idx, count);
+		auto index_state = index_tree->GetLocalState();
 		auto &local_state = index_state->Cast<WindowIndexTreeLocalState>();
 
 		//	Build the indirection array by scanning the valid indices
@@ -339,12 +352,12 @@ struct QuantileSortTree {
 						filter_sel[filtered++] = i;
 					}
 				}
-				local_state.Sink(partition.context, sort, row_idx, filter_sel, filtered, interrupt);
+				local_state.SinkChunk(sort, row_idx, filter_sel, filtered);
 			} else {
-				local_state.Sink(partition.context, sort, row_idx, nullptr, 0, interrupt);
+				local_state.SinkChunk(sort, row_idx, nullptr, 0);
 			}
 		}
-		local_state.Finalize(partition.context, interrupt);
+		local_state.Sort();
 	}
 
 	inline idx_t SelectNth(const SubFrames &frames, size_t n) const {
@@ -360,7 +373,7 @@ struct QuantileSortTree {
 		index_tree->Build();
 
 		//	Find the interpolated indicies within the frame
-		QuantileInterpolator<DISCRETE> interp(q, n, false);
+		Interpolator<DISCRETE> interp(q, n, false);
 		const auto lo_data = SelectNth(frames, interp.FRN);
 		auto hi_data = lo_data;
 		if (interp.CRN != interp.FRN) {
@@ -396,7 +409,7 @@ struct QuantileSortTree {
 		ID indirect(data);
 		for (const auto &q : bind_data.order) {
 			const auto &quantile = bind_data.quantiles[q];
-			QuantileInterpolator<DISCRETE> interp(quantile, n, false);
+			Interpolator<DISCRETE> interp(quantile, n, false);
 
 			const auto lo_data = SelectNth(frames, interp.FRN);
 			auto hi_data = lo_data;

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

@@ -201,7 +201,7 @@ struct WindowQuantileState {
 		} else if (s) {
 			// Find the position(s) needed
 			try {
-				QuantileInterpolator<DISCRETE> interp(q, s->size(), false);
+				Interpolator<DISCRETE> interp(q, s->size(), false);
 				s->at(interp.FRN, interp.CRN - interp.FRN + 1, skips);
 				array<INPUT_TYPE, 2> dest;
 				dest[0] = skips[0].second;

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

@@ -18,7 +18,7 @@ namespace duckdb {
 struct RegrAvgxFun {
 	static constexpr const char *Name = "regr_avgx";
 	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "Returns the average of the independent variable for non-NULL pairs in a group, where x is the independent variable and y is the dependent variable.";
+	static constexpr const char *Description = "Returns the average of the independent variable for non-null pairs in a group, where x is the independent variable and y is the dependent variable.";
 	static constexpr const char *Example = "";
 	static constexpr const char *Categories = "";
 
@@ -28,7 +28,7 @@ struct RegrAvgxFun {
 struct RegrAvgyFun {
 	static constexpr const char *Name = "regr_avgy";
 	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "Returns the average of the dependent variable for non-NULL pairs in a group, where x is the independent variable and y is the dependent variable.";
+	static constexpr const char *Description = "Returns the average of the dependent variable for non-null pairs in a group, where x is the independent variable and y is the dependent variable.";
 	static constexpr const char *Example = "";
 	static constexpr const char *Categories = "";
 
@@ -38,7 +38,7 @@ struct RegrAvgyFun {
 struct RegrCountFun {
 	static constexpr const char *Name = "regr_count";
 	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "Returns the number of non-NULL number pairs in a group.";
+	static constexpr const char *Description = "Returns the number of non-null number pairs in a group.";
 	static constexpr const char *Example = "(SUM(x*y) - SUM(x) * SUM(y) / COUNT(*)) / COUNT(*)";
 	static constexpr const char *Categories = "";
 
@@ -48,8 +48,8 @@ struct RegrCountFun {
 struct RegrInterceptFun {
 	static constexpr const char *Name = "regr_intercept";
 	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "Returns the intercept of the univariate linear regression line for non-NULL pairs in a group.";
-	static constexpr const char *Example = "AVG(y)-REGR_SLOPE(y, x)*AVG(x)";
+	static constexpr const char *Description = "Returns the intercept of the univariate linear regression line for non-null pairs in a group.";
+	static constexpr const char *Example = "AVG(y)-REGR_SLOPE(y,x)*AVG(x)";
 	static constexpr const char *Categories = "";
 
 	static AggregateFunction GetFunction();
@@ -58,7 +58,7 @@ struct RegrInterceptFun {
 struct RegrR2Fun {
 	static constexpr const char *Name = "regr_r2";
 	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "Returns the coefficient of determination for non-NULL pairs in a group.";
+	static constexpr const char *Description = "Returns the coefficient of determination for non-null pairs in a group.";
 	static constexpr const char *Example = "";
 	static constexpr const char *Categories = "";
 
@@ -68,8 +68,8 @@ struct RegrR2Fun {
 struct RegrSlopeFun {
 	static constexpr const char *Name = "regr_slope";
 	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "Returns the slope of the linear regression line for non-NULL pairs in a group.";
-	static constexpr const char *Example = "COVAR_POP(x, y) / VAR_POP(x)";
+	static constexpr const char *Description = "Returns the slope of the linear regression line for non-null pairs in a group.";
+	static constexpr const char *Example = "COVAR_POP(x,y) / VAR_POP(x)";
 	static constexpr const char *Categories = "";
 
 	static AggregateFunction GetFunction();

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

@@ -30,7 +30,6 @@ struct SumState {
 
 	void Initialize() {
 		this->isset = false;
-		this->value = 0;
 	}
 
 	void Combine(const SumState<T> &other) {
@@ -183,6 +182,7 @@ struct BaseSumOperation {
 		STATEOP::template AddValues<STATE>(state, count);
 		ADDOP::template AddConstant<STATE, INPUT_TYPE>(state, input, count);
 	}
+
 	static bool IgnoreNull() {
 		return true;
 	}