duckdb 0.7.2-dev12.0 → 0.7.2-dev1244.0

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

@@ -0,0 +1,269 @@
+#include "duckdb/function/aggregate/distributive_functions.hpp"
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/types/null_value.hpp"
+#include "duckdb/common/vector_operations/aggregate_executor.hpp"
+#include "duckdb/common/types/bit.hpp"
+#include "duckdb/storage/statistics/base_statistics.hpp"
+#include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/common/types/cast_helpers.hpp"
+#include "duckdb/common/operator/subtract.hpp"
+
+namespace duckdb {
+
+template <class INPUT_TYPE>
+struct BitAggState {
+	bool is_set;
+	string_t value;
+	INPUT_TYPE min;
+	INPUT_TYPE max;
+};
+
+struct BitstringAggBindData : public FunctionData {
+	Value min;
+	Value max;
+
+	BitstringAggBindData() {
+	}
+
+	BitstringAggBindData(Value min, Value max) : min(std::move(min)), max(std::move(max)) {
+	}
+
+	unique_ptr<FunctionData> Copy() const override {
+		return make_unique<BitstringAggBindData>(*this);
+	}
+
+	bool Equals(const FunctionData &other_p) const override {
+		auto &other = (BitstringAggBindData &)other_p;
+		if (min.IsNull() && other.min.IsNull() && max.IsNull() && other.max.IsNull()) {
+			return true;
+		}
+		if (Value::NotDistinctFrom(min, other.min) && Value::NotDistinctFrom(max, other.max)) {
+			return true;
+		}
+		return false;
+	}
+};
+
+struct BitStringAggOperation {
+	static constexpr const idx_t MAX_BIT_RANGE = 1000000000; // for now capped at 1 billion bits
+
+	template <class STATE>
+	static void Initialize(STATE *state) {
+		state->is_set = false;
+	}
+
+	template <class INPUT_TYPE, class STATE, class OP>
+	static void Operation(STATE *state, AggregateInputData &data, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
+		auto bind_agg_data = (BitstringAggBindData *)data.bind_data;
+		if (!state->is_set) {
+			if (bind_agg_data->min.IsNull() || bind_agg_data->max.IsNull()) {
+				throw BinderException(
+				    "Could not retrieve required statistics. Alternatively, try by providing the statistics "
+				    "explicitly: BITSTRING_AGG(col, min, max) ");
+			}
+			state->min = bind_agg_data->min.GetValue<INPUT_TYPE>();
+			state->max = bind_agg_data->max.GetValue<INPUT_TYPE>();
+			idx_t bit_range =
+			    GetRange(bind_agg_data->min.GetValue<INPUT_TYPE>(), bind_agg_data->max.GetValue<INPUT_TYPE>());
+			if (bit_range > MAX_BIT_RANGE) {
+				throw OutOfRangeException(
+				    "The range between min and max value (%s <-> %s) is too large for bitstring aggregation",
+				    NumericHelper::ToString(state->min), NumericHelper::ToString(state->max));
+			}
+			idx_t len = Bit::ComputeBitstringLen(bit_range);
+			auto target = len > string_t::INLINE_LENGTH ? string_t(new char[len], len) : string_t(len);
+			Bit::SetEmptyBitString(target, bit_range);
+
+			state->value = target;
+			state->is_set = true;
+		}
+		if (input[idx] >= state->min && input[idx] <= state->max) {
+			Execute(state, input[idx], bind_agg_data->min.GetValue<INPUT_TYPE>());
+		} else {
+			throw OutOfRangeException("Value %s is outside of provided min and max range (%s <-> %s)",
+			                          NumericHelper::ToString(input[idx]), NumericHelper::ToString(state->min),
+			                          NumericHelper::ToString(state->max));
+		}
+	}
+
+	template <class INPUT_TYPE, class STATE, class OP>
+	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
+	                              ValidityMask &mask, idx_t count) {
+		OP::template Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
+	}
+
+	template <class INPUT_TYPE>
+	static idx_t GetRange(INPUT_TYPE min, INPUT_TYPE max) {
+		D_ASSERT(max >= min);
+		INPUT_TYPE result;
+		if (!TrySubtractOperator::Operation(max, min, result)) {
+			return NumericLimits<idx_t>::Maximum();
+		}
+		idx_t val(result);
+		if (val == NumericLimits<idx_t>::Maximum()) {
+			return val;
+		}
+		return val + 1;
+	}
+
+	template <class INPUT_TYPE, class STATE>
+	static void Execute(STATE *state, INPUT_TYPE input, INPUT_TYPE min) {
+		Bit::SetBit(state->value, input - min, 1);
+	}
+
+	template <class STATE, class OP>
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
+		if (!source.is_set) {
+			return;
+		}
+		if (!target->is_set) {
+			Assign(target, source.value);
+			target->is_set = true;
+			target->min = source.min;
+			target->max = source.max;
+		} else {
+			Bit::BitwiseOr(source.value, target->value, target->value);
+		}
+	}
+
+	template <class INPUT_TYPE, class STATE>
+	static void Assign(STATE *state, INPUT_TYPE input) {
+		D_ASSERT(state->is_set == false);
+		if (input.IsInlined()) {
+			state->value = input;
+		} else { // non-inlined string, need to allocate space for it
+			auto len = input.GetSize();
+			auto ptr = new char[len];
+			memcpy(ptr, input.GetDataUnsafe(), len);
+			state->value = string_t(ptr, len);
+		}
+	}
+
+	template <class T, class STATE>
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+		if (!state->is_set) {
+			mask.SetInvalid(idx);
+		} else {
+			target[idx] = StringVector::AddStringOrBlob(result, state->value);
+		}
+	}
+
+	template <class STATE>
+	static void Destroy(STATE *state) {
+		if (state->is_set && !state->value.IsInlined()) {
+			delete[] state->value.GetDataUnsafe();
+		}
+	}
+
+	static bool IgnoreNull() {
+		return true;
+	}
+};
+
+template <>
+void BitStringAggOperation::Execute(BitAggState<hugeint_t> *state, hugeint_t input, hugeint_t min) {
+	idx_t val;
+	if (Hugeint::TryCast(input - min, val)) {
+		Bit::SetBit(state->value, val, 1);
+	} else {
+		throw OutOfRangeException("Range too large for bitstring aggregation");
+	}
+}
+
+template <>
+idx_t BitStringAggOperation::GetRange(hugeint_t min, hugeint_t max) {
+	hugeint_t result;
+	if (!TrySubtractOperator::Operation(max, min, result)) {
+		return NumericLimits<idx_t>::Maximum();
+	}
+	idx_t range;
+	if (!Hugeint::TryCast(result + 1, range)) {
+		return NumericLimits<idx_t>::Maximum();
+	}
+	return range;
+}
+
+unique_ptr<BaseStatistics> BitstringPropagateStats(ClientContext &context, BoundAggregateExpression &expr,
+                                                   AggregateStatisticsInput &input) {
+
+	if (!NumericStats::HasMinMax(input.child_stats[0])) {
+		throw BinderException("Could not retrieve required statistics. Alternatively, try by providing the statistics "
+		                      "explicitly: BITSTRING_AGG(col, min, max) ");
+	}
+	auto bind_agg_data = (BitstringAggBindData *)input.bind_data;
+	bind_agg_data->min = NumericStats::Min(input.child_stats[0]);
+	bind_agg_data->max = NumericStats::Max(input.child_stats[0]);
+	return nullptr;
+}
+
+unique_ptr<FunctionData> BindBitstringAgg(ClientContext &context, AggregateFunction &function,
+                                          vector<unique_ptr<Expression>> &arguments) {
+	if (arguments.size() == 3) {
+		if (!arguments[1]->IsFoldable() && !arguments[2]->IsFoldable()) {
+			throw BinderException("bitstring_agg requires a constant min and max argument");
+		}
+		auto min = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
+		auto max = ExpressionExecutor::EvaluateScalar(context, *arguments[2]);
+		Function::EraseArgument(function, arguments, 2);
+		Function::EraseArgument(function, arguments, 1);
+		return make_unique<BitstringAggBindData>(min, max);
+	}
+	return make_unique<BitstringAggBindData>();
+}
+
+template <class TYPE>
+static void BindBitString(AggregateFunctionSet &bitstring_agg, const LogicalTypeId &type) {
+	auto function =
+	    AggregateFunction::UnaryAggregateDestructor<BitAggState<TYPE>, TYPE, string_t, BitStringAggOperation>(
+	        type, LogicalType::BIT);
+	function.bind = BindBitstringAgg;              // create new a 'BitstringAggBindData'
+	function.statistics = BitstringPropagateStats; // stores min and max from column stats in BitstringAggBindData
+	bitstring_agg.AddFunction(function); // uses the BitstringAggBindData to access statistics for creating bitstring
+	function.arguments = {type, type, type};
+	function.statistics = nullptr; // min and max are provided as arguments
+	bitstring_agg.AddFunction(function);
+}
+
+void BitStringAggFun::GetBitStringAggregate(const LogicalType &type, AggregateFunctionSet &bitstring_agg) {
+	switch (type.id()) {
+	case LogicalType::TINYINT: {
+		return BindBitString<int8_t>(bitstring_agg, type.id());
+	}
+	case LogicalType::SMALLINT: {
+		return BindBitString<int16_t>(bitstring_agg, type.id());
+	}
+	case LogicalType::INTEGER: {
+		return BindBitString<int32_t>(bitstring_agg, type.id());
+	}
+	case LogicalType::BIGINT: {
+		return BindBitString<int64_t>(bitstring_agg, type.id());
+	}
+	case LogicalType::HUGEINT: {
+		return BindBitString<hugeint_t>(bitstring_agg, type.id());
+	}
+	case LogicalType::UTINYINT: {
+		return BindBitString<uint8_t>(bitstring_agg, type.id());
+	}
+	case LogicalType::USMALLINT: {
+		return BindBitString<uint16_t>(bitstring_agg, type.id());
+	}
+	case LogicalType::UINTEGER: {
+		return BindBitString<uint32_t>(bitstring_agg, type.id());
+	}
+	case LogicalType::UBIGINT: {
+		return BindBitString<uint64_t>(bitstring_agg, type.id());
+	}
+	default:
+		throw InternalException("Unimplemented bitstring aggregate");
+	}
+}
+
+void BitStringAggFun::RegisterFunction(BuiltinFunctions &set) {
+	AggregateFunctionSet bitstring_agg("bitstring_agg");
+	for (auto &type : LogicalType::Integral()) {
+		GetBitStringAggregate(type, bitstring_agg);
+	}
+	set.AddFunction(bitstring_agg);
+}
+
+} // namespace duckdb

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

