duckdb 0.8.2-dev1764.0 → 0.8.2-dev1859.0

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

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

@@ -1,22 +0,0 @@
-#include "duckdb/execution/index/art/swizzleable_pointer.hpp"
-
-#include "duckdb/storage/meta_block_reader.hpp"
-
-namespace duckdb {
-
-SwizzleablePointer::SwizzleablePointer(MetaBlockReader &reader) {
-
-	idx_t block_id = reader.Read<block_id_t>();
-	offset = reader.Read<uint32_t>();
-	type = 0;
-
-	if (block_id == DConstants::INVALID_INDEX) {
-		swizzle_flag = 0;
-		return;
-	}
-
-	buffer_id = (uint32_t)block_id;
-	swizzle_flag = 1;
-}
-
-} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/index/art/leaf_segment.hpp

@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/art/leaf_segment.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-#pragma once
-
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/node.hpp"
-
-namespace duckdb {
-
-class LeafSegment {
-public:
-	//! The row IDs stored in this segment
-	row_t row_ids[Node::LEAF_SEGMENT_SIZE];
-	//! The pointer of the next segment, if the row IDs exceeds this segment
-	Node next;
-
-public:
-	//! Get a new leaf segment node, might cause a new buffer allocation, and initialize it
-	static LeafSegment &New(ART &art, Node &node);
-	//! Get a reference to the leaf segment
-	static inline LeafSegment &Get(const ART &art, const Node ptr) {
-		return *Node::GetAllocator(art, NType::LEAF_SEGMENT).Get<LeafSegment>(ptr);
-	}
-	//! Free the leaf segment and any subsequent ones
-	static void Free(ART &art, Node &node);
-
-	//! Append a row ID to the current segment, or create a new segment containing that row ID
-	LeafSegment &Append(ART &art, uint32_t &count, const row_t row_id);
-	//! Get the tail of a list of segments
-	LeafSegment &GetTail(const ART &art);
-};
-
-} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/index/art/swizzleable_pointer.hpp

@@ -1,58 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/art/swizzleable_pointer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-// classes
-class MetaBlockReader;
-
-// structs
-struct BlockPointer;
-
-//! SwizzleablePointer provides functions on a (possibly) swizzled pointer. If the swizzle flag is set, then the
-//! pointer points to a storage address (and has no type), otherwise the pointer has a type and stores
-//! other information (e.g., a buffer location)
-class SwizzleablePointer {
-public:
-	//! Constructs an empty SwizzleablePointer
-	SwizzleablePointer() : swizzle_flag(0), type(0), offset(0), buffer_id(0) {};
-	//! Constructs a swizzled pointer from a buffer ID and an offset
-	explicit SwizzleablePointer(MetaBlockReader &reader);
-	//! Constructs a non-swizzled pointer from a buffer ID and an offset
-	SwizzleablePointer(uint32_t offset, uint32_t buffer_id)
-	    : swizzle_flag(0), type(0), offset(offset), buffer_id(buffer_id) {};
-
-	//! The swizzle flag, set if swizzled, not set otherwise
-	uint8_t swizzle_flag : 1;
-	//! The type of the pointer, zero if not set
-	uint8_t type : 7;
-	//! The offset of a memory location
-	uint32_t offset : 24;
-	//! The buffer ID of a memory location
-	uint32_t buffer_id : 32;
-
-public:
-	//! Checks if the pointer is swizzled
-	inline bool IsSwizzled() const {
-		return swizzle_flag;
-	}
-	//! Returns true, if neither the swizzle flag nor the type is set, and false otherwise
-	inline bool IsSet() const {
-		return swizzle_flag || type;
-	}
-	//! Reset the pointer
-	inline void Reset() {
-		swizzle_flag = 0;
-		type = 0;
-	}
-};
-
-} // namespace duckdb