duckdb 0.7.1 → 0.7.2-dev1034.0

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;
 }
 

package/src/duckdb/src/function/aggregate/nested/list.cpp

@@ -723,9 +723,9 @@ static void GetSegmentDataFunctions(WriteDataToSegment &write_data_to_segment,
 		read_data_from_segment.segment_function = ReadDataFromVarcharSegment;
 		copy_data_from_segment.segment_function = CopyDataFromListSegment;
 
-		write_data_to_segment.child_functions.emplace_back(WriteDataToSegment());
+		write_data_to_segment.child_functions.emplace_back();
 		write_data_to_segment.child_functions.back().create_segment = CreatePrimitiveSegment<char>;
-		copy_data_from_segment.child_functions.emplace_back(CopyDataFromSegment());
+		copy_data_from_segment.child_functions.emplace_back();
 		copy_data_from_segment.child_functions.back().segment_function = CopyDataFromPrimitiveSegment<char>;
 		break;
 	}
@@ -736,9 +736,9 @@ static void GetSegmentDataFunctions(WriteDataToSegment &write_data_to_segment,
 		copy_data_from_segment.segment_function = CopyDataFromListSegment;
 
 		// recurse
-		write_data_to_segment.child_functions.emplace_back(WriteDataToSegment());
-		read_data_from_segment.child_functions.emplace_back(ReadDataFromSegment());
-		copy_data_from_segment.child_functions.emplace_back(CopyDataFromSegment());
+		write_data_to_segment.child_functions.emplace_back();
+		read_data_from_segment.child_functions.emplace_back();
+		copy_data_from_segment.child_functions.emplace_back();
 		GetSegmentDataFunctions(write_data_to_segment.child_functions.back(),
 		                        read_data_from_segment.child_functions.back(),
 		                        copy_data_from_segment.child_functions.back(), ListType::GetChildType(type));
@@ -753,9 +753,9 @@ static void GetSegmentDataFunctions(WriteDataToSegment &write_data_to_segment,
 		// recurse
 		auto child_types = StructType::GetChildTypes(type);
 		for (idx_t i = 0; i < child_types.size(); i++) {
-			write_data_to_segment.child_functions.emplace_back(WriteDataToSegment());
-			read_data_from_segment.child_functions.emplace_back(ReadDataFromSegment());
-			copy_data_from_segment.child_functions.emplace_back(CopyDataFromSegment());
+			write_data_to_segment.child_functions.emplace_back();
+			read_data_from_segment.child_functions.emplace_back();
+			copy_data_from_segment.child_functions.emplace_back();
 			GetSegmentDataFunctions(write_data_to_segment.child_functions.back(),
 			                        read_data_from_segment.child_functions.back(),
 			                        copy_data_from_segment.child_functions.back(), child_types[i].second);

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

@@ -3,6 +3,9 @@
 #include "duckdb/common/types/column_data_collection.hpp"
 #include "duckdb/function/function_binder.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
+#include "duckdb/parser/expression_map.hpp"
+#include "duckdb/function/aggregate/distributive_functions.hpp"
 
 namespace duckdb {
 
@@ -71,17 +74,25 @@ struct SortedAggregateBindData : public FunctionData {
 };
 
 struct SortedAggregateState {
-	static const idx_t BUFFER_CAPACITY = STANDARD_VECTOR_SIZE;
+	//! Default buffer size, optimised for small group to avoid blowing out memory.
+	static const idx_t BUFFER_CAPACITY = 16;
 
 	SortedAggregateState() : nsel(0) {
 	}
 
 	static inline void InitializeBuffer(DataChunk &chunk, const vector<LogicalType> &types) {
 		if (!chunk.ColumnCount() && !types.empty()) {
-			chunk.Initialize(Allocator::DefaultAllocator(), types);
+			chunk.Initialize(Allocator::DefaultAllocator(), types, BUFFER_CAPACITY);
 		}
 	}
 
+	//! Make sure the buffer is large enough for slicing
+	static inline void ResetBuffer(DataChunk &chunk, const vector<LogicalType> &types) {
+		chunk.Reset();
+		chunk.Destroy();
+		chunk.Initialize(Allocator::DefaultAllocator(), types);
+	}
+
 	void Flush(SortedAggregateBindData &order_bind) {
 		if (ordering) {
 			return;
@@ -90,10 +101,12 @@ struct SortedAggregateState {
 		ordering = make_unique<ColumnDataCollection>(order_bind.buffer_manager, order_bind.sort_types);
 		InitializeBuffer(sort_buffer, order_bind.sort_types);
 		ordering->Append(sort_buffer);
+		ResetBuffer(sort_buffer, order_bind.sort_types);
 
 		arguments = make_unique<ColumnDataCollection>(order_bind.buffer_manager, order_bind.arg_types);
 		InitializeBuffer(arg_buffer, order_bind.arg_types);
 		arguments->Append(arg_buffer);
+		ResetBuffer(arg_buffer, order_bind.arg_types);
 	}
 
 	void Update(SortedAggregateBindData &order_bind, DataChunk &sort_chunk, DataChunk &arg_chunk) {
@@ -101,7 +114,7 @@ struct SortedAggregateState {
 		InitializeBuffer(sort_buffer, order_bind.sort_types);
 		InitializeBuffer(arg_buffer, order_bind.arg_types);
 
-		if (sort_chunk.size() + sort_buffer.size() > BUFFER_CAPACITY) {
+		if (sort_chunk.size() + sort_buffer.size() > STANDARD_VECTOR_SIZE) {
 			Flush(order_bind);
 		}
 		if (ordering) {
@@ -118,7 +131,7 @@ struct SortedAggregateState {
 		InitializeBuffer(sort_buffer, order_bind.sort_types);
 		InitializeBuffer(arg_buffer, order_bind.arg_types);
 
-		if (nsel + sort_buffer.size() > BUFFER_CAPACITY) {
+		if (nsel + sort_buffer.size() > STANDARD_VECTOR_SIZE) {
 			Flush(order_bind);
 		}
 		if (ordering) {
@@ -276,6 +289,8 @@ struct SortedAggregateFunction {
 		auto &orders = order_bind->orders;
 		RowLayout payload_layout;
 		payload_layout.Initialize(order_bind->arg_types);
+		DataChunk chunk;
+		chunk.Initialize(Allocator::DefaultAllocator(), order_bind->arg_types);
 
 		//	 Reusable inner state
 		vector<data_t> agg_state(order_bind->function.state_size());
@@ -314,7 +329,6 @@ struct SortedAggregateFunction {
 					global_sort->CompleteMergeRound(false);
 				}
 
-				auto &chunk = state->arg_buffer;
 				PayloadScanner scanner(*global_sort);
 				for (;;) {
 					chunk.Reset();
@@ -352,16 +366,44 @@ struct SortedAggregateFunction {
 	}
 };
 
-unique_ptr<FunctionData> FunctionBinder::BindSortedAggregate(AggregateFunction &bound_function,
-                                                             vector<unique_ptr<Expression>> &children,
-                                                             unique_ptr<FunctionData> bind_info,
-                                                             unique_ptr<BoundOrderModifier> order_bys) {
-
-	auto sorted_bind =
-	    make_unique<SortedAggregateBindData>(context, bound_function, children, std::move(bind_info), *order_bys);
+void FunctionBinder::BindSortedAggregate(ClientContext &context, BoundAggregateExpression &expr,
+                                         const vector<unique_ptr<Expression>> &groups) {
+	if (!expr.order_bys || expr.order_bys->orders.empty() || expr.children.empty()) {
+		// not a sorted aggregate: return
+		return;
+	}
+	if (context.config.enable_optimizer) {
+		// for each ORDER BY - check if it is actually necessary
+		// expressions that are in the groups do not need to be ORDERED BY
+		// `ORDER BY` on a group has no effect, because for each aggregate, the group is unique
+		// similarly, we only need to ORDER BY each aggregate once
+		expression_set_t seen_expressions;
+		for (auto &target : groups) {
+			seen_expressions.insert(target.get());
+		}
+		vector<BoundOrderByNode> new_order_nodes;
+		for (auto &order_node : expr.order_bys->orders) {
+			if (seen_expressions.find(order_node.expression.get()) != seen_expressions.end()) {
+				// we do not need to order by this node
+				continue;
+			}
+			seen_expressions.insert(order_node.expression.get());
+			new_order_nodes.push_back(std::move(order_node));
+		}
+		if (new_order_nodes.empty()) {
+			expr.order_bys.reset();
+			return;
+		}
+		expr.order_bys->orders = std::move(new_order_nodes);
+	}
+	auto &bound_function = expr.function;
+	auto &children = expr.children;
+	auto &order_bys = *expr.order_bys;
+	auto sorted_bind = make_unique<SortedAggregateBindData>(context, bound_function, expr.children,
+	                                                        std::move(expr.bind_info), order_bys);
 
 	// The arguments are the children plus the sort columns.
-	for (auto &order : order_bys->orders) {
+	for (auto &order : order_bys.orders) {
 		children.emplace_back(std::move(order.expression));
 	}
 
@@ -381,9 +423,9 @@ unique_ptr<FunctionData> FunctionBinder::BindSortedAggregate(AggregateFunction &
 	    AggregateFunction::StateDestroy<SortedAggregateState, SortedAggregateFunction>, nullptr,
 	    SortedAggregateFunction::Window, SortedAggregateFunction::Serialize, SortedAggregateFunction::Deserialize);
 
-	bound_function = std::move(ordered_aggregate);
-
-	return std::move(sorted_bind);
+	expr.function = std::move(ordered_aggregate);
+	expr.bind_info = std::move(sorted_bind);
+	expr.order_bys.reset();
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/cast/bit_cast.cpp

@@ -9,8 +9,6 @@ BoundCastInfo DefaultCasts::BitCastSwitch(BindCastInput &input, const LogicalTyp
 	case LogicalTypeId::VARCHAR:
 		// bit to varchar
 		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, duckdb::CastFromBit>);
-	case LogicalTypeId::BLOB:
-		return DefaultCasts::ReinterpretCast;
 	default:
 		return DefaultCasts::TryVectorNullCast;
 	}

package/src/duckdb/src/function/cast/blob_cast.cpp

@@ -10,7 +10,6 @@ BoundCastInfo DefaultCasts::BlobCastSwitch(BindCastInput &input, const LogicalTy
 		// blob to varchar
 		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, duckdb::CastFromBlob>);
 	case LogicalTypeId::AGGREGATE_STATE:
-	case LogicalTypeId::BIT:
 		return DefaultCasts::ReinterpretCast;
 	default:
 		return DefaultCasts::TryVectorNullCast;

package/src/duckdb/src/function/cast/cast_function_set.cpp

@@ -6,7 +6,7 @@
 
 namespace duckdb {
 
-BindCastInput::BindCastInput(CastFunctionSet &function_set, BindCastInfo *info, ClientContext *context)
+BindCastInput::BindCastInput(CastFunctionSet &function_set, BindCastInfo *info, optional_ptr<ClientContext> context)
     : function_set(function_set), info(info), context(context) {
 }
 

package/src/duckdb/src/function/cast/enum_casts.cpp

@@ -109,17 +109,39 @@ unique_ptr<BoundCastData> BindEnumCast(BindCastInput &input, const LogicalType &
 	return make_unique<EnumBoundCastData>(std::move(to_varchar_cast), std::move(from_varchar_cast));
 }
 
+struct EnumCastLocalState : public FunctionLocalState {
+public:
+	unique_ptr<FunctionLocalState> to_varchar_local;
+	unique_ptr<FunctionLocalState> from_varchar_local;
+};
+
+static unique_ptr<FunctionLocalState> InitEnumCastLocalState(CastLocalStateParameters &parameters) {
+	auto &cast_data = (EnumBoundCastData &)*parameters.cast_data;
+	auto result = make_unique<EnumCastLocalState>();
+
+	if (cast_data.from_varchar_cast.init_local_state) {
+		CastLocalStateParameters from_varchar_params(parameters, cast_data.from_varchar_cast.cast_data);
+		result->from_varchar_local = cast_data.from_varchar_cast.init_local_state(from_varchar_params);
+	}
+	if (cast_data.to_varchar_cast.init_local_state) {
+		CastLocalStateParameters from_varchar_params(parameters, cast_data.to_varchar_cast.cast_data);
+		result->from_varchar_local = cast_data.to_varchar_cast.init_local_state(from_varchar_params);
+	}
+	return std::move(result);
+}
+
 static bool EnumToAnyCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	auto &cast_data = (EnumBoundCastData &)*parameters.cast_data;
+	auto &lstate = (EnumCastLocalState &)*parameters.local_state;
 
 	Vector varchar_cast(LogicalType::VARCHAR, count);
 
 	// cast to varchar
-	CastParameters to_varchar_params(parameters, cast_data.to_varchar_cast.cast_data.get());
+	CastParameters to_varchar_params(parameters, cast_data.to_varchar_cast.cast_data, lstate.to_varchar_local);
 	cast_data.to_varchar_cast.function(source, varchar_cast, count, to_varchar_params);
 
 	// cast from varchar to the target
-	CastParameters from_varchar_params(parameters, cast_data.from_varchar_cast.cast_data.get());
+	CastParameters from_varchar_params(parameters, cast_data.from_varchar_cast.cast_data, lstate.from_varchar_local);
 	cast_data.from_varchar_cast.function(varchar_cast, result, count, from_varchar_params);
 	return true;
 }
@@ -152,7 +174,7 @@ BoundCastInfo DefaultCasts::EnumCastSwitch(BindCastInput &input, const LogicalTy
 			throw InternalException("ENUM can only have unsigned integers (except UINT64) as physical types");
 		}
 	default: {
-		return BoundCastInfo(EnumToAnyCast, BindEnumCast(input, source, target));
+		return BoundCastInfo(EnumToAnyCast, BindEnumCast(input, source, target), InitEnumCastLocalState);
 	}
 	}
 }

package/src/duckdb/src/function/cast/list_casts.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/function/cast/default_casts.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
+#include "duckdb/function/cast/bound_cast_data.hpp"
 
 namespace duckdb {
 
@@ -12,6 +13,15 @@ unique_ptr<BoundCastData> ListBoundCastData::BindListToListCast(BindCastInput &i
 	return make_unique<ListBoundCastData>(std::move(child_cast));
 }
 
+unique_ptr<FunctionLocalState> ListBoundCastData::InitListLocalState(CastLocalStateParameters &parameters) {
+	auto &cast_data = (ListBoundCastData &)*parameters.cast_data;
+	if (!cast_data.child_cast_info.init_local_state) {
+		return nullptr;
+	}
+	CastLocalStateParameters child_parameters(parameters, cast_data.child_cast_info.cast_data);
+	return cast_data.child_cast_info.init_local_state(child_parameters);
+}
+
 bool ListCast::ListToListCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	auto &cast_data = (ListBoundCastData &)*parameters.cast_data;
 
@@ -40,7 +50,7 @@ bool ListCast::ListToListCast(Vector &source, Vector &result, idx_t count, CastP
 	ListVector::Reserve(result, source_size);
 	auto &append_vector = ListVector::GetEntry(result);
 
-	CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data.get());
+	CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state);
 	if (!cast_data.child_cast_info.function(source_cc, append_vector, source_size, child_parameters)) {
 		return false;
 	}
@@ -116,10 +126,13 @@ static bool ListToVarcharCast(Vector &source, Vector &result, idx_t count, CastP
 BoundCastInfo DefaultCasts::ListCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
 	switch (target.id()) {
 	case LogicalTypeId::LIST:
-		return BoundCastInfo(ListCast::ListToListCast, ListBoundCastData::BindListToListCast(input, source, target));
+		return BoundCastInfo(ListCast::ListToListCast, ListBoundCastData::BindListToListCast(input, source, target),
+		                     ListBoundCastData::InitListLocalState);
 	case LogicalTypeId::VARCHAR:
-		return BoundCastInfo(ListToVarcharCast, ListBoundCastData::BindListToListCast(
-		                                            input, source, LogicalType::LIST(LogicalType::VARCHAR)));
+		return BoundCastInfo(
+		    ListToVarcharCast,
+		    ListBoundCastData::BindListToListCast(input, source, LogicalType::LIST(LogicalType::VARCHAR)),
+		    ListBoundCastData::InitListLocalState);
 	default:
 		return DefaultCasts::TryVectorNullCast;
 	}

package/src/duckdb/src/function/cast/map_cast.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/function/cast/default_casts.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
+#include "duckdb/function/cast/bound_cast_data.hpp"
 
 namespace duckdb {
 
@@ -78,10 +79,12 @@ static bool MapToVarcharCast(Vector &source, Vector &result, idx_t count, CastPa
 BoundCastInfo DefaultCasts::MapCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
 	switch (target.id()) {
 	case LogicalTypeId::MAP:
-		return BoundCastInfo(ListCast::ListToListCast, ListBoundCastData::BindListToListCast(input, source, target));
+		return BoundCastInfo(ListCast::ListToListCast, ListBoundCastData::BindListToListCast(input, source, target),
+		                     ListBoundCastData::InitListLocalState);
 	case LogicalTypeId::VARCHAR: {
 		auto varchar_type = LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR);
-		return BoundCastInfo(MapToVarcharCast, ListBoundCastData::BindListToListCast(input, source, varchar_type));
+		return BoundCastInfo(MapToVarcharCast, ListBoundCastData::BindListToListCast(input, source, varchar_type),
+		                     ListBoundCastData::InitListLocalState);
 	}
 	default:
 		return TryVectorNullCast;