@@ -95,6 +95,7 @@ AggregateFunction BoolOrFun::GetFunction() {
 	auto fun = AggregateFunction::UnaryAggregate<BoolState, bool, bool, BoolOrFunFunction>(
 	    LogicalType(LogicalTypeId::BOOLEAN), LogicalType::BOOLEAN);
 	fun.name = "bool_or";
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }
 
@@ -102,6 +103,7 @@ AggregateFunction BoolAndFun::GetFunction() {
 	auto fun = AggregateFunction::UnaryAggregate<BoolState, bool, bool, BoolAndFunFunction>(
 	    LogicalType(LogicalTypeId::BOOLEAN), LogicalType::BOOLEAN);
 	fun.name = "bool_and";
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }
 

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

@@ -2,7 +2,6 @@
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/function/aggregate/distributive_functions.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/storage/statistics/validity_statistics.hpp"
 
 namespace duckdb {
 
@@ -77,6 +76,7 @@ AggregateFunction CountFun::GetFunction() {
 	    LogicalType(LogicalTypeId::ANY), LogicalType::BIGINT);
 	fun.name = "count";
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }
 
@@ -100,9 +100,8 @@ AggregateFunction CountStarFun::GetFunction() {
 }
 
 unique_ptr<BaseStatistics> CountPropagateStats(ClientContext &context, BoundAggregateExpression &expr,
-                                               FunctionData *bind_data, vector<unique_ptr<BaseStatistics>> &child_stats,
-                                               NodeStatistics *node_stats) {
-	if (!expr.IsDistinct() && child_stats[0] && !child_stats[0]->CanHaveNull()) {
+                                               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";

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

@@ -79,6 +79,7 @@ struct FirstFunctionString : public FirstFunctionBase {
 			}
 		} else {
 			state->is_set = true;
+			state->is_null = false;
 			if (value.IsInlined()) {
 				state->value = value;
 			} else {

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

@@ -514,6 +514,7 @@ unique_ptr<FunctionData> BindDecimalMinMax(ClientContext &context, AggregateFunc
 	function.name = std::move(name);
 	function.arguments[0] = decimal_type;
 	function.return_type = decimal_type;
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return nullptr;
 }
 
@@ -545,6 +546,7 @@ unique_ptr<FunctionData> BindMinMax(ClientContext &context, AggregateFunction &f
 	auto name = std::move(function.name);
 	function = GetMinMaxOperator<OP, OP_STRING, OP_VECTOR>(input_type);
 	function.name = std::move(name);
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	if (function.bind) {
 		return function.bind(context, function, arguments);
 	} else {

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

@@ -2,7 +2,6 @@
 #include "duckdb/function/aggregate/sum_helpers.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/types/decimal.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/function/aggregate/algebraic_functions.hpp"
 
@@ -52,9 +51,6 @@ struct DoubleSumOperation : public BaseSumOperation<SumSetOperation, ADD_OPERATO
 		if (!state->isset) {
 			mask.SetInvalid(idx);
 		} else {
-			if (!Value::DoubleIsFinite(state->value)) {
-				throw OutOfRangeException("SUM is out of range!");
-			}
 			target[idx] = state->value;
 		}
 	}
@@ -75,30 +71,29 @@ struct HugeintSumOperation : public BaseSumOperation<SumSetOperation, RegularAdd
 };
 
 unique_ptr<BaseStatistics> SumPropagateStats(ClientContext &context, BoundAggregateExpression &expr,
-                                             FunctionData *bind_data, vector<unique_ptr<BaseStatistics>> &child_stats,
-                                             NodeStatistics *node_stats) {
-	if (child_stats[0] && node_stats && node_stats->has_max_cardinality) {
-		auto &numeric_stats = (NumericStatistics &)*child_stats[0];
-		if (numeric_stats.min.IsNull() || numeric_stats.max.IsNull()) {
+                                             AggregateStatisticsInput &input) {
+	if (input.node_stats && input.node_stats->has_max_cardinality) {
+		auto &numeric_stats = input.child_stats[0];
+		if (!NumericStats::HasMinMax(numeric_stats)) {
 			return nullptr;
 		}
-		auto internal_type = numeric_stats.min.type().InternalType();
+		auto internal_type = numeric_stats.GetType().InternalType();
 		hugeint_t max_negative;
 		hugeint_t max_positive;
 		switch (internal_type) {
 		case PhysicalType::INT32:
-			max_negative = numeric_stats.min.GetValueUnsafe<int32_t>();
-			max_positive = numeric_stats.max.GetValueUnsafe<int32_t>();
+			max_negative = NumericStats::Min(numeric_stats).GetValueUnsafe<int32_t>();
+			max_positive = NumericStats::Max(numeric_stats).GetValueUnsafe<int32_t>();
 			break;
 		case PhysicalType::INT64:
-			max_negative = numeric_stats.min.GetValueUnsafe<int64_t>();
-			max_positive = numeric_stats.max.GetValueUnsafe<int64_t>();
+			max_negative = NumericStats::Min(numeric_stats).GetValueUnsafe<int64_t>();
+			max_positive = NumericStats::Max(numeric_stats).GetValueUnsafe<int64_t>();
 			break;
 		default:
 			throw InternalException("Unsupported type for propagate sum stats");
 		}
-		auto max_sum_negative = max_negative * hugeint_t(node_stats->max_cardinality);
-		auto max_sum_positive = max_positive * hugeint_t(node_stats->max_cardinality);
+		auto max_sum_negative = max_negative * hugeint_t(input.node_stats->max_cardinality);
+		auto max_sum_positive = max_positive * hugeint_t(input.node_stats->max_cardinality);
 		if (max_sum_positive >= NumericLimits<int64_t>::Maximum() ||
 		    max_sum_negative <= NumericLimits<int64_t>::Minimum()) {
 			// sum can potentially exceed int64_t bounds: use hugeint sum
@@ -115,6 +110,7 @@ AggregateFunction SumFun::GetSumAggregate(PhysicalType type) {
 	case PhysicalType::INT16: {
 		auto function = AggregateFunction::UnaryAggregate<SumState<int64_t>, int16_t, hugeint_t, IntegerSumOperation>(
 		    LogicalType::SMALLINT, LogicalType::HUGEINT);
+		function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 		return function;
 	}
 
@@ -123,6 +119,7 @@ AggregateFunction SumFun::GetSumAggregate(PhysicalType type) {
 		    AggregateFunction::UnaryAggregate<SumState<hugeint_t>, int32_t, hugeint_t, SumToHugeintOperation>(
 		        LogicalType::INTEGER, LogicalType::HUGEINT);
 		function.statistics = SumPropagateStats;
+		function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 		return function;
 	}
 	case PhysicalType::INT64: {
@@ -130,12 +127,14 @@ AggregateFunction SumFun::GetSumAggregate(PhysicalType type) {
 		    AggregateFunction::UnaryAggregate<SumState<hugeint_t>, int64_t, hugeint_t, SumToHugeintOperation>(
 		        LogicalType::BIGINT, LogicalType::HUGEINT);
 		function.statistics = SumPropagateStats;
+		function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 		return function;
 	}
 	case PhysicalType::INT128: {
 		auto function =
 		    AggregateFunction::UnaryAggregate<SumState<hugeint_t>, hugeint_t, hugeint_t, HugeintSumOperation>(
 		        LogicalType::HUGEINT, LogicalType::HUGEINT);
+		function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 		return function;
 	}
 	default:
@@ -149,12 +148,14 @@ AggregateFunction SumFun::GetSumAggregateNoOverflow(PhysicalType type) {
 		auto function = AggregateFunction::UnaryAggregate<SumState<int64_t>, int32_t, hugeint_t, IntegerSumOperation>(
 		    LogicalType::INTEGER, LogicalType::HUGEINT);
 		function.name = "sum_no_overflow";
+		function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 		return function;
 	}
 	case PhysicalType::INT64: {
 		auto function = AggregateFunction::UnaryAggregate<SumState<int64_t>, int64_t, hugeint_t, IntegerSumOperation>(
 		    LogicalType::BIGINT, LogicalType::HUGEINT);
 		function.name = "sum_no_overflow";
+		function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 		return function;
 	}
 	default:
@@ -169,6 +170,7 @@ unique_ptr<FunctionData> BindDecimalSum(ClientContext &context, AggregateFunctio
 	function.name = "sum";
 	function.arguments[0] = decimal_type;
 	function.return_type = LogicalType::DECIMAL(Decimal::MAX_WIDTH_DECIMAL, DecimalType::GetScale(decimal_type));
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return nullptr;
 }
 
@@ -179,6 +181,7 @@ unique_ptr<FunctionData> BindDecimalSumNoOverflow(ClientContext &context, Aggreg
 	function.name = "sum_no_overflow";
 	function.arguments[0] = decimal_type;
 	function.return_type = LogicalType::DECIMAL(Decimal::MAX_WIDTH_DECIMAL, DecimalType::GetScale(decimal_type));
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return nullptr;
 }
 

package/src/duckdb/src/function/aggregate/distributive_functions.cpp

@@ -10,6 +10,7 @@ void BuiltinFunctions::RegisterDistributiveAggregates() {
 	Register<BitAndFun>();
 	Register<BitOrFun>();
 	Register<BitXorFun>();
+	Register<BitStringAggFun>();
 	Register<CountStarFun>();
 	Register<CountFun>();
 	Register<FirstFun>();

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

@@ -70,11 +70,14 @@ struct ApproxQuantileOperation {
 
 	template <class INPUT_TYPE, class STATE, class OP>
 	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
+		auto val = Cast::template Operation<INPUT_TYPE, SAVE_TYPE>(data[idx]);
+		if (!Value::DoubleIsFinite(val)) {
+			return;
+		}
 		if (!state->h) {
 			state->h = new duckdb_tdigest::TDigest(100);
 		}
-
-		state->h->add(Cast::template Operation<INPUT_TYPE, SAVE_TYPE>(data[idx]));
+		state->h->add(val);
 		state->pos++;
 	}
 

package/src/duckdb/src/function/aggregate/holistic/mode.cpp

@@ -176,7 +176,7 @@ struct ModeFunction {
 		}
 		auto highest_frequency = state->Scan();
 		if (highest_frequency != state->frequency_map->end()) {
-			target[idx] = INPUT_TYPE(highest_frequency->first);
+			target[idx] = ASSIGN_OP::template Assign<INPUT_TYPE, INPUT_TYPE>(result, highest_frequency->first);
 		} else {
 			mask.SetInvalid(idx);
 		}

package/src/duckdb/src/function/aggregate/holistic/quantile.cpp

@@ -414,7 +414,7 @@ struct QuantileBindData : public FunctionData {
 		size_t pos = 0;
 		size_t neg = 0;
 		for (idx_t i = 0; i < quantiles_p.size(); ++i) {
-			const auto q = quantiles_p[i];
+			const auto &q = quantiles_p[i];
 			pos += (q > 0);
 			neg += (q < 0);
 			quantiles.emplace_back(QuantileAbs(q));
@@ -795,6 +795,7 @@ AggregateFunction GetTypedDiscreteQuantileListAggregateFunction(const LogicalTyp
 	using STATE = QuantileState<SAVE_TYPE>;
 	using OP = QuantileListOperation<INPUT_TYPE, true>;
 	auto fun = QuantileListAggregate<STATE, INPUT_TYPE, list_entry_t, OP>(type, type);
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	fun.window = AggregateFunction::UnaryWindow<STATE, INPUT_TYPE, list_entry_t, OP>;
 	return fun;
 }
@@ -851,6 +852,7 @@ AggregateFunction GetTypedContinuousQuantileAggregateFunction(const LogicalType
 	using STATE = QuantileState<INPUT_TYPE>;
 	using OP = QuantileScalarOperation<false>;
 	auto fun = AggregateFunction::UnaryAggregateDestructor<STATE, INPUT_TYPE, TARGET_TYPE, OP>(input_type, target_type);
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	fun.window = AggregateFunction::UnaryWindow<STATE, INPUT_TYPE, TARGET_TYPE, OP>;
 	return fun;
 }
@@ -904,6 +906,7 @@ AggregateFunction GetTypedContinuousQuantileListAggregateFunction(const LogicalT
 	using STATE = QuantileState<INPUT_TYPE>;
 	using OP = QuantileListOperation<CHILD_TYPE, false>;
 	auto fun = QuantileListAggregate<STATE, INPUT_TYPE, list_entry_t, OP>(input_type, result_type);
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	fun.window = AggregateFunction::UnaryWindow<STATE, INPUT_TYPE, list_entry_t, OP>;
 	return fun;
 }
@@ -1129,6 +1132,7 @@ AggregateFunction GetTypedMedianAbsoluteDeviationAggregateFunction(const Logical
 	using STATE = QuantileState<INPUT_TYPE>;
 	using OP = MedianAbsoluteDeviationOperation<MEDIAN_TYPE>;
 	auto fun = AggregateFunction::UnaryAggregateDestructor<STATE, INPUT_TYPE, TARGET_TYPE, OP>(input_type, target_type);
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	fun.window = AggregateFunction::UnaryWindow<STATE, INPUT_TYPE, TARGET_TYPE, OP>;
 	return fun;
 }
@@ -1198,6 +1202,7 @@ unique_ptr<FunctionData> BindMedianDecimal(ClientContext &context, AggregateFunc
 	function.name = "median";
 	function.serialize = QuantileSerialize;
 	function.deserialize = QuantileDeserialize;
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
 
@@ -1205,6 +1210,7 @@ unique_ptr<FunctionData> BindMedianAbsoluteDeviationDecimal(ClientContext &conte
                                                             vector<unique_ptr<Expression>> &arguments) {
 	function = GetMedianAbsoluteDeviationAggregateFunction(arguments[0]->return_type);
 	function.name = "mad";
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return nullptr;
 }
 
@@ -1257,6 +1263,7 @@ unique_ptr<FunctionData> BindDiscreteQuantileDecimal(ClientContext &context, Agg
 	function.name = "quantile_disc";
 	function.serialize = QuantileDecimalSerialize;
 	function.deserialize = QuantileDeserialize;
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
 
@@ -1267,6 +1274,7 @@ unique_ptr<FunctionData> BindDiscreteQuantileDecimalList(ClientContext &context,
 	function.name = "quantile_disc";
 	function.serialize = QuantileDecimalSerialize;
 	function.deserialize = QuantileDeserialize;
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
 
@@ -1277,6 +1285,7 @@ unique_ptr<FunctionData> BindContinuousQuantileDecimal(ClientContext &context, A
 	function.name = "quantile_cont";
 	function.serialize = QuantileDecimalSerialize;
 	function.deserialize = QuantileDeserialize;
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
 
@@ -1287,6 +1296,7 @@ unique_ptr<FunctionData> BindContinuousQuantileDecimalList(ClientContext &contex
 	function.name = "quantile_cont";
 	function.serialize = QuantileDecimalSerialize;
 	function.deserialize = QuantileDeserialize;
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return bind_data;
 }
 
@@ -1316,6 +1326,7 @@ AggregateFunction GetDiscreteQuantileAggregate(const LogicalType &type) {
 	fun.deserialize = QuantileDeserialize;
 	// temporarily push an argument so we can bind the actual quantile
 	fun.arguments.emplace_back(LogicalType::DOUBLE);
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }
 
@@ -1327,6 +1338,7 @@ AggregateFunction GetDiscreteQuantileListAggregate(const LogicalType &type) {
 	// temporarily push an argument so we can bind the actual quantile
 	auto list_of_double = LogicalType::LIST(LogicalType::DOUBLE);
 	fun.arguments.push_back(list_of_double);
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }
 
@@ -1337,6 +1349,7 @@ AggregateFunction GetContinuousQuantileAggregate(const LogicalType &type) {
 	fun.deserialize = QuantileDeserialize;
 	// temporarily push an argument so we can bind the actual quantile
 	fun.arguments.emplace_back(LogicalType::DOUBLE);
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }
 
@@ -1348,6 +1361,7 @@ AggregateFunction GetContinuousQuantileListAggregate(const LogicalType &type) {
 	// temporarily push an argument so we can bind the actual quantile
 	auto list_of_double = LogicalType::LIST(LogicalType::DOUBLE);
 	fun.arguments.push_back(list_of_double);
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }
 
@@ -1357,6 +1371,7 @@ AggregateFunction GetQuantileDecimalAggregate(const vector<LogicalType> &argumen
 	fun.bind = bind;
 	fun.serialize = QuantileSerialize;
 	fun.deserialize = QuantileDeserialize;
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }