duckdb 0.9.3-dev2.0 → 0.10.0

package/src/duckdb/src/core_functions/aggregate/distributive/arg_min_max.cpp

@@ -3,12 +3,14 @@
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/function/function_set.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
+#include "duckdb/planner/expression/bound_comparison_expression.hpp"
+#include "duckdb/planner/expression_binder.hpp"
 #include "duckdb/common/operator/comparison_operators.hpp"
 
 namespace duckdb {
 
 struct ArgMinMaxStateBase {
-	ArgMinMaxStateBase() : is_initialized(false) {
+	ArgMinMaxStateBase() : is_initialized(false), arg_null(false) {
 	}
 
 	template <class T>
@@ -20,7 +22,7 @@ struct ArgMinMaxStateBase {
 	}
 
 	template <class T>
-	static inline void AssignValue(T &target, T new_value, bool is_initialized) {
+	static inline void AssignValue(T &target, T new_value) {
 		target = new_value;
 	}
 
@@ -30,9 +32,15 @@ struct ArgMinMaxStateBase {
 	}
 
 	bool is_initialized;
+	bool arg_null;
 };
 
 // Out-of-line specialisations
+template <>
+void ArgMinMaxStateBase::CreateValue(string_t &value) {
+	value = string_t(uint32_t(0));
+}
+
 template <>
 void ArgMinMaxStateBase::CreateValue(Vector *&value) {
 	value = nullptr;
@@ -52,10 +60,8 @@ void ArgMinMaxStateBase::DestroyValue(Vector *&value) {
 }
 
 template <>
-void ArgMinMaxStateBase::AssignValue(string_t &target, string_t new_value, bool is_initialized) {
-	if (is_initialized) {
-		DestroyValue(target);
-	}
+void ArgMinMaxStateBase::AssignValue(string_t &target, string_t new_value) {
+	DestroyValue(target);
 	if (new_value.IsInlined()) {
 		target = new_value;
 	} else {
@@ -95,7 +101,7 @@ struct ArgMinMaxState : public ArgMinMaxStateBase {
 	}
 };
 
-template <class COMPARATOR>
+template <class COMPARATOR, bool IGNORE_NULL>
 struct ArgMinMaxBase {
 
 	template <class STATE>
@@ -108,22 +114,36 @@ struct ArgMinMaxBase {
 		state.~STATE();
 	}
 
+	template <class A_TYPE, class B_TYPE, class STATE>
+	static void Assign(STATE &state, const A_TYPE &x, const B_TYPE &y, const bool x_null) {
+		if (IGNORE_NULL) {
+			STATE::template AssignValue<A_TYPE>(state.arg, x);
+			STATE::template AssignValue<B_TYPE>(state.value, y);
+		} else {
+			state.arg_null = x_null;
+			if (!state.arg_null) {
+				STATE::template AssignValue<A_TYPE>(state.arg, x);
+			}
+			STATE::template AssignValue<B_TYPE>(state.value, y);
+		}
+	}
+
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &) {
+	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &binary) {
 		if (!state.is_initialized) {
-			STATE::template AssignValue<A_TYPE>(state.arg, x, false);
-			STATE::template AssignValue<B_TYPE>(state.value, y, false);
-			state.is_initialized = true;
+			if (IGNORE_NULL || binary.right_mask.RowIsValid(binary.ridx)) {
+				Assign(state, x, y, !binary.left_mask.RowIsValid(binary.lidx));
+				state.is_initialized = true;
+			}
 		} else {
-			OP::template Execute<A_TYPE, B_TYPE, STATE>(state, x, y);
+			OP::template Execute<A_TYPE, B_TYPE, STATE>(state, x, y, binary);
 		}
 	}
 
 	template <class A_TYPE, class B_TYPE, class STATE>
-	static void Execute(STATE &state, A_TYPE x_data, B_TYPE y_data) {
-		if (COMPARATOR::Operation(y_data, state.value)) {
-			STATE::template AssignValue<A_TYPE>(state.arg, x_data, true);
-			STATE::template AssignValue<B_TYPE>(state.value, y_data, true);
+	static void Execute(STATE &state, A_TYPE x_data, B_TYPE y_data, AggregateBinaryInput &binary) {
+		if ((IGNORE_NULL || binary.right_mask.RowIsValid(binary.ridx)) && COMPARATOR::Operation(y_data, state.value)) {
+			Assign(state, x_data, y_data, !binary.left_mask.RowIsValid(binary.lidx));
 		}
 	}
 
@@ -133,15 +153,14 @@ struct ArgMinMaxBase {
 			return;
 		}
 		if (!target.is_initialized || COMPARATOR::Operation(source.value, target.value)) {
-			STATE::template AssignValue(target.arg, source.arg, target.is_initialized);
-			STATE::template AssignValue(target.value, source.value, target.is_initialized);
+			Assign(target, source.arg, source.value, source.arg_null);
 			target.is_initialized = true;
 		}
 	}
 
 	template <class T, class STATE>
 	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		if (!state.is_initialized) {
+		if (!state.is_initialized || state.arg_null) {
 			finalize_data.ReturnNull();
 		} else {
 			STATE::template ReadValue(finalize_data.result, state.arg, target);
@@ -149,21 +168,32 @@ struct ArgMinMaxBase {
 	}
 
 	static bool IgnoreNull() {
-		return true;
+		return IGNORE_NULL;
+	}
+
+	static unique_ptr<FunctionData> Bind(ClientContext &context, AggregateFunction &function,
+	                                     vector<unique_ptr<Expression>> &arguments) {
+		ExpressionBinder::PushCollation(context, arguments[1], arguments[1]->return_type, false);
+		function.arguments[0] = arguments[0]->return_type;
+		function.return_type = arguments[0]->return_type;
+		return nullptr;
 	}
 };
 
-template <typename COMPARATOR>
-struct VectorArgMinMaxBase : ArgMinMaxBase<COMPARATOR> {
+template <typename COMPARATOR, bool IGNORE_NULL>
+struct VectorArgMinMaxBase : ArgMinMaxBase<COMPARATOR, IGNORE_NULL> {
 	template <class STATE>
-	static void AssignVector(STATE &state, Vector &arg, const idx_t idx) {
-		if (!state.is_initialized) {
-			state.arg = new Vector(arg.GetType());
+	static void AssignVector(STATE &state, Vector &arg, bool arg_null, const idx_t idx) {
+		if (!state.arg) {
+			state.arg = new Vector(arg.GetType(), 1);
 			state.arg->SetVectorType(VectorType::CONSTANT_VECTOR);
 		}
-		sel_t selv = idx;
-		SelectionVector sel(&selv);
-		VectorOperations::Copy(arg, *state.arg, sel, 1, 0, 0);
+		state.arg_null = arg_null;
+		if (!arg_null) {
+			sel_t selv = idx;
+			SelectionVector sel(&selv);
+			VectorOperations::Copy(arg, *state.arg, sel, 1, 0, 0);
+		}
 	}
 
 	template <class STATE>
@@ -189,16 +219,22 @@ struct VectorArgMinMaxBase : ArgMinMaxBase<COMPARATOR> {
 			}
 			const auto bval = bys[bidx];
 
+			const auto aidx = adata.sel->get_index(i);
+			const auto arg_null = !adata.validity.RowIsValid(aidx);
+			if (IGNORE_NULL && arg_null) {
+				continue;
+			}
+
 			const auto sidx = sdata.sel->get_index(i);
 			auto &state = *states[sidx];
 			if (!state.is_initialized) {
-				STATE::template AssignValue<BY_TYPE>(state.value, bval, false);
-				AssignVector(state, arg, i);
+				STATE::template AssignValue<BY_TYPE>(state.value, bval);
+				AssignVector(state, arg, arg_null, i);
 				state.is_initialized = true;
 
 			} else if (COMPARATOR::template Operation<BY_TYPE>(bval, state.value)) {
-				STATE::template AssignValue<BY_TYPE>(state.value, bval, true);
-				AssignVector(state, arg, i);
+				STATE::template AssignValue<BY_TYPE>(state.value, bval);
+				AssignVector(state, arg, arg_null, i);
 			}
 		}
 	}
@@ -209,15 +245,15 @@ struct VectorArgMinMaxBase : ArgMinMaxBase<COMPARATOR> {
 			return;
 		}
 		if (!target.is_initialized || COMPARATOR::Operation(source.value, target.value)) {
-			STATE::template AssignValue(target.value, source.value, target.is_initialized);
-			AssignVector(target, *source.arg, 0);
+			STATE::template AssignValue(target.value, source.value);
+			AssignVector(target, *source.arg, source.arg_null, 0);
 			target.is_initialized = true;
 		}
 	}
 
 	template <class STATE>
 	static void Finalize(STATE &state, AggregateFinalizeData &finalize_data) {
-		if (!state.is_initialized) {
+		if (!state.is_initialized || state.arg_null) {
 			finalize_data.ReturnNull();
 		} else {
 			VectorOperations::Copy(*state.arg, finalize_data.result, 1, 0, finalize_data.result_idx);
@@ -257,16 +293,19 @@ AggregateFunction GetVectorArgMinMaxFunctionBy(const LogicalType &by_type, const
 	}
 }
 
+static const vector<LogicalType> ArgMaxByTypes() {
+	vector<LogicalType> types = {LogicalType::INTEGER,      LogicalType::BIGINT, LogicalType::DOUBLE,
+	                             LogicalType::VARCHAR,      LogicalType::DATE,   LogicalType::TIMESTAMP,
+	                             LogicalType::TIMESTAMP_TZ, LogicalType::BLOB};
+	return types;
+}
+
 template <class OP, class ARG_TYPE>
 void AddVectorArgMinMaxFunctionBy(AggregateFunctionSet &fun, const LogicalType &type) {
-	fun.AddFunction(GetVectorArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::INTEGER, type));
-	fun.AddFunction(GetVectorArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::BIGINT, type));
-	fun.AddFunction(GetVectorArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::DOUBLE, type));
-	fun.AddFunction(GetVectorArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::VARCHAR, type));
-	fun.AddFunction(GetVectorArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::DATE, type));
-	fun.AddFunction(GetVectorArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::TIMESTAMP, type));
-	fun.AddFunction(GetVectorArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::TIMESTAMP_TZ, type));
-	fun.AddFunction(GetVectorArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::BLOB, type));
+	auto by_types = ArgMaxByTypes();
+	for (const auto &by_type : by_types) {
+		fun.AddFunction(GetVectorArgMinMaxFunctionBy<OP, ARG_TYPE>(by_type, type));
+	}
 }
 
 template <class OP, class ARG_TYPE, class BY_TYPE>
@@ -276,6 +315,9 @@ AggregateFunction GetArgMinMaxFunctionInternal(const LogicalType &by_type, const
 	if (type.InternalType() == PhysicalType::VARCHAR || by_type.InternalType() == PhysicalType::VARCHAR) {
 		function.destructor = AggregateFunction::StateDestroy<STATE, OP>;
 	}
+	if (by_type.InternalType() == PhysicalType::VARCHAR) {
+		function.bind = OP::Bind;
+	}
 	return function;
 }
 
@@ -297,19 +339,48 @@ AggregateFunction GetArgMinMaxFunctionBy(const LogicalType &by_type, const Logic
 
 template <class OP, class ARG_TYPE>
 void AddArgMinMaxFunctionBy(AggregateFunctionSet &fun, const LogicalType &type) {
-	fun.AddFunction(GetArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::INTEGER, type));
-	fun.AddFunction(GetArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::BIGINT, type));
-	fun.AddFunction(GetArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::DOUBLE, type));
-	fun.AddFunction(GetArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::VARCHAR, type));
-	fun.AddFunction(GetArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::DATE, type));
-	fun.AddFunction(GetArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::TIMESTAMP, type));
-	fun.AddFunction(GetArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::TIMESTAMP_TZ, type));
-	fun.AddFunction(GetArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::BLOB, type));
+	auto by_types = ArgMaxByTypes();
+	for (const auto &by_type : by_types) {
+		fun.AddFunction(GetArgMinMaxFunctionBy<OP, ARG_TYPE>(by_type, type));
+	}
+}
+
+template <class OP>
+static AggregateFunction GetDecimalArgMinMaxFunction(const LogicalType &by_type, const LogicalType &type) {
+	D_ASSERT(type.id() == LogicalTypeId::DECIMAL);
+	switch (type.InternalType()) {
+	case PhysicalType::INT16:
+		return GetArgMinMaxFunctionBy<OP, int16_t>(by_type, type);
+	case PhysicalType::INT32:
+		return GetArgMinMaxFunctionBy<OP, int32_t>(by_type, type);
+	case PhysicalType::INT64:
+		return GetArgMinMaxFunctionBy<OP, int64_t>(by_type, type);
+	default:
+		return GetArgMinMaxFunctionBy<OP, hugeint_t>(by_type, type);
+	}
+}
+
+template <class OP>
+static unique_ptr<FunctionData> BindDecimalArgMinMax(ClientContext &context, AggregateFunction &function,
+                                                     vector<unique_ptr<Expression>> &arguments) {
+	auto decimal_type = arguments[0]->return_type;
+	auto by_type = arguments[1]->return_type;
+	auto name = std::move(function.name);
+	function = GetDecimalArgMinMaxFunction<OP>(by_type, decimal_type);
+	function.name = std::move(name);
+	function.return_type = decimal_type;
+	return nullptr;
 }
 
