duckdb 0.7.2-dev16.0 → 0.7.2-dev225.0

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

@@ -3,6 +3,8 @@
 #include "duckdb/common/types/null_value.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/vector_operations/aggregate_executor.hpp"
+#include "duckdb/common/types/bit.hpp"
+#include "duckdb/common/types/cast_helpers.hpp"
 
 namespace duckdb {
 
@@ -38,37 +40,32 @@ static AggregateFunction GetBitfieldUnaryAggregate(LogicalType type) {
 	}
 }
 
-struct BitAndOperation {
+struct BitwiseOperation {
 	template <class STATE>
 	static void Initialize(STATE *state) {
-		//  If there are no matching rows, BIT_AND() returns a null value.
+		//  If there are no matching rows, returns a null value.
 		state->is_set = false;
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
 	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
 		if (!state->is_set) {
+			OP::template Assign(state, input[idx]);
 			state->is_set = true;
-			state->value = input[idx];
 		} else {
-			state->value &= input[idx];
+			OP::template Execute(state, input[idx]);
 		}
 	}
 
 	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) {
-		//  count is not relevant
-		Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
+		OP::template Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
 	}
 
-	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] = state->value;
-		}
+	template <class INPUT_TYPE, class STATE>
+	static void Assign(STATE *state, INPUT_TYPE input) {
+		state->value = input;
 	}
 
 	template <class STATE, class OP>
@@ -79,9 +76,19 @@ struct BitAndOperation {
 		}
 		if (!target->is_set) {
 			// target is NULL, use source value directly.
-			*target = source;
+			OP::template Assign(target, source.value);
+			target->is_set = true;
+		} else {
+			OP::template Execute(target, source.value);
+		}
+	}
+
+	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->value &= source.value;
+			target[idx] = state->value;
 		}
 	}
 
@@ -90,36 +97,55 @@ struct BitAndOperation {
 	}
 };
 
-void BitAndFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet bit_and("bit_and");
-	for (auto &type : LogicalType::Integral()) {
-		bit_and.AddFunction(GetBitfieldUnaryAggregate<BitAndOperation>(type));
+struct BitAndOperation : public BitwiseOperation {
+	template <class INPUT_TYPE, class STATE>
+	static void Execute(STATE *state, INPUT_TYPE input) {
+		state->value &= input;
 	}
-	set.AddFunction(bit_and);
-}
+};
 
-struct BitOrOperation {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		//  If there are no matching rows, BIT_OR() returns a null value.
-		state->is_set = false;
+struct BitOrOperation : public BitwiseOperation {
+	template <class INPUT_TYPE, class STATE>
+	static void Execute(STATE *state, INPUT_TYPE input) {
+		state->value |= input;
 	}
+};
 
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		if (!state->is_set) {
-			state->is_set = true;
-			state->value = input[idx];
-		} else {
-			state->value |= input[idx];
-		}
+struct BitXorOperation : public BitwiseOperation {
+	template <class INPUT_TYPE, class STATE>
+	static void Execute(STATE *state, INPUT_TYPE input) {
+		state->value ^= input;
 	}
 
 	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) {
-		//  count is irrelevant
-		Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
+		for (idx_t i = 0; i < count; i++) {
+			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
+		}
+	}
+};
+
+struct BitStringBitwiseOperation : public BitwiseOperation {
+	template <class STATE>
+	static void Destroy(STATE *state) {
+		if (state->is_set && !state->value.IsInlined()) {
+			delete[] state->value.GetDataUnsafe();
+		}
+	}
+
+	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>
@@ -127,52 +153,31 @@ struct BitOrOperation {
 		if (!state->is_set) {
 			mask.SetInvalid(idx);
 		} else {
-			target[idx] = state->value;
+			target[idx] = StringVector::AddStringOrBlob(result, state->value);
 		}
 	}
+};
 
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (!source.is_set) {
-			// source is NULL, nothing to do.
-			return;
-		}
-		if (!target->is_set) {
-			// target is NULL, use source value directly.
-			*target = source;
-		} else {
-			target->value |= source.value;
-		}
-	}
+struct BitStringAndOperation : public BitStringBitwiseOperation {
 
-	static bool IgnoreNull() {
-		return true;
+	template <class INPUT_TYPE, class STATE>
+	static void Execute(STATE *state, INPUT_TYPE input) {
+		Bit::BitwiseAnd(input, state->value, state->value);
 	}
 };
 
-void BitOrFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet bit_or("bit_or");
-	for (auto &type : LogicalType::Integral()) {
-		bit_or.AddFunction(GetBitfieldUnaryAggregate<BitOrOperation>(type));
-	}
-	set.AddFunction(bit_or);
-}
+struct BitStringOrOperation : public BitStringBitwiseOperation {
 
-struct BitXorOperation {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		//  If there are no matching rows, BIT_XOR() returns a null value.
-		state->is_set = false;
+	template <class INPUT_TYPE, class STATE>
+	static void Execute(STATE *state, INPUT_TYPE input) {
+		Bit::BitwiseOr(input, state->value, state->value);
 	}
+};
 
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		if (!state->is_set) {
-			state->is_set = true;
-			state->value = input[idx];
-		} else {
-			state->value ^= input[idx];
-		}
+struct BitStringXorOperation : public BitStringBitwiseOperation {
+	template <class INPUT_TYPE, class STATE>
+	static void Execute(STATE *state, INPUT_TYPE input) {
+		Bit::BitwiseXor(input, state->value, state->value);
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
@@ -182,40 +187,39 @@ struct BitXorOperation {
 			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
 		}
 	}
+};
 
-	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] = state->value;
-		}
+void BitAndFun::RegisterFunction(BuiltinFunctions &set) {
+	AggregateFunctionSet bit_and("bit_and");
+	for (auto &type : LogicalType::Integral()) {
+		bit_and.AddFunction(GetBitfieldUnaryAggregate<BitAndOperation>(type));
 	}
 
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (!source.is_set) {
-			// source is NULL, nothing to do.
-			return;
-		}
-		if (!target->is_set) {
-			// target is NULL, use source value directly.
-			*target = source;
-		} else {
-			target->value ^= source.value;
-		}
-	}
+	bit_and.AddFunction(
+	    AggregateFunction::UnaryAggregateDestructor<BitState<string_t>, string_t, string_t, BitStringAndOperation>(
+	        LogicalType::BIT, LogicalType::BIT));
+	set.AddFunction(bit_and);
+}
 
