duckdb 0.8.2-dev1791.0 → 0.8.2-dev1862.0

package/src/duckdb/src/include/duckdb/execution/window_executor.hpp

@@ -0,0 +1,313 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/window_executor.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/execution/window_segment_tree.hpp"
+#include "duckdb/planner/expression/bound_window_expression.hpp"
+#include "duckdb/common/vector_operations/vector_operations.hpp"
+
+namespace duckdb {
+
+struct WindowInputExpression {
+	static void PrepareInputExpression(Expression &expr, ExpressionExecutor &executor, DataChunk &chunk) {
+		vector<LogicalType> types;
+		types.push_back(expr.return_type);
+		executor.AddExpression(expr);
+
+		auto &allocator = executor.GetAllocator();
+		chunk.Initialize(allocator, types);
+	}
+
+	WindowInputExpression(optional_ptr<Expression> expr_p, ClientContext &context)
+	    : expr(expr_p), ptype(PhysicalType::INVALID), scalar(true), executor(context) {
+		if (expr) {
+			PrepareInputExpression(*expr, executor, chunk);
+			ptype = expr->return_type.InternalType();
+			scalar = expr->IsScalar();
+		}
+	}
+
+	void Execute(DataChunk &input_chunk) {
+		if (expr) {
+			chunk.Reset();
+			executor.Execute(input_chunk, chunk);
+			chunk.Verify();
+		}
+	}
+
+	template <typename T>
+	inline T GetCell(idx_t i) const {
+		D_ASSERT(!chunk.data.empty());
+		const auto data = FlatVector::GetData<T>(chunk.data[0]);
+		return data[scalar ? 0 : i];
+	}
+
+	inline bool CellIsNull(idx_t i) const {
+		D_ASSERT(!chunk.data.empty());
+		if (chunk.data[0].GetVectorType() == VectorType::CONSTANT_VECTOR) {
+			return ConstantVector::IsNull(chunk.data[0]);
+		}
+		return FlatVector::IsNull(chunk.data[0], i);
+	}
+
+	inline void CopyCell(Vector &target, idx_t target_offset) const {
+		D_ASSERT(!chunk.data.empty());
+		auto &source = chunk.data[0];
+		auto source_offset = scalar ? 0 : target_offset;
+		VectorOperations::Copy(source, target, source_offset + 1, source_offset, target_offset);
+	}
+
+	optional_ptr<Expression> expr;
+	PhysicalType ptype;
+	bool scalar;
+	ExpressionExecutor executor;
+	DataChunk chunk;
+};
+
+struct WindowInputColumn {
+	WindowInputColumn(Expression *expr_p, ClientContext &context, idx_t capacity_p)
+	    : input_expr(expr_p, context), count(0), capacity(capacity_p) {
+		if (input_expr.expr) {
+			target = make_uniq<Vector>(input_expr.chunk.data[0].GetType(), capacity);
+		}
+	}
+
+	void Append(DataChunk &input_chunk) {
+		if (input_expr.expr) {
+			const auto source_count = input_chunk.size();
+			D_ASSERT(count + source_count <= capacity);
+			if (!input_expr.scalar || !count) {
+				input_expr.Execute(input_chunk);
+				auto &source = input_expr.chunk.data[0];
+				VectorOperations::Copy(source, *target, source_count, 0, count);
+			}
+			count += source_count;
+		}
+	}
+
+	inline bool CellIsNull(idx_t i) const {
+		D_ASSERT(target);
+		D_ASSERT(i < count);
+		return FlatVector::IsNull(*target, input_expr.scalar ? 0 : i);
+	}
+
+	template <typename T>
+	inline T GetCell(idx_t i) const {
+		D_ASSERT(target);
+		D_ASSERT(i < count);
+		const auto data = FlatVector::GetData<T>(*target);
+		return data[input_expr.scalar ? 0 : i];
+	}
+
+	WindowInputExpression input_expr;
+
+private:
+	unique_ptr<Vector> target;
+	idx_t count;
+	idx_t capacity;
+};
+
+//	Column indexes of the bounds chunk
+enum WindowBounds : uint8_t { PARTITION_BEGIN, PARTITION_END, PEER_BEGIN, PEER_END, WINDOW_BEGIN, WINDOW_END };
+
+class WindowExecutorState {
+public:
+	WindowExecutorState() {};
+	virtual ~WindowExecutorState() {
+	}
+
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return reinterpret_cast<const TARGET &>(*this);
+	}
+};
+
+class WindowExecutor {
+public:
+	WindowExecutor(BoundWindowExpression &wexpr, ClientContext &context, const idx_t payload_count,
+	               const ValidityMask &partition_mask, const ValidityMask &order_mask);
+	virtual ~WindowExecutor() {
+	}
+
+	virtual void Sink(DataChunk &input_chunk, const idx_t input_idx, const idx_t total_count) {
+		range.Append(input_chunk);
+	}
+
+	virtual void Finalize() {
+	}
+
+	virtual unique_ptr<WindowExecutorState> GetExecutorState() const;
+
+	void Evaluate(idx_t row_idx, DataChunk &input_chunk, Vector &result, WindowExecutorState &lstate) const;
+
+protected:
+	// The function
+	BoundWindowExpression &wexpr;
+	ClientContext &context;
+	const idx_t payload_count;
+	const ValidityMask &partition_mask;
+	const ValidityMask &order_mask;
+
+	// Expression collections
+	DataChunk payload_collection;
+	ExpressionExecutor payload_executor;
+	DataChunk payload_chunk;
+
+	// evaluate RANGE expressions, if needed
+	WindowInputColumn range;
+
+	virtual void EvaluateInternal(WindowExecutorState &lstate, Vector &result, idx_t count, idx_t row_idx) const = 0;
+};
+
+class WindowAggregateExecutor : public WindowExecutor {
+public:
+	bool IsConstantAggregate();
+	bool IsCustomAggregate();
+
+	WindowAggregateExecutor(BoundWindowExpression &wexpr, ClientContext &context, const idx_t payload_count,
+	                        const ValidityMask &partition_mask, const ValidityMask &order_mask,
+	                        WindowAggregationMode mode);
+
+	void Sink(DataChunk &input_chunk, const idx_t input_idx, const idx_t total_count) override;
+	void Finalize() override;
+
+	unique_ptr<WindowExecutorState> GetExecutorState() const override;
+
+	const WindowAggregationMode mode;
+
+protected:
+	ExpressionExecutor filter_executor;
+	SelectionVector filter_sel;
+
+	// aggregate computation algorithm
+	unique_ptr<WindowAggregator> aggregator;
+
+	void EvaluateInternal(WindowExecutorState &lstate, Vector &result, idx_t count, idx_t row_idx) const override;
+};
+
+class WindowRowNumberExecutor : public WindowExecutor {
+public:
+	WindowRowNumberExecutor(BoundWindowExpression &wexpr, ClientContext &context, const idx_t payload_count,
+	                        const ValidityMask &partition_mask, const ValidityMask &order_mask);
+
+protected:
+	void EvaluateInternal(WindowExecutorState &lstate, Vector &result, idx_t count, idx_t row_idx) const override;
+};
+
+//	Base class for non-aggregate functions that use peer boundaries
+class WindowRankExecutor : public WindowExecutor {
+public:
+	WindowRankExecutor(BoundWindowExpression &wexpr, ClientContext &context, const idx_t payload_count,
+	                   const ValidityMask &partition_mask, const ValidityMask &order_mask);
+
+	unique_ptr<WindowExecutorState> GetExecutorState() const override;
+
+protected:
+	void EvaluateInternal(WindowExecutorState &lstate, Vector &result, idx_t count, idx_t row_idx) const override;
+};
+
+class WindowDenseRankExecutor : public WindowExecutor {
+public:
+	WindowDenseRankExecutor(BoundWindowExpression &wexpr, ClientContext &context, const idx_t payload_count,
+	                        const ValidityMask &partition_mask, const ValidityMask &order_mask);
+
+	unique_ptr<WindowExecutorState> GetExecutorState() const override;
+
+protected:
+	void EvaluateInternal(WindowExecutorState &lstate, Vector &result, idx_t count, idx_t row_idx) const override;
+};
+
+class WindowPercentRankExecutor : public WindowExecutor {
+public:
+	WindowPercentRankExecutor(BoundWindowExpression &wexpr, ClientContext &context, const idx_t payload_count,
+	                          const ValidityMask &partition_mask, const ValidityMask &order_mask);
+
+	unique_ptr<WindowExecutorState> GetExecutorState() const override;
+
+protected:
+	void EvaluateInternal(WindowExecutorState &lstate, Vector &result, idx_t count, idx_t row_idx) const override;
+};
+
+class WindowCumeDistExecutor : public WindowExecutor {
+public:
+	WindowCumeDistExecutor(BoundWindowExpression &wexpr, ClientContext &context, const idx_t payload_count,
+	                       const ValidityMask &partition_mask, const ValidityMask &order_mask);
+
+protected:
+	void EvaluateInternal(WindowExecutorState &lstate, Vector &result, idx_t count, idx_t row_idx) const override;
+};
+
+// Base class for non-aggregate functions that have a payload
+class WindowValueExecutor : public WindowExecutor {
+public:
+	WindowValueExecutor(BoundWindowExpression &wexpr, ClientContext &context, const idx_t payload_count,
+	                    const ValidityMask &partition_mask, const ValidityMask &order_mask);
+
+	void Sink(DataChunk &input_chunk, const idx_t input_idx, const idx_t total_count) override;
+
+protected:
+	// IGNORE NULLS
+	ValidityMask ignore_nulls;
+};
+
+//
+class WindowNtileExecutor : public WindowValueExecutor {
+public:
+	WindowNtileExecutor(BoundWindowExpression &wexpr, ClientContext &context, const idx_t payload_count,
+	                    const ValidityMask &partition_mask, const ValidityMask &order_mask);
+
+protected:
+	void EvaluateInternal(WindowExecutorState &lstate, Vector &result, idx_t count, idx_t row_idx) const override;
+};
+class WindowLeadLagExecutor : public WindowValueExecutor {
+public:
+	WindowLeadLagExecutor(BoundWindowExpression &wexpr, ClientContext &context, const idx_t payload_count,
+	                      const ValidityMask &partition_mask, const ValidityMask &order_mask);
+
+	unique_ptr<WindowExecutorState> GetExecutorState() const override;
+
+protected:
+	void EvaluateInternal(WindowExecutorState &lstate, Vector &result, idx_t count, idx_t row_idx) const override;
+};
+
+class WindowFirstValueExecutor : public WindowValueExecutor {
+public:
+	WindowFirstValueExecutor(BoundWindowExpression &wexpr, ClientContext &context, const idx_t payload_count,
+	                         const ValidityMask &partition_mask, const ValidityMask &order_mask);
+
+protected:
+	void EvaluateInternal(WindowExecutorState &lstate, Vector &result, idx_t count, idx_t row_idx) const override;
+};
+
+class WindowLastValueExecutor : public WindowValueExecutor {
+public:
+	WindowLastValueExecutor(BoundWindowExpression &wexpr, ClientContext &context, const idx_t payload_count,
+	                        const ValidityMask &partition_mask, const ValidityMask &order_mask);
+
+protected:
+	void EvaluateInternal(WindowExecutorState &lstate, Vector &result, idx_t count, idx_t row_idx) const override;
+};
+
+class WindowNthValueExecutor : public WindowValueExecutor {
+public:
+	WindowNthValueExecutor(BoundWindowExpression &wexpr, ClientContext &context, const idx_t payload_count,
+	                       const ValidityMask &partition_mask, const ValidityMask &order_mask);
+
+protected:
+	void EvaluateInternal(WindowExecutorState &lstate, Vector &result, idx_t count, idx_t row_idx) const override;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/window_segment_tree.hpp

@@ -16,20 +16,42 @@
 
 namespace duckdb {
 
-class WindowAggregateState {
+class WindowAggregatorState {
 public:
-	WindowAggregateState(AggregateObject aggr, const LogicalType &result_type_p, idx_t partition_count);
-	virtual ~WindowAggregateState();
+	WindowAggregatorState();
+	virtual ~WindowAggregatorState() {
+	}
+
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return reinterpret_cast<const TARGET &>(*this);
+	}
 
+	//! Allocator for aggregates
+	ArenaAllocator allocator;
+};
+
+class WindowAggregator {
+public:
+	WindowAggregator(AggregateObject aggr, const LogicalType &result_type_p, idx_t partition_count);
+	virtual ~WindowAggregator();
+
+	//	Build
 	virtual void Sink(DataChunk &payload_chunk, SelectionVector *filter_sel, idx_t filtered);
 	virtual void Finalize();
-	virtual void Compute(Vector &result, idx_t rid, idx_t start, idx_t end);
-	virtual void Evaluate(const idx_t *begins, const idx_t *ends, Vector &result, idx_t count);
 
-protected:
-	void AggregateInit();
-	void AggegateFinal(Vector &result, idx_t rid);
+	//	Probe
+	virtual unique_ptr<WindowAggregatorState> GetLocalState() const = 0;
+	virtual void Evaluate(WindowAggregatorState &lstate, const idx_t *begins, const idx_t *ends, Vector &result,
+	                      idx_t count) const = 0;
 
+protected:
 	AggregateObject aggr;
 	//! The result type of the window function
 	LogicalType result_type;
@@ -38,10 +60,6 @@ protected:
 	const idx_t partition_count;
 	//! The size of a single aggregate state
 	const idx_t state_size;
-	//! Data pointer that contains a single state, used for intermediate window segment aggregation
-	vector<data_t> state;
-	//! Reused result state container for the window functions
-	Vector statef;
 	//! Partition data chunk
 	DataChunk inputs;
 
@@ -49,23 +67,28 @@ protected:
 	vector<validity_t> filter_bits;
 	ValidityMask filter_mask;
 	idx_t filter_pos;
-
-	//! Allocator for aggregates
-	ArenaAllocator allocator;
+	//! The state used by the aggregator to build.
+	unique_ptr<WindowAggregatorState> gstate;
 };
 
-class WindowConstantAggregate : public WindowAggregateState {
+class WindowConstantAggregator : public WindowAggregator {
 public:
-	WindowConstantAggregate(AggregateObject aggr, const LogicalType &result_type_p, const ValidityMask &partition_mask,
-	                        const idx_t count);
-	~WindowConstantAggregate() override {
+	WindowConstantAggregator(AggregateObject aggr, const LogicalType &result_type_p, const ValidityMask &partition_mask,
+	                         const idx_t count);
+	~WindowConstantAggregator() override {
 	}
 
 	void Sink(DataChunk &payload_chunk, SelectionVector *filter_sel, idx_t filtered) override;
 	void Finalize() override;
-	void Evaluate(const idx_t *begins, const idx_t *ends, Vector &result, idx_t count) override;
+
+	unique_ptr<WindowAggregatorState> GetLocalState() const override;
+	void Evaluate(WindowAggregatorState &lstate, const idx_t *begins, const idx_t *ends, Vector &result,
+	              idx_t count) const override;
 
 private:
+	void AggregateInit();
+	void AggegateFinal(Vector &result, idx_t rid);
+
 	//! Partition starts
 	vector<idx_t> partition_offsets;
 	//! Aggregate results
@@ -74,25 +97,25 @@ private:
 	idx_t partition;
 	//! The current input row being built/read
 	idx_t row;
+	//! Data pointer that contains a single state, used for intermediate window segment aggregation
+	vector<data_t> state;
 	//! A vector of pointers to "state", used for intermediate window segment aggregation
 	Vector statep;
-	//! Shared SV for evaluation
-	SelectionVector matches;
+	//! Reused result state container for the window functions
+	Vector statef;
 };
 
-class WindowCustomAggregate : public WindowAggregateState {
+class WindowCustomAggregator : public WindowAggregator {
 public:
-	WindowCustomAggregate(AggregateObject aggr, const LogicalType &result_type_p, idx_t partition_count);
-	~WindowCustomAggregate() override;
+	WindowCustomAggregator(AggregateObject aggr, const LogicalType &result_type_p, idx_t partition_count);
+	~WindowCustomAggregator() override;
 
-	void Compute(Vector &result, idx_t rid, idx_t start, idx_t end) override;
-
-private:
-	//! The frame boundaries, used for the window functions
-	FrameBounds frame;
+	unique_ptr<WindowAggregatorState> GetLocalState() const override;
+	void Evaluate(WindowAggregatorState &lstate, const idx_t *begins, const idx_t *ends, Vector &result,
+	              idx_t count) const override;
 };
 
-class WindowSegmentTree : public WindowAggregateState {
+class WindowSegmentTree : public WindowAggregator {
 public:
 	using FrameBounds = std::pair<idx_t, idx_t>;
 
@@ -100,32 +123,19 @@ public:
 	~WindowSegmentTree() override;
 
 	void Finalize() override;
-	void Evaluate(const idx_t *begins, const idx_t *ends, Vector &result, idx_t count) override;
 
-private:
+	unique_ptr<WindowAggregatorState> GetLocalState() const override;
+	void Evaluate(WindowAggregatorState &lstate, const idx_t *begins, const idx_t *ends, Vector &result,
+	              idx_t count) const override;
+
+public:
 	void ConstructTree();
-	void ExtractFrame(idx_t begin, idx_t end, data_ptr_t current_state);
-	void FlushStates(bool combining);
-	void WindowSegmentValue(idx_t l_idx, idx_t begin, idx_t end, data_ptr_t current_state);
 
 	//! Use the combine API, if available
 	inline bool UseCombineAPI() const {
 		return mode < WindowAggregationMode::SEPARATE;
 	}
 
-	//! Input data chunk, used for leaf segment aggregation
-	DataChunk leaves;
-	//! The filtered rows in inputs.
-	SelectionVector filter_sel;
-	//! A vector of pointers to "state", used for intermediate window segment aggregation
-	Vector statep;
-	//! The frame boundaries, used for the window functions
-	FrameBounds frame;
-	//! Reused state pointers for combining segment tree levels
-	Vector statel;
-	//! Count of buffered values
-	idx_t flush_count;
-
 	//! The actual window segment tree: an array of aggregate states that represent all the intermediate nodes
 	unsafe_unique_array<data_t> levels_flat_native;
 	//! For each level, the starting location in the levels_flat_native array
@@ -134,12 +144,9 @@ private:
 	//! The total number of internal nodes of the tree, stored in levels_flat_native
 	idx_t internal_nodes;
 
-	//! Use the window API, if available
+	//! Use the combine API, if available
 	WindowAggregationMode mode;
 
-	//! Aggregate allocator
-	ArenaAllocator allocator;
-
 	// TREE_FANOUT needs to cleanly divide STANDARD_VECTOR_SIZE
 	static constexpr idx_t TREE_FANOUT = 16;
 };

package/src/duckdb/src/storage/compression/rle.cpp

@@ -166,8 +166,8 @@ struct RLECompressState : public CompressionState {
 	void WriteValue(T value, rle_count_t count, bool is_null) {
 		// write the RLE entry
 		auto handle_ptr = handle.Ptr() + RLEConstants::RLE_HEADER_SIZE;
-		auto data_pointer = (T *)handle_ptr;
-		auto index_pointer = (rle_count_t *)(handle_ptr + max_rle_count * sizeof(T));
+		auto data_pointer = reinterpret_cast<T *>(handle_ptr);
+		auto index_pointer = reinterpret_cast<rle_count_t *>(handle_ptr + max_rle_count * sizeof(T));
 		data_pointer[entry_count] = value;
 		index_pointer[entry_count] = count;
 		entry_count++;
@@ -257,7 +257,7 @@ struct RLEScanState : public SegmentScanState {
 
 	void Skip(ColumnSegment &segment, idx_t skip_count) {
 		auto data = handle.Ptr() + segment.GetBlockOffset();
-		auto index_pointer = (rle_count_t *)(data + rle_count_offset);
+		auto index_pointer = reinterpret_cast<rle_count_t *>(data + rle_count_offset);
 
 		for (idx_t i = 0; i < skip_count; i++) {
 			// assign the current value
@@ -292,14 +292,58 @@ void RLESkip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count) {
 	scan_state.Skip(segment, skip_count);
 }
 
+static bool CanEmitConstantVector(idx_t position, idx_t run_length, idx_t scan_count) {
+	if (scan_count != STANDARD_VECTOR_SIZE) {
+		// Only when we can fill an entire Vector can we emit a ConstantVector, because subsequent scans require the
+		// input Vector to be flat
+		return false;
+	}
+	D_ASSERT(position < run_length);
+	auto remaining_in_run = run_length - position;
+	// The amount of values left in this run are equal or greater than the amount of values we need to scan
+	return remaining_in_run >= scan_count;
+}
+
+template <class T>
+inline static void ForwardToNextRun(RLEScanState<T> &scan_state) {
+	// handled all entries in this RLE value
+	// move to the next entry
+	scan_state.entry_pos++;
+	scan_state.position_in_entry = 0;
+}
+
+template <class T>
+inline static bool ExhaustedRun(RLEScanState<T> &scan_state, rle_count_t *index_pointer) {
+	return scan_state.position_in_entry >= index_pointer[scan_state.entry_pos];
+}
+
+template <class T>
+static void RLEScanConstant(RLEScanState<T> &scan_state, rle_count_t *index_pointer, T *data_pointer, idx_t scan_count,
+                            Vector &result) {
+	result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	auto result_data = ConstantVector::GetData<T>(result);
+	result_data[0] = data_pointer[scan_state.entry_pos];
+	scan_state.position_in_entry += scan_count;
+	if (ExhaustedRun(scan_state, index_pointer)) {
+		ForwardToNextRun(scan_state);
+	}
+	return;
+}
+
 template <class T>
 void RLEScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
                     idx_t result_offset) {
 	auto &scan_state = state.scan_state->Cast<RLEScanState<T>>();
 
 	auto data = scan_state.handle.Ptr() + segment.GetBlockOffset();
-	auto data_pointer = (T *)(data + RLEConstants::RLE_HEADER_SIZE);
-	auto index_pointer = (rle_count_t *)(data + scan_state.rle_count_offset);
+	auto data_pointer = reinterpret_cast<T *>(data + RLEConstants::RLE_HEADER_SIZE);
+	auto index_pointer = reinterpret_cast<rle_count_t *>(data + scan_state.rle_count_offset);
+
+	// If we are scanning an entire Vector and it contains only a single run
+	if (CanEmitConstantVector(scan_state.position_in_entry, index_pointer[scan_state.entry_pos], scan_count)) {
+		RLEScanConstant<T>(scan_state, index_pointer, data_pointer, scan_count, result);
+		return;
+	}
 
 	auto result_data = FlatVector::GetData<T>(result);
 	result.SetVectorType(VectorType::FLAT_VECTOR);
@@ -307,18 +351,14 @@ void RLEScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_c
 		// assign the current value
 		result_data[result_offset + i] = data_pointer[scan_state.entry_pos];
 		scan_state.position_in_entry++;
-		if (scan_state.position_in_entry >= index_pointer[scan_state.entry_pos]) {
-			// handled all entries in this RLE value
-			// move to the next entry
-			scan_state.entry_pos++;
-			scan_state.position_in_entry = 0;
+		if (ExhaustedRun(scan_state, index_pointer)) {
+			ForwardToNextRun(scan_state);
 		}
 	}
 }
 
 template <class T>
 void RLEScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
-	// FIXME: emit constant vector if repetition of single value is >= scan_count
 	RLEScanPartial<T>(segment, state, scan_count, result, 0);
 }
 
@@ -331,7 +371,7 @@ void RLEFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id,
 	scan_state.Skip(segment, row_id);
 
 	auto data = scan_state.handle.Ptr() + segment.GetBlockOffset();
-	auto data_pointer = (T *)(data + RLEConstants::RLE_HEADER_SIZE);
+	auto data_pointer = reinterpret_cast<T *>(data + RLEConstants::RLE_HEADER_SIZE);
 	auto result_data = FlatVector::GetData<T>(result);
 	result_data[result_idx] = data_pointer[scan_state.entry_pos];
 }

package/src/duckdb/ub_src_core_functions_scalar_debug.cpp

@@ -0,0 +1,2 @@
+#include "src/core_functions/scalar/debug/vector_type.cpp"
+

package/src/duckdb/ub_src_execution.cpp

@@ -24,5 +24,7 @@
 
 #include "src/execution/reservoir_sample.cpp"
 
+#include "src/execution/window_executor.cpp"
+
 #include "src/execution/window_segment_tree.cpp"
 

package/src/duckdb/ub_src_execution_index_art.cpp

@@ -8,8 +8,6 @@
 
 #include "src/execution/index/art/leaf.cpp"
 
-#include "src/execution/index/art/leaf_segment.cpp"
-
 #include "src/execution/index/art/node4.cpp"
 
 #include "src/execution/index/art/node16.cpp"
@@ -18,8 +16,6 @@
 
 #include "src/execution/index/art/node256.cpp"
 
-#include "src/execution/index/art/swizzleable_pointer.cpp"
-
 #include "src/execution/index/art/prefix.cpp"
 
 #include "src/execution/index/art/art.cpp"

package/src/duckdb/src/execution/index/art/leaf_segment.cpp

@@ -1,52 +0,0 @@
-#include "duckdb/execution/index/art/leaf_segment.hpp"
-
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/node.hpp"
-
-namespace duckdb {
-
-LeafSegment &LeafSegment::New(ART &art, Node &node) {
-
-	node.SetPtr(Node::GetAllocator(art, NType::LEAF_SEGMENT).New());
-	node.type = (uint8_t)NType::LEAF_SEGMENT;
-
-	auto &segment = LeafSegment::Get(art, node);
-	segment.next.Reset();
-	return segment;
-}
-
-void LeafSegment::Free(ART &art, Node &node) {
-
-	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSwizzled());
-
-	// free next segment
-	auto next_segment = LeafSegment::Get(art, node).next;
-	Node::Free(art, next_segment);
-}
-
-LeafSegment &LeafSegment::Append(ART &art, uint32_t &count, const row_t row_id) {
-
-	reference<LeafSegment> segment(*this);
-	auto position = count % Node::LEAF_SEGMENT_SIZE;
-
-	// we need a new segment
-	if (position == 0 && count != 0) {
-		segment = LeafSegment::New(art, next);
-	}
-
-	segment.get().row_ids[position] = row_id;
-	count++;
-	return segment.get();
-}
-
-LeafSegment &LeafSegment::GetTail(const ART &art) {
-
-	reference<LeafSegment> segment(*this);
-	while (segment.get().next.IsSet()) {
-		segment = LeafSegment::Get(art, segment.get().next);
-	}
-	return segment.get();
-}
-
-} // namespace duckdb