duckdb 0.8.2-dev161.0 → 0.8.2-dev1764.0

package/src/duckdb/src/execution/window_segment_tree.cpp

@@ -1,20 +1,23 @@
 #include "duckdb/execution/window_segment_tree.hpp"
 
-#include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/algorithm.hpp"
 #include "duckdb/common/helper.hpp"
+#include "duckdb/common/vector_operations/vector_operations.hpp"
+
+#include <utility>
 
 namespace duckdb {
 
 //===--------------------------------------------------------------------===//
 // WindowAggregateState
 //===--------------------------------------------------------------------===//
-
-WindowAggregateState::WindowAggregateState(AggregateObject aggr, const LogicalType &result_type_p)
-    : aggr(std::move(aggr)), result_type(result_type_p), state(aggr.function.state_size()),
-      statev(Value::POINTER(CastPointerToValue(state.data()))),
-      statep(Value::POINTER(CastPointerToValue(state.data()))) {
-	statev.SetVectorType(VectorType::FLAT_VECTOR); // Prevent conversion of results to constants
+WindowAggregateState::WindowAggregateState(AggregateObject aggr, const LogicalType &result_type_p,
+                                           idx_t partition_count_p)
+    : aggr(std::move(aggr)), result_type(result_type_p), partition_count(partition_count_p),
+      state_size(this->aggr.function.state_size()), state(state_size),
+      statef(Value::POINTER(CastPointerToValue(state.data()))), filter_pos(0),
+      allocator(Allocator::DefaultAllocator()) {
+	statef.SetVectorType(VectorType::FLAT_VECTOR); // Prevent conversion of results to constants
 }
 
 WindowAggregateState::~WindowAggregateState() {
@@ -25,15 +28,33 @@ void WindowAggregateState::AggregateInit() {
 }
 
 void WindowAggregateState::AggegateFinal(Vector &result, idx_t rid) {
-	AggregateInputData aggr_input_data(aggr.GetFunctionData(), Allocator::DefaultAllocator());
-	aggr.function.finalize(statev, aggr_input_data, result, 1, rid);
+	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
+	aggr.function.finalize(statef, aggr_input_data, result, 1, rid);
 
 	if (aggr.function.destructor) {
-		aggr.function.destructor(statev, aggr_input_data, 1);
+		aggr.function.destructor(statef, aggr_input_data, 1);
 	}
 }
 
 void WindowAggregateState::Sink(DataChunk &payload_chunk, SelectionVector *filter_sel, idx_t filtered) {
+	if (!inputs.ColumnCount() && payload_chunk.ColumnCount()) {
+		inputs.Initialize(Allocator::DefaultAllocator(), payload_chunk.GetTypes());
+	}
+	if (inputs.ColumnCount()) {
+		inputs.Append(payload_chunk, true);
+	}
+	if (filter_sel) {
+		//	Lazy instantiation
+		if (!filter_mask.IsMaskSet()) {
+			// 	Start with all invalid and set the ones that pass
+			filter_bits.resize(ValidityMask::ValidityMaskSize(partition_count), 0);
+			filter_mask.Initialize(filter_bits.data());
+		}
+		for (idx_t f = 0; f < filtered; ++f) {
+			filter_mask.SetValid(filter_pos + filter_sel->get_index(f));
+		}
+		filter_pos += payload_chunk.size();
+	}
 }
 
 void WindowAggregateState::Finalize() {
@@ -42,22 +63,36 @@ void WindowAggregateState::Finalize() {
 void WindowAggregateState::Compute(Vector &result, idx_t rid, idx_t start, idx_t end) {
 }
 
+void WindowAggregateState::Evaluate(const idx_t *begins, const idx_t *ends, Vector &result, idx_t count) {
+	auto &rmask = FlatVector::Validity(result);
+	for (idx_t i = 0; i < count; ++i) {
+		const auto begin = begins[i];
+		const auto end = ends[i];
+		if (begin >= end) {
+			rmask.SetInvalid(i);
+			continue;
+		}
+		Compute(result, i, begin, end);
+	}
+}
+
 //===--------------------------------------------------------------------===//
 // WindowConstantAggregate
 //===--------------------------------------------------------------------===//
 
 WindowConstantAggregate::WindowConstantAggregate(AggregateObject aggr, const LogicalType &result_type,
                                                  const ValidityMask &partition_mask, const idx_t count)
-    : WindowAggregateState(std::move(aggr), result_type), partition(0), row(0) {
+    : WindowAggregateState(std::move(aggr), result_type, count), partition(0), row(0),
+      statep(Value::POINTER(CastPointerToValue(state.data()))) {
+	matches.Initialize();
 
 	// Locate the partition boundaries
-	idx_t start = 0;
 	if (partition_mask.AllValid()) {
 		partition_offsets.emplace_back(0);
 	} else {
 		idx_t entry_idx;
 		idx_t shift;
-		while (start < count) {
+		for (idx_t start = 0; start < count;) {
 			partition_mask.GetEntryIndex(start, entry_idx, shift);
 
 			//	If start is aligned with the start of a block,
@@ -93,7 +128,7 @@ void WindowConstantAggregate::Sink(DataChunk &payload_chunk, SelectionVector *fi
 		inputs.Initialize(Allocator::DefaultAllocator(), payload_chunk.GetTypes());
 	}
 
-	AggregateInputData aggr_input_data(aggr.GetFunctionData(), Allocator::DefaultAllocator());
+	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
 	idx_t begin = 0;
 	idx_t filter_idx = 0;
 	auto partition_end = partition_offsets[partition + 1];
@@ -165,43 +200,88 @@ void WindowConstantAggregate::Finalize() {
 	row = 0;
 }
 
-void WindowConstantAggregate::Compute(Vector &target, idx_t rid, idx_t start, idx_t end) {
-	//	Find the partition containing [start, end)
-	while (start < partition_offsets[partition] || partition_offsets[partition + 1] <= start) {
-		++partition;
+void WindowConstantAggregate::Evaluate(const idx_t *begins, const idx_t *ends, Vector &target, idx_t count) {
+	//	Chunk up the constants and copy them one at a time
+	idx_t matched = 0;
+	idx_t target_offset = 0;
+	for (idx_t i = 0; i < count; ++i) {
+		const auto begin = begins[i];
+		//	Find the partition containing [begin, end)
+		while (partition_offsets[partition + 1] <= begin) {
+			//	Flush the previous partition's data
+			if (matched) {
+				VectorOperations::Copy(*results, target, matches, matched, 0, target_offset);
+				target_offset += matched;
+				matched = 0;
+			}
+			++partition;
+		}
+
+		matches.set_index(matched++, partition);
+	}
+
+	//	Flush the last partition
+	if (matched) {
+		VectorOperations::Copy(*results, target, matches, matched, 0, target_offset);
+	}
+}
+
+//===--------------------------------------------------------------------===//
+// WindowCustomAggregate
+//===--------------------------------------------------------------------===//
+WindowCustomAggregate::WindowCustomAggregate(AggregateObject aggr, const LogicalType &result_type, idx_t count)
+    : WindowAggregateState(std::move(aggr), result_type, count) {
+	// if we have a frame-by-frame method, share the single state
+	AggregateInit();
+}
+
+WindowCustomAggregate::~WindowCustomAggregate() {
+	if (aggr.function.destructor) {
+		AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
+		aggr.function.destructor(statef, aggr_input_data, 1);
 	}
-	D_ASSERT(partition_offsets[partition] <= start);
-	D_ASSERT(partition + 1 < partition_offsets.size());
-	D_ASSERT(end <= partition_offsets[partition + 1]);
+}
+
+void WindowCustomAggregate::Compute(Vector &result, idx_t rid, idx_t begin, idx_t end) {
+	// Frame boundaries
+	auto prev = frame;
+	frame = FrameBounds(begin, end);
 
-	// Copy the value
-	VectorOperations::Copy(*results, target, partition + 1, partition, rid);
+	// Extract the range
+	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
+	aggr.function.window(inputs.data.data(), filter_mask, aggr_input_data, inputs.ColumnCount(), state.data(), frame,
+	                     prev, result, rid, 0);
 }
 
 //===--------------------------------------------------------------------===//
 // WindowSegmentTree
 //===--------------------------------------------------------------------===//
-WindowSegmentTree::WindowSegmentTree(AggregateObject aggr_p, const LogicalType &result_type_p, DataChunk *input,
-                                     const ValidityMask &filter_mask_p, WindowAggregationMode mode_p)
-    : aggr(std::move(aggr_p)), result_type(result_type_p), state(aggr.function.state_size()),
-      statep(Value::POINTER(CastPointerToValue(state.data()))), frame(0, 0),
-      statev(Value::POINTER(CastPointerToValue(state.data()))), internal_nodes(0), input_ref(input),
-      filter_mask(filter_mask_p), mode(mode_p) {
-	statep.Flatten(input->size());
-	statev.SetVectorType(VectorType::FLAT_VECTOR); // Prevent conversion of results to constants
-
-	if (input_ref && input_ref->ColumnCount() > 0) {
-		filter_sel.Initialize(input->size());
-		inputs.Initialize(Allocator::DefaultAllocator(), input_ref->GetTypes());
-		// if we have a frame-by-frame method, share the single state
-		if (aggr.function.window && UseWindowAPI()) {
-			AggregateInit();
-			inputs.Reference(*input_ref);
-		} else {
-			inputs.SetCapacity(*input_ref);
-			if (aggr.function.combine && UseCombineAPI()) {
-				ConstructTree();
-			}
+WindowSegmentTree::WindowSegmentTree(AggregateObject aggr, const LogicalType &result_type, idx_t count,
+                                     WindowAggregationMode mode_p)
+    : WindowAggregateState(std::move(aggr), result_type, count),
+      statep(Value::POINTER(CastPointerToValue(state.data()))), frame(0, 0), statel(LogicalType::POINTER),
+      flush_count(0), internal_nodes(0), mode(mode_p), allocator(Allocator::DefaultAllocator()) {
+	state.resize(state_size * STANDARD_VECTOR_SIZE);
+	statep.Flatten(STANDARD_VECTOR_SIZE);
+
+	//	Build the finalise vector that just points to the result states
+	data_ptr_t state_ptr = state.data();
+	D_ASSERT(statef.GetVectorType() == VectorType::FLAT_VECTOR);
+	statef.SetVectorType(VectorType::CONSTANT_VECTOR);
+	statef.Flatten(STANDARD_VECTOR_SIZE);
+	auto fdata = FlatVector::GetData<data_ptr_t>(statef);
+	for (idx_t i = 0; i < STANDARD_VECTOR_SIZE; ++i) {
+		fdata[i] = state_ptr;
+		state_ptr += state_size;
+	}
+}
+
+void WindowSegmentTree::Finalize() {
+	if (inputs.ColumnCount() > 0) {
+		leaves.Initialize(Allocator::DefaultAllocator(), inputs.GetTypes());
+		filter_sel.Initialize();
+		if (aggr.function.combine && UseCombineAPI()) {
+			ConstructTree();
 		}
 	}
 }
@@ -211,13 +291,13 @@ WindowSegmentTree::~WindowSegmentTree() {
 		// nothing to destroy
 		return;
 	}
-	AggregateInputData aggr_input_data(aggr.GetFunctionData(), Allocator::DefaultAllocator());
+	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
 	// call the destructor for all the intermediate states
 	data_ptr_t address_data[STANDARD_VECTOR_SIZE];
 	Vector addresses(LogicalType::POINTER, data_ptr_cast(address_data));
 	idx_t count = 0;
 	for (idx_t i = 0; i < internal_nodes; i++) {
-		address_data[count++] = data_ptr_t(levels_flat_native.get() + i * state.size());
+		address_data[count++] = data_ptr_t(levels_flat_native.get() + i * state_size);
 		if (count == STANDARD_VECTOR_SIZE) {
 			aggr.function.destructor(addresses, aggr_input_data, count);
 			count = 0;
@@ -226,92 +306,92 @@ WindowSegmentTree::~WindowSegmentTree() {
 	if (count > 0) {
 		aggr.function.destructor(addresses, aggr_input_data, count);
 	}
-
-	if (aggr.function.window && UseWindowAPI()) {
-		aggr.function.destructor(statev, aggr_input_data, 1);
-	}
-}
-
-void WindowSegmentTree::AggregateInit() {
-	aggr.function.initialize(state.data());
 }
 
-void WindowSegmentTree::AggegateFinal(Vector &result, idx_t rid) {
-	AggregateInputData aggr_input_data(aggr.GetFunctionData(), Allocator::DefaultAllocator());
-	aggr.function.finalize(statev, aggr_input_data, result, 1, rid);
-
-	if (aggr.function.destructor) {
-		aggr.function.destructor(statev, aggr_input_data, 1);
+void WindowSegmentTree::FlushStates(bool combining) {
+	if (!flush_count) {
+		return;
 	}
-}
 
-void WindowSegmentTree::ExtractFrame(idx_t begin, idx_t end) {
-	const auto size = end - begin;
-
-	auto &chunk = *input_ref;
-	const auto input_count = input_ref->ColumnCount();
-	inputs.SetCardinality(size);
-	for (idx_t i = 0; i < input_count; ++i) {
-		auto &v = inputs.data[i];
-		auto &vec = chunk.data[i];
-		v.Slice(vec, begin, end);
-		v.Verify(size);
+	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
+	if (combining) {
+		statel.Verify(flush_count);
+		aggr.function.combine(statel, statep, aggr_input_data, flush_count);
+	} else {
+		leaves.Reference(inputs);
+		leaves.Slice(filter_sel, flush_count);
+		aggr.function.update(&leaves.data[0], aggr_input_data, leaves.ColumnCount(), statep, flush_count);
 	}
 
-	// Slice to any filtered rows
-	if (!filter_mask.AllValid()) {
-		idx_t filtered = 0;
+	flush_count = 0;
+}
+
+void WindowSegmentTree::ExtractFrame(idx_t begin, idx_t end, data_ptr_t state_ptr) {
+	const auto count = end - begin;
+	D_ASSERT(count <= TREE_FANOUT);
+
+	//	If we are not filtering,
+	//	just update the shared dictionary selection to the range
+	//	Otherwise set it to the input rows that pass the filter
+	auto states = FlatVector::GetData<data_ptr_t>(statep);
+	if (filter_mask.AllValid()) {
+		for (idx_t i = 0; i < count; ++i) {
+			states[flush_count] = state_ptr;
+			filter_sel.set_index(flush_count++, begin + i);
+			if (flush_count >= STANDARD_VECTOR_SIZE) {
+				FlushStates(false);
+			}
+		}
+	} else {
 		for (idx_t i = begin; i < end; ++i) {
 			if (filter_mask.RowIsValid(i)) {
-				filter_sel.set_index(filtered++, i - begin);
+				states[flush_count] = state_ptr;
+				filter_sel.set_index(flush_count++, i);
+				if (flush_count >= STANDARD_VECTOR_SIZE) {
+					FlushStates(false);
+				}
 			}
 		}
-		if (filtered != inputs.size()) {
-			inputs.Slice(filter_sel, filtered);
-		}
 	}
 }
 
-void WindowSegmentTree::WindowSegmentValue(idx_t l_idx, idx_t begin, idx_t end) {
+void WindowSegmentTree::WindowSegmentValue(idx_t l_idx, idx_t begin, idx_t end, data_ptr_t state_ptr) {
 	D_ASSERT(begin <= end);
 	if (begin == end || inputs.ColumnCount() == 0) {
 		return;
 	}
 
 	const auto count = end - begin;
-	Vector s(statep, 0, count);
 	if (l_idx == 0) {
-		ExtractFrame(begin, end);
-		AggregateInputData aggr_input_data(aggr.GetFunctionData(), Allocator::DefaultAllocator());
-		D_ASSERT(!inputs.data.empty());
-		aggr.function.update(&inputs.data[0], aggr_input_data, input_ref->ColumnCount(), s, inputs.size());
+		ExtractFrame(begin, end, state_ptr);
 	} else {
 		// find out where the states begin
-		data_ptr_t begin_ptr = levels_flat_native.get() + state.size() * (begin + levels_flat_start[l_idx - 1]);
+		data_ptr_t begin_ptr = levels_flat_native.get() + state_size * (begin + levels_flat_start[l_idx - 1]);
 		// set up a vector of pointers that point towards the set of states
-		Vector v(LogicalType::POINTER, count);
-		auto pdata = FlatVector::GetData<data_ptr_t>(v);
+		auto ldata = FlatVector::GetData<data_ptr_t>(statel);
+		auto pdata = FlatVector::GetData<data_ptr_t>(statep);
 		for (idx_t i = 0; i < count; i++) {
-			pdata[i] = begin_ptr + i * state.size();
+			pdata[flush_count] = state_ptr;
+			ldata[flush_count++] = begin_ptr;
+			begin_ptr += state_size;
+			if (flush_count >= STANDARD_VECTOR_SIZE) {
+				FlushStates(true);
+			}
 		}
-		v.Verify(count);
-		AggregateInputData aggr_input_data(aggr.GetFunctionData(), Allocator::DefaultAllocator());
-		aggr.function.combine(v, s, aggr_input_data, count);
 	}
 }
 
 void WindowSegmentTree::ConstructTree() {
-	D_ASSERT(input_ref);
 	D_ASSERT(inputs.ColumnCount() > 0);
 
 	// compute space required to store internal nodes of segment tree
 	internal_nodes = 0;
-	idx_t level_nodes = input_ref->size();
+	idx_t level_nodes = inputs.size();
 	do {
 		level_nodes = (level_nodes + (TREE_FANOUT - 1)) / TREE_FANOUT;
 		internal_nodes += level_nodes;
 	} while (level_nodes > 1);
-	levels_flat_native = make_unsafe_uniq_array<data_t>(internal_nodes * state.size());
+	levels_flat_native = make_unsafe_uniq_array<data_t>(internal_nodes * state_size);
 	levels_flat_start.push_back(0);
 
 	idx_t levels_flat_offset = 0;
@@ -319,14 +399,14 @@ void WindowSegmentTree::ConstructTree() {
 	// level 0 is data itself
 	idx_t level_size;
 	// iterate over the levels of the segment tree
-	while ((level_size = (level_current == 0 ? input_ref->size()
-	                                         : levels_flat_offset - levels_flat_start[level_current - 1])) > 1) {
+	while ((level_size =
+	            (level_current == 0 ? inputs.size() : levels_flat_offset - levels_flat_start[level_current - 1])) > 1) {
 		for (idx_t pos = 0; pos < level_size; pos += TREE_FANOUT) {
 			// compute the aggregate for this entry in the segment tree
-			AggregateInit();
-			WindowSegmentValue(level_current, pos, MinValue(level_size, pos + TREE_FANOUT));
-
-			memcpy(levels_flat_native.get() + (levels_flat_offset * state.size()), state.data(), state.size());
+			data_ptr_t state_ptr = levels_flat_native.get() + (levels_flat_offset * state_size);
+			aggr.function.initialize(state_ptr);
+			WindowSegmentValue(level_current, pos, MinValue(level_size, pos + TREE_FANOUT), state_ptr);
+			FlushStates(level_current > 0);
 
 			levels_flat_offset++;
 		}
@@ -341,52 +421,129 @@ void WindowSegmentTree::ConstructTree() {
 	}
 }
 
-void WindowSegmentTree::Compute(Vector &result, idx_t rid, idx_t begin, idx_t end) {
-	D_ASSERT(input_ref);
+void WindowSegmentTree::Evaluate(const idx_t *begins, const idx_t *ends, Vector &result, idx_t count) {
+	const auto cant_combine = (!aggr.function.combine || !UseCombineAPI());
+	auto fdata = FlatVector::GetData<data_ptr_t>(statef);
+
+	//	First pass: aggregate the segment tree nodes
+	//	Share adjacent identical states
+	//  We do this first because we want to share only tree aggregations
+	idx_t prev_begin = 1;
+	idx_t prev_end = 0;
+	auto ldata = FlatVector::GetData<data_ptr_t>(statel);
+	auto pdata = FlatVector::GetData<data_ptr_t>(statep);
+	data_ptr_t prev_state = nullptr;
+	for (idx_t rid = 0; rid < count; ++rid) {
+		auto state_ptr = fdata[rid];
+		aggr.function.initialize(state_ptr);
+
+		if (cant_combine) {
+			// Make sure we initialise all states
+			continue;
+		}
 
-	// If we have a window function, use that
-	if (aggr.function.window && UseWindowAPI()) {
-		// Frame boundaries
-		auto prev = frame;
-		frame = FrameBounds(begin, end);
+		auto begin = begins[rid];
+		auto end = ends[rid];
+		if (begin >= end) {
+			continue;
+		}
 
-		// Extract the range
-		AggregateInputData aggr_input_data(aggr.GetFunctionData(), Allocator::DefaultAllocator());
-		aggr.function.window(input_ref->data.data(), filter_mask, aggr_input_data, inputs.ColumnCount(), state.data(),
-		                     frame, prev, result, rid, 0);
-		return;
-	}
+		//	Skip level 0
+		idx_t l_idx = 0;
+		for (; l_idx < levels_flat_start.size() + 1; l_idx++) {
+			idx_t parent_begin = begin / TREE_FANOUT;
+			idx_t parent_end = end / TREE_FANOUT;
+			if (prev_state && l_idx == 1 && begin == prev_begin && end == prev_end) {
+				//	Just combine the previous top level result
+				ldata[flush_count] = prev_state;
+				pdata[flush_count] = state_ptr;
+				if (++flush_count >= STANDARD_VECTOR_SIZE) {
+					FlushStates(true);
+				}
+				break;
+			}
 
-	AggregateInit();
+			if (l_idx == 1) {
+				prev_state = state_ptr;
+				prev_begin = begin;
+				prev_end = end;
+			}
 
-	// Aggregate everything at once if we can't combine states
-	if (!aggr.function.combine || !UseCombineAPI()) {
-		WindowSegmentValue(0, begin, end);
-		AggegateFinal(result, rid);
-		return;
+			if (parent_begin == parent_end) {
+				if (l_idx) {
+					WindowSegmentValue(l_idx, begin, end, state_ptr);
+				}
+				break;
+			}
+			idx_t group_begin = parent_begin * TREE_FANOUT;
+			if (begin != group_begin) {
+				if (l_idx) {
+					WindowSegmentValue(l_idx, begin, group_begin + TREE_FANOUT, state_ptr);
+				}
+				parent_begin++;
+			}
+			idx_t group_end = parent_end * TREE_FANOUT;
+			if (end != group_end) {
+				if (l_idx) {
+					WindowSegmentValue(l_idx, group_end, end, state_ptr);
+				}
+			}
+			begin = parent_begin;
+			end = parent_end;
+		}
 	}
+	FlushStates(true);
+
+	//	Second pass: aggregate the ragged leaves
+	//	(or everything if we can't combine)
+	for (idx_t rid = 0; rid < count; ++rid) {
+		auto state_ptr = fdata[rid];
 
-	for (idx_t l_idx = 0; l_idx < levels_flat_start.size() + 1; l_idx++) {
+		const auto begin = begins[rid];
+		const auto end = ends[rid];
+		if (begin >= end) {
+			continue;
+		}
+
+		// Aggregate everything at once if we can't combine states
 		idx_t parent_begin = begin / TREE_FANOUT;
 		idx_t parent_end = end / TREE_FANOUT;
-		if (parent_begin == parent_end) {
-			WindowSegmentValue(l_idx, begin, end);
-			break;
+		if (parent_begin == parent_end || cant_combine) {
+			WindowSegmentValue(0, begin, end, state_ptr);
+			continue;
 		}
+
 		idx_t group_begin = parent_begin * TREE_FANOUT;
 		if (begin != group_begin) {
-			WindowSegmentValue(l_idx, begin, group_begin + TREE_FANOUT);
+			WindowSegmentValue(0, begin, group_begin + TREE_FANOUT, state_ptr);
 			parent_begin++;
 		}
 		idx_t group_end = parent_end * TREE_FANOUT;
 		if (end != group_end) {
-			WindowSegmentValue(l_idx, group_end, end);
+			WindowSegmentValue(0, group_end, end, state_ptr);
 		}
-		begin = parent_begin;
-		end = parent_end;
 	}
+	FlushStates(false);
+
+	//	Finalise the result aggregates
+	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
+	aggr.function.finalize(statef, aggr_input_data, result, count, 0);
+
+	//	Destruct the result aggregates
+	if (aggr.function.destructor) {
+		aggr.function.destructor(statef, aggr_input_data, count);
+	}
+
+	//	Set the validity mask on  the invalid rows
+	auto &rmask = FlatVector::Validity(result);
+	for (idx_t rid = 0; rid < count; ++rid) {
+		const auto begin = begins[rid];
+		const auto end = ends[rid];
 
-	AggegateFinal(result, rid);
+		if (begin >= end) {
+			rmask.SetInvalid(rid);
+		}
+	}
 }
 
 } // namespace duckdb

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

@@ -374,7 +374,8 @@ struct SortedAggregateFunction {
 
 		// State variables
 		auto bind_info = order_bind.bind_info.get();
-		AggregateInputData aggr_bind_info(bind_info, Allocator::DefaultAllocator());
+		ArenaAllocator allocator(Allocator::DefaultAllocator());
+		AggregateInputData aggr_bind_info(bind_info, allocator);
 
 		// Inner aggregate APIs
 		auto initialize = order_bind.function.initialize;

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

@@ -1,3 +1,6 @@
+#include "duckdb/common/hugeint.hpp"
+#include "duckdb/common/operator/cast_operators.hpp"
+#include "duckdb/common/types.hpp"
 #include "duckdb/function/cast/default_casts.hpp"
 #include "duckdb/function/cast/vector_cast_helpers.hpp"
 
@@ -6,9 +9,38 @@ namespace duckdb {
 BoundCastInfo DefaultCasts::BitCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
 	// now switch on the result type
 	switch (target.id()) {
+	// Numerics
+	case LogicalTypeId::BOOLEAN:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, bool, CastFromBitToNumeric>);
+	case LogicalTypeId::TINYINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, int8_t, CastFromBitToNumeric>);
+	case LogicalTypeId::SMALLINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, int16_t, CastFromBitToNumeric>);
+	case LogicalTypeId::INTEGER:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, int32_t, CastFromBitToNumeric>);
+	case LogicalTypeId::BIGINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, int64_t, CastFromBitToNumeric>);
+	case LogicalTypeId::UTINYINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, uint8_t, CastFromBitToNumeric>);
+	case LogicalTypeId::USMALLINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, uint16_t, CastFromBitToNumeric>);
+	case LogicalTypeId::UINTEGER:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, uint32_t, CastFromBitToNumeric>);
+	case LogicalTypeId::UBIGINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, uint64_t, CastFromBitToNumeric>);
+	case LogicalTypeId::HUGEINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, hugeint_t, CastFromBitToNumeric>);
+	case LogicalTypeId::FLOAT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, float, CastFromBitToNumeric>);
+	case LogicalTypeId::DOUBLE:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, double, CastFromBitToNumeric>);
+
+	case LogicalTypeId::BLOB:
+		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, CastFromBitToBlob>);
+
 	case LogicalTypeId::VARCHAR:
-		// bit to varchar
-		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, duckdb::CastFromBit>);
+		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, CastFromBitToString>);
+
 	default:
 		return DefaultCasts::TryVectorNullCast;
 	}

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

@@ -11,6 +11,9 @@ BoundCastInfo DefaultCasts::BlobCastSwitch(BindCastInput &input, const LogicalTy
 		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, duckdb::CastFromBlob>);
 	case LogicalTypeId::AGGREGATE_STATE:
 		return DefaultCasts::ReinterpretCast;
+	case LogicalTypeId::BIT:
+		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, duckdb::CastFromBlobToBit>);
+
 	default:
 		return DefaultCasts::TryVectorNullCast;
 	}

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

@@ -37,6 +37,8 @@ static BoundCastInfo InternalNumericCastSwitch(const LogicalType &source, const
 		return BoundCastInfo(&VectorCastHelpers::ToDecimalCast<SRC>);
 	case LogicalTypeId::VARCHAR:
 		return BoundCastInfo(&VectorCastHelpers::StringCast<SRC, duckdb::StringCast>);
+	case LogicalTypeId::BIT:
+		return BoundCastInfo(&VectorCastHelpers::StringCast<SRC, duckdb::NumericTryCastToBit>);
 	default:
 		return DefaultCasts::TryVectorNullCast;
 	}

package/src/duckdb/src/function/function.cpp

@@ -94,6 +94,8 @@ void BuiltinFunctions::Initialize() {
 
 	RegisterDistributiveAggregates();
 
+	RegisterCompressedMaterializationFunctions();
+
 	RegisterGenericFunctions();
 	RegisterOperators();
 	RegisterSequenceFunctions();
@@ -111,7 +113,7 @@ void BuiltinFunctions::Initialize() {
 hash_t BaseScalarFunction::Hash() const {
 	hash_t hash = return_type.Hash();
 	for (auto &arg : arguments) {
-		duckdb::CombineHash(hash, arg.Hash());
+		hash = duckdb::CombineHash(hash, arg.Hash());
 	}
 	return hash;
 }