-	static bool IgnoreNull() {
-		return true;
+void BitOrFun::RegisterFunction(BuiltinFunctions &set) {
+	AggregateFunctionSet bit_or("bit_or");
+	for (auto &type : LogicalType::Integral()) {
+		bit_or.AddFunction(GetBitfieldUnaryAggregate<BitOrOperation>(type));
 	}
-};
+	bit_or.AddFunction(
+	    AggregateFunction::UnaryAggregateDestructor<BitState<string_t>, string_t, string_t, BitStringOrOperation>(
+	        LogicalType::BIT, LogicalType::BIT));
+	set.AddFunction(bit_or);
+}
 
 void BitXorFun::RegisterFunction(BuiltinFunctions &set) {
 	AggregateFunctionSet bit_xor("bit_xor");
 	for (auto &type : LogicalType::Integral()) {
 		bit_xor.AddFunction(GetBitfieldUnaryAggregate<BitXorOperation>(type));
 	}
+	bit_xor.AddFunction(
+	    AggregateFunction::UnaryAggregateDestructor<BitState<string_t>, string_t, string_t, BitStringXorOperation>(
+	        LogicalType::BIT, LogicalType::BIT));
 	set.AddFunction(bit_xor);
 }
 

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

@@ -0,0 +1,261 @@
+#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/numeric_statistics.hpp"
+#include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/common/types/cast_helpers.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) {
+		return max - min + 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) {
+	idx_t val;
+	if (Hugeint::TryCast(max - min + 1, val)) {
+		return val;
+	} else {
+		throw OutOfRangeException("Range too large for bitstring aggregation");
+	}
+}
+
+unique_ptr<BaseStatistics> BitstringPropagateStats(ClientContext &context, BoundAggregateExpression &expr,
+                                                   FunctionData *bind_data,
+                                                   vector<unique_ptr<BaseStatistics>> &child_stats,
+                                                   NodeStatistics *node_stats) {
+
+	if (child_stats[0]) {
+		auto &numeric_stats = (NumericStatistics &)*child_stats[0];
+		if (numeric_stats.min.IsNull() || numeric_stats.max.IsNull()) {
+			return nullptr;
+		}
+		auto bind_agg_data = (BitstringAggBindData *)bind_data;
+		bind_agg_data->min = numeric_stats.min;
+		bind_agg_data->max = numeric_stats.max;
+	} else {
+		throw BinderException("Could not retrieve required statistics. Alternatively, try by providing the statistics "
+		                      "explicitly: BITSTRING_AGG(col, min, max) ");
+	}
+	return nullptr;
+}
+
+unique_ptr<FunctionData> BindBitstringAgg(ClientContext &context, AggregateFunction &function,
+                                          vector<unique_ptr<Expression>> &arguments) {
+
+	if (arguments.size() == 3) {
+		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/sum.cpp

@@ -52,9 +52,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;
 		}
 	}

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/sorted_aggregate_function.cpp

@@ -71,17 +71,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 +98,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 +111,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 +128,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 +286,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 +326,6 @@ struct SortedAggregateFunction {
 					global_sort->CompleteMergeRound(false);
 				}
 
-				auto &chunk = state->arg_buffer;
 				PayloadScanner scanner(*global_sort);
 				for (;;) {
 					chunk.Reset();

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;