-template <class COMPARATOR>
+template <class OP>
+void AddDecimalArgMinMaxFunctionBy(AggregateFunctionSet &fun, const LogicalType &by_type) {
+	fun.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL, by_type}, LogicalTypeId::DECIMAL, nullptr, nullptr,
+	                                  nullptr, nullptr, nullptr, nullptr, BindDecimalArgMinMax<OP>));
+}
+
+template <class COMPARATOR, bool IGNORE_NULL>
 static void AddArgMinMaxFunctions(AggregateFunctionSet &fun) {
-	using OP = ArgMinMaxBase<COMPARATOR>;
+	using OP = ArgMinMaxBase<COMPARATOR, IGNORE_NULL>;
 	AddArgMinMaxFunctionBy<OP, int32_t>(fun, LogicalType::INTEGER);
 	AddArgMinMaxFunctionBy<OP, int64_t>(fun, LogicalType::BIGINT);
 	AddArgMinMaxFunctionBy<OP, double>(fun, LogicalType::DOUBLE);
@@ -319,19 +390,36 @@ static void AddArgMinMaxFunctions(AggregateFunctionSet &fun) {
 	AddArgMinMaxFunctionBy<OP, timestamp_t>(fun, LogicalType::TIMESTAMP_TZ);
 	AddArgMinMaxFunctionBy<OP, string_t>(fun, LogicalType::BLOB);
 
-	using VECTOR_OP = VectorArgMinMaxBase<COMPARATOR>;
+	auto by_types = ArgMaxByTypes();
+	for (const auto &by_type : by_types) {
+		AddDecimalArgMinMaxFunctionBy<OP>(fun, by_type);
+	}
+
+	using VECTOR_OP = VectorArgMinMaxBase<COMPARATOR, IGNORE_NULL>;
 	AddVectorArgMinMaxFunctionBy<VECTOR_OP, Vector *>(fun, LogicalType::ANY);
 }
 
 AggregateFunctionSet ArgMinFun::GetFunctions() {
 	AggregateFunctionSet fun;
-	AddArgMinMaxFunctions<LessThan>(fun);
+	AddArgMinMaxFunctions<LessThan, true>(fun);
 	return fun;
 }
 
 AggregateFunctionSet ArgMaxFun::GetFunctions() {
 	AggregateFunctionSet fun;
-	AddArgMinMaxFunctions<GreaterThan>(fun);
+	AddArgMinMaxFunctions<GreaterThan, true>(fun);
+	return fun;
+}
+
+AggregateFunctionSet ArgMinNullFun::GetFunctions() {
+	AggregateFunctionSet fun;
+	AddArgMinMaxFunctions<LessThan, false>(fun);
+	return fun;
+}
+
+AggregateFunctionSet ArgMaxNullFun::GetFunctions() {
+	AggregateFunctionSet fun;
+	AddArgMinMaxFunctions<GreaterThan, false>(fun);
 	return fun;
 }
 

package/src/duckdb/src/core_functions/aggregate/distributive/bitagg.cpp

@@ -35,6 +35,8 @@ static AggregateFunction GetBitfieldUnaryAggregate(LogicalType type) {
 		return AggregateFunction::UnaryAggregate<BitState<uint32_t>, uint32_t, uint32_t, OP>(type, type);
 	case LogicalTypeId::UBIGINT:
 		return AggregateFunction::UnaryAggregate<BitState<uint64_t>, uint64_t, uint64_t, OP>(type, type);
+	case LogicalTypeId::UHUGEINT:
+		return AggregateFunction::UnaryAggregate<BitState<uhugeint_t>, uhugeint_t, uhugeint_t, OP>(type, type);
 	default:
 		throw InternalException("Unimplemented bitfield type for unary aggregate");
 	}

package/src/duckdb/src/core_functions/aggregate/distributive/bitstring_agg.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/common/types/null_value.hpp"
 #include "duckdb/common/vector_operations/aggregate_executor.hpp"
 #include "duckdb/common/types/bit.hpp"
+#include "duckdb/common/types/uhugeint.hpp"
 #include "duckdb/storage/statistics/base_statistics.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/common/types/cast_helpers.hpp"
@@ -183,6 +184,29 @@ idx_t BitStringAggOperation::GetRange(hugeint_t min, hugeint_t max) {
 	return range;
 }
 
+template <>
+void BitStringAggOperation::Execute(BitAggState<uhugeint_t> &state, uhugeint_t input, uhugeint_t min) {
+	idx_t val;
+	if (Uhugeint::TryCast(input - min, val)) {
+		Bit::SetBit(state.value, val, 1);
+	} else {
+		throw OutOfRangeException("Range too large for bitstring aggregation");
+	}
+}
+
+template <>
+idx_t BitStringAggOperation::GetRange(uhugeint_t min, uhugeint_t max) {
+	uhugeint_t result;
+	if (!TrySubtractOperator::Operation(max, min, result)) {
+		return NumericLimits<idx_t>::Maximum();
+	}
+	idx_t range;
+	if (!Uhugeint::TryCast(result + 1, range)) {
+		return NumericLimits<idx_t>::Maximum();
+	}
+	return range;
+}
+
 unique_ptr<BaseStatistics> BitstringPropagateStats(ClientContext &context, BoundAggregateExpression &expr,
                                                    AggregateStatisticsInput &input) {
 
@@ -253,6 +277,9 @@ void GetBitStringAggregate(const LogicalType &type, AggregateFunctionSet &bitstr
 	case LogicalType::UBIGINT: {
 		return BindBitString<uint64_t>(bitstring_agg, type.id());
 	}
+	case LogicalType::UHUGEINT: {
+		return BindBitString<uhugeint_t>(bitstring_agg, type.id());
+	}
 	default:
 		throw InternalException("Unimplemented bitstring aggregate");
 	}

package/src/duckdb/src/core_functions/aggregate/distributive/entropy.cpp

@@ -146,10 +146,11 @@ AggregateFunction GetEntropyFunctionInternal(PhysicalType type) {
 	case PhysicalType::DOUBLE:
 		return AggregateFunction::UnaryAggregateDestructor<EntropyState<double>, double, double, EntropyFunction>(
 		    LogicalType::DOUBLE, LogicalType::DOUBLE);
-	case PhysicalType::VARCHAR:
+	case PhysicalType::VARCHAR: {
 		return AggregateFunction::UnaryAggregateDestructor<EntropyState<string>, string_t, double,
-		                                                   EntropyFunctionString>(LogicalType::VARCHAR,
-		                                                                          LogicalType::DOUBLE);
+		                                                   EntropyFunctionString>(
+		    LogicalType::ANY_PARAMS(LogicalType::VARCHAR, 150), LogicalType::DOUBLE);
+	}
 
 	default:
 		throw InternalException("Unimplemented approximate_count aggregate");

package/src/duckdb/src/core_functions/aggregate/distributive/kurtosis.cpp

@@ -14,6 +14,11 @@ struct KurtosisState {
 	double sum_four;
 };
 
+struct KurtosisFlagBiasCorrection {};
+
+struct KurtosisFlagNoBiasCorrection {};
+
+template <class KURTOSIS_FLAG>
 struct KurtosisOperation {
 	template <class STATE>
 	static void Initialize(STATE &state) {
@@ -53,7 +58,11 @@ struct KurtosisOperation {
 	template <class TARGET_TYPE, class STATE>
 	static void Finalize(STATE &state, TARGET_TYPE &target, AggregateFinalizeData &finalize_data) {
 		auto n = (double)state.n;
-		if (n <= 3) {
+		if (n <= 1) {
+			finalize_data.ReturnNull();
+			return;
+		}
+		if (std::is_same<KURTOSIS_FLAG, KurtosisFlagBiasCorrection>::value && n <= 3) {
 			finalize_data.ReturnNull();
 			return;
 		}
@@ -70,11 +79,15 @@ struct KurtosisOperation {
 		            6 * state.sum_sqr * state.sum * state.sum * temp * temp - 3 * pow(state.sum, 4) * pow(temp, 3));
 
 		double m2 = temp * (state.sum_sqr - state.sum * state.sum * temp);
-		if (m2 <= 0 || ((n - 2) * (n - 3)) == 0) { // m2 shouldn't be below 0 but floating points are weird
+		if (m2 <= 0) { // m2 shouldn't be below 0 but floating points are weird
 			finalize_data.ReturnNull();
 			return;
 		}
-		target = (n - 1) * ((n + 1) * m4 / (m2 * m2) - 3 * (n - 1)) / ((n - 2) * (n - 3));
+		if (std::is_same<KURTOSIS_FLAG, KurtosisFlagNoBiasCorrection>::value) {
+			target = m4 / (m2 * m2) - 3;
+		} else {
+			target = (n - 1) * ((n + 1) * m4 / (m2 * m2) - 3 * (n - 1)) / ((n - 2) * (n - 3));
+		}
 		if (!Value::DoubleIsFinite(target)) {
 			throw OutOfRangeException("Kurtosis is out of range!");
 		}
@@ -86,8 +99,15 @@ struct KurtosisOperation {
 };
 
 AggregateFunction KurtosisFun::GetFunction() {
-	return AggregateFunction::UnaryAggregate<KurtosisState, double, double, KurtosisOperation>(LogicalType::DOUBLE,
-	                                                                                           LogicalType::DOUBLE);
+	return AggregateFunction::UnaryAggregate<KurtosisState, double, double,
+	                                         KurtosisOperation<KurtosisFlagBiasCorrection>>(LogicalType::DOUBLE,
+	                                                                                        LogicalType::DOUBLE);
+}
+
+AggregateFunction KurtosisPopFun::GetFunction() {
+	return AggregateFunction::UnaryAggregate<KurtosisState, double, double,
+	                                         KurtosisOperation<KurtosisFlagNoBiasCorrection>>(LogicalType::DOUBLE,
+	                                                                                          LogicalType::DOUBLE);
 }
 
 } // namespace duckdb

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

@@ -1,9 +1,13 @@
+#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
 #include "duckdb/core_functions/aggregate/distributive_functions.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/operator/comparison_operators.hpp"
 #include "duckdb/common/types/null_value.hpp"
 #include "duckdb/planner/expression.hpp"
+#include "duckdb/planner/expression/bound_comparison_expression.hpp"
+#include "duckdb/planner/expression_binder.hpp"
+#include "duckdb/function/function_binder.hpp"
 
 namespace duckdb {
 
@@ -36,6 +40,8 @@ static AggregateFunction GetUnaryAggregate(LogicalType type) {
 		return AggregateFunction::UnaryAggregate<MinMaxState<uint64_t>, uint64_t, uint64_t, OP>(type, type);
 	case PhysicalType::INT128:
 		return AggregateFunction::UnaryAggregate<MinMaxState<hugeint_t>, hugeint_t, hugeint_t, OP>(type, type);
+	case PhysicalType::UINT128:
+		return AggregateFunction::UnaryAggregate<MinMaxState<uhugeint_t>, uhugeint_t, uhugeint_t, OP>(type, type);
 	case PhysicalType::FLOAT:
 		return AggregateFunction::UnaryAggregate<MinMaxState<float>, float, float, OP>(type, type);
 	case PhysicalType::DOUBLE:
@@ -234,6 +240,9 @@ static bool TemplatedOptimumList(Vector &left, idx_t lidx, idx_t lcount, Vector
 template <class OP>
 static bool TemplatedOptimumStruct(Vector &left, idx_t lidx, idx_t lcount, Vector &right, idx_t ridx, idx_t rcount);
 
+template <class OP>
+static bool TemplatedOptimumArray(Vector &left, idx_t lidx, idx_t lcount, Vector &right, idx_t ridx, idx_t rcount);
+
 template <class OP>
 static bool TemplatedOptimumValue(Vector &left, idx_t lidx, idx_t lcount, Vector &right, idx_t ridx, idx_t rcount) {
 	D_ASSERT(left.GetType() == right.GetType());
@@ -257,6 +266,8 @@ static bool TemplatedOptimumValue(Vector &left, idx_t lidx, idx_t lcount, Vector
 		return TemplatedOptimumType<uint64_t, OP>(left, lidx, lcount, right, ridx, rcount);
 	case PhysicalType::INT128:
 		return TemplatedOptimumType<hugeint_t, OP>(left, lidx, lcount, right, ridx, rcount);
+	case PhysicalType::UINT128:
+		return TemplatedOptimumType<uhugeint_t, OP>(left, lidx, lcount, right, ridx, rcount);
 	case PhysicalType::FLOAT:
 		return TemplatedOptimumType<float, OP>(left, lidx, lcount, right, ridx, rcount);
 	case PhysicalType::DOUBLE:
@@ -269,6 +280,8 @@ static bool TemplatedOptimumValue(Vector &left, idx_t lidx, idx_t lcount, Vector
 		return TemplatedOptimumList<OP>(left, lidx, lcount, right, ridx, rcount);
 	case PhysicalType::STRUCT:
 		return TemplatedOptimumStruct<OP>(left, lidx, lcount, right, ridx, rcount);
+	case PhysicalType::ARRAY:
+		return TemplatedOptimumArray<OP>(left, lidx, lcount, right, ridx, rcount);
 	default:
 		throw InternalException("Invalid type for distinct comparison");
 	}
@@ -370,6 +383,52 @@ static bool TemplatedOptimumList(Vector &left, idx_t lidx, idx_t lcount, Vector
 	return false;
 }
 
+// FIXME: We should try to unify this with TemplatedOptimumList
+template <class OP>
+static bool TemplatedOptimumArray(Vector &left, idx_t lidx_p, idx_t lcount, Vector &right, idx_t ridx_p, idx_t rcount) {
+	// so map the indexes first
+	UnifiedVectorFormat lvdata, rvdata;
+	left.ToUnifiedFormat(lcount, lvdata);
+	right.ToUnifiedFormat(rcount, rvdata);
+
+	idx_t lidx = lvdata.sel->get_index(lidx_p);
+	idx_t ridx = rvdata.sel->get_index(ridx_p);
+
+	// DISTINCT semantics are in effect for nested types
+	auto lnull = !lvdata.validity.RowIsValid(lidx);
+	auto rnull = !rvdata.validity.RowIsValid(ridx);
+	if (lnull || rnull) {
+		return OP::Operation(0, 0, lnull, rnull);
+	}
+
+	auto &lchild = ArrayVector::GetEntry(left);
+	auto &rchild = ArrayVector::GetEntry(right);
+	auto left_array_size = ArrayType::GetSize(left.GetType());
+	auto right_array_size = ArrayType::GetSize(right.GetType());
+
+	D_ASSERT(left_array_size == right_array_size);
+
+	auto lchild_count = lcount * left_array_size;
+	auto rchild_count = rcount * right_array_size;
+
+	for (idx_t elem_idx = 0; elem_idx < left_array_size; elem_idx++) {
+		auto left_elem_idx = lidx * left_array_size + elem_idx;
+		auto right_elem_idx = ridx * right_array_size + elem_idx;
+
+		// Strict comparisons use the OP for definite
+		if (TemplatedOptimumValue<OP>(lchild, left_elem_idx, lchild_count, rchild, right_elem_idx, rchild_count)) {
+			return true;
+		}
+
+		// Strict comparisons use IS NOT DISTINCT for possible
+		if (!TemplatedOptimumValue<NotDistinctFrom>(lchild, left_elem_idx, lchild_count, rchild, right_elem_idx,
+		                                            rchild_count)) {
+			return false;
+		}
+	}
+	return false;
+}
+
 struct VectorMinMaxState {
 	Vector *value;
 };
@@ -515,12 +574,16 @@ static AggregateFunction GetMinMaxFunction(const LogicalType &type) {
 
 template <class OP, class OP_STRING, class OP_VECTOR>
 static AggregateFunction GetMinMaxOperator(const LogicalType &type) {
-	if (type.InternalType() == PhysicalType::VARCHAR) {
+	auto internal_type = type.InternalType();
+	switch (internal_type) {
+	case PhysicalType::VARCHAR:
 		return AggregateFunction::UnaryAggregateDestructor<MinMaxState<string_t>, string_t, string_t, OP_STRING>(
 		    type.id(), type.id());
-	} else if (type.InternalType() == PhysicalType::LIST || type.InternalType() == PhysicalType::STRUCT) {
+	case PhysicalType::LIST:
+	case PhysicalType::STRUCT:
+	case PhysicalType::ARRAY:
 		return GetMinMaxFunction<OP_VECTOR, VectorMinMaxState>(type);
-	} else {
+	default:
 		return GetUnaryAggregate<OP>(type);
 	}
 }
@@ -528,6 +591,40 @@ static AggregateFunction GetMinMaxOperator(const LogicalType &type) {
 template <class OP, class OP_STRING, class OP_VECTOR>
 unique_ptr<FunctionData> BindMinMax(ClientContext &context, AggregateFunction &function,
                                     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()) {
+			// 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";
+			QueryErrorContext error_context;
+			auto func = Catalog::GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, "", "", function_name,
+			                              OnEntryNotFound::RETURN_NULL, error_context);
+
+			auto &func_entry = func->Cast<AggregateFunctionCatalogEntry>();
+
+			FunctionBinder function_binder(context);
+			vector<LogicalType> types {arguments[0]->return_type, arguments[0]->return_type};
+			ErrorData error;
+			idx_t best_function = function_binder.BindFunction(func_entry.name, func_entry.functions, types, error);
+			if (best_function == DConstants::INVALID_INDEX) {
+				throw BinderException(string("Fail to find corresponding function for collation min/max: ") +
+				                      error.Message());
+			}
+			function = func_entry.functions.GetFunctionByOffset(best_function);
+
+			// Create a copied child and PushCollation for it.
+			arguments.push_back(arguments[0]->Copy());
+			ExpressionBinder::PushCollation(context, arguments[1], arguments[0]->return_type, false);
+
+			// Bind function like arg_min/arg_max.
+			function.arguments[0] = arguments[0]->return_type;
+			function.return_type = arguments[0]->return_type;
+			return nullptr;
+		}
+	}
+
 	auto input_type = arguments[0]->return_type;
 	auto name = std::move(function.name);
 	function = GetMinMaxOperator<OP, OP_STRING, OP_VECTOR>(input_type);

package/src/duckdb/src/core_functions/aggregate/distributive/string_agg.cpp

@@ -155,7 +155,8 @@ unique_ptr<FunctionData> StringAggDeserialize(Deserializer &deserializer, Aggreg
 AggregateFunctionSet StringAggFun::GetFunctions() {
 	AggregateFunctionSet string_agg;
 	AggregateFunction string_agg_param(
-	    {LogicalType::VARCHAR}, LogicalType::VARCHAR, AggregateFunction::StateSize<StringAggState>,
+	    {LogicalType::ANY_PARAMS(LogicalType::VARCHAR)}, LogicalType::VARCHAR,
+	    AggregateFunction::StateSize<StringAggState>,
 	    AggregateFunction::StateInitialize<StringAggState, StringAggFunction>,
 	    AggregateFunction::UnaryScatterUpdate<StringAggState, string_t, StringAggFunction>,
 	    AggregateFunction::StateCombine<StringAggState, StringAggFunction>,

package/src/duckdb/src/core_functions/aggregate/holistic/approximate_quantile.cpp

@@ -121,7 +121,15 @@ struct ApproxQuantileScalarOperation : public ApproxQuantileOperation {
 		state.h->compress();
 		auto &bind_data = finalize_data.input.bind_data->template Cast<ApproximateQuantileBindData>();
 		D_ASSERT(bind_data.quantiles.size() == 1);
-		target = Cast::template Operation<SAVE_TYPE, TARGET_TYPE>(state.h->quantile(bind_data.quantiles[0]));
+		// The result is approximate, so clamp instead of overflowing.
+		const auto source = state.h->quantile(bind_data.quantiles[0]);
+		if (TryCast::Operation(source, target, false)) {
+			return;
+		} else if (source < 0) {
+			target = NumericLimits<TARGET_TYPE>::Minimum();
+		} else {
+			target = NumericLimits<TARGET_TYPE>::Maximum();
+		}
 	}
 };