duckdb 0.10.1-dev9.0 → 0.10.2-dev0.0

package/src/duckdb/src/planner/subquery/rewrite_correlated_expressions.cpp

@@ -9,6 +9,7 @@
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/tableref/bound_joinref.hpp"
 #include "duckdb/planner/operator/logical_dependent_join.hpp"
+#include "duckdb/planner/tableref/bound_subqueryref.hpp"
 
 namespace duckdb {
 
@@ -69,6 +70,20 @@ unique_ptr<Expression> RewriteCorrelatedExpressions::VisitReplace(BoundColumnRef
 	return nullptr;
 }
 
+//! Helper class used to recursively rewrite correlated expressions within nested subqueries.
+class RewriteCorrelatedRecursive : public BoundNodeVisitor {
+public:
+	RewriteCorrelatedRecursive(ColumnBinding base_binding, column_binding_map_t<idx_t> &correlated_map);
+
+	void VisitBoundTableRef(BoundTableRef &ref) override;
+	void VisitExpression(unique_ptr<Expression> &expression) override;
+
+	void RewriteCorrelatedSubquery(Binder &binder, BoundQueryNode &subquery);
+
+	ColumnBinding base_binding;
+	column_binding_map_t<idx_t> &correlated_map;
+};
+
 unique_ptr<Expression> RewriteCorrelatedExpressions::VisitReplace(BoundSubqueryExpression &expr,
                                                                   unique_ptr<Expression> *expr_ptr) {
 	if (!expr.IsCorrelated()) {
@@ -76,19 +91,19 @@ unique_ptr<Expression> RewriteCorrelatedExpressions::VisitReplace(BoundSubqueryE
 	}
 	// subquery detected within this subquery
 	// recursively rewrite it using the RewriteCorrelatedRecursive class
-	RewriteCorrelatedRecursive rewrite(expr, base_binding, correlated_map);
-	rewrite.RewriteCorrelatedSubquery(expr);
+	RewriteCorrelatedRecursive rewrite(base_binding, correlated_map);
+	rewrite.RewriteCorrelatedSubquery(*expr.binder, *expr.subquery);
 	return nullptr;
 }
 
-RewriteCorrelatedExpressions::RewriteCorrelatedRecursive::RewriteCorrelatedRecursive(
-    BoundSubqueryExpression &parent, ColumnBinding base_binding, column_binding_map_t<idx_t> &correlated_map)
-    : parent(parent), base_binding(base_binding), correlated_map(correlated_map) {
+RewriteCorrelatedRecursive::RewriteCorrelatedRecursive(ColumnBinding base_binding,
+                                                       column_binding_map_t<idx_t> &correlated_map)
+    : base_binding(base_binding), correlated_map(correlated_map) {
 }
 
-void RewriteCorrelatedExpressions::RewriteCorrelatedRecursive::RewriteJoinRefRecursive(BoundTableRef &ref) {
-	// recursively rewrite bindings in the correlated columns for the table ref and all the children
+void RewriteCorrelatedRecursive::VisitBoundTableRef(BoundTableRef &ref) {
 	if (ref.type == TableReferenceType::JOIN) {
+		// rewrite correlated columns in child joins
 		auto &bound_join = ref.Cast<BoundJoinRef>();
 		for (auto &corr : bound_join.correlated_columns) {
 			auto entry = correlated_map.find(corr.binding);
@@ -96,39 +111,30 @@ void RewriteCorrelatedExpressions::RewriteCorrelatedRecursive::RewriteJoinRefRec
 				corr.binding = ColumnBinding(base_binding.table_index, base_binding.column_index + entry->second);
 			}
 		}
-		RewriteJoinRefRecursive(*bound_join.left);
-		RewriteJoinRefRecursive(*bound_join.right);
+	} else if (ref.type == TableReferenceType::SUBQUERY) {
+		auto &subquery = ref.Cast<BoundSubqueryRef>();
+		RewriteCorrelatedSubquery(*subquery.binder, *subquery.subquery);
+		return;
 	}
+	// visit the children of the table ref
+	BoundNodeVisitor::VisitBoundTableRef(ref);
 }
 
-void RewriteCorrelatedExpressions::RewriteCorrelatedRecursive::RewriteCorrelatedSubquery(
-    BoundSubqueryExpression &expr) {
+void RewriteCorrelatedRecursive::RewriteCorrelatedSubquery(Binder &binder, BoundQueryNode &subquery) {
 	// rewrite the binding in the correlated list of the subquery)
-	for (auto &corr : expr.binder->correlated_columns) {
+	for (auto &corr : binder.correlated_columns) {
 		auto entry = correlated_map.find(corr.binding);
 		if (entry != correlated_map.end()) {
 			corr.binding = ColumnBinding(base_binding.table_index, base_binding.column_index + entry->second);
 		}
 	}
-	// TODO: Cleanup and find a better way to do this
-	auto &node = *expr.subquery;
-	if (node.type == QueryNodeType::SELECT_NODE) {
-		// Found an unplanned select node, need to update column bindings correlated columns in the from tables
-		auto &bound_select = node.Cast<BoundSelectNode>();
-		if (bound_select.from_table) {
-			BoundTableRef &table_ref = *bound_select.from_table;
-			RewriteJoinRefRecursive(table_ref);
-		}
-	}
-	// now rewrite any correlated BoundColumnRef expressions inside the subquery
-	ExpressionIterator::EnumerateQueryNodeChildren(*expr.subquery,
-	                                               [&](Expression &child) { RewriteCorrelatedExpressions(child); });
+	VisitBoundQueryNode(subquery);
 }
 
-void RewriteCorrelatedExpressions::RewriteCorrelatedRecursive::RewriteCorrelatedExpressions(Expression &child) {
-	if (child.type == ExpressionType::BOUND_COLUMN_REF) {
+void RewriteCorrelatedRecursive::VisitExpression(unique_ptr<Expression> &expression) {
+	if (expression->type == ExpressionType::BOUND_COLUMN_REF) {
 		// bound column reference
-		auto &bound_colref = child.Cast<BoundColumnRefExpression>();
+		auto &bound_colref = expression->Cast<BoundColumnRefExpression>();
 		if (bound_colref.depth == 0) {
 			// not a correlated column, ignore
 			return;
@@ -142,13 +148,13 @@ void RewriteCorrelatedExpressions::RewriteCorrelatedRecursive::RewriteCorrelated
 			bound_colref.binding = ColumnBinding(base_binding.table_index, base_binding.column_index + entry->second);
 			bound_colref.depth--;
 		}
-	} else if (child.type == ExpressionType::SUBQUERY) {
+	} else if (expression->type == ExpressionType::SUBQUERY) {
 		// we encountered another subquery: rewrite recursively
-		D_ASSERT(child.GetExpressionClass() == ExpressionClass::BOUND_SUBQUERY);
-		auto &bound_subquery = child.Cast<BoundSubqueryExpression>();
-		RewriteCorrelatedRecursive rewrite(bound_subquery, base_binding, correlated_map);
-		rewrite.RewriteCorrelatedSubquery(bound_subquery);
+		auto &bound_subquery = expression->Cast<BoundSubqueryExpression>();
+		RewriteCorrelatedSubquery(*bound_subquery.binder, *bound_subquery.subquery);
 	}
+	// recurse into the children of this subquery
+	BoundNodeVisitor::VisitExpression(expression);
 }
 
 RewriteCountAggregates::RewriteCountAggregates(column_binding_map_t<idx_t> &replacement_map)

package/src/duckdb/src/planner/subquery/ub_duckdb_planner_subquery.cpp

@@ -0,0 +1,4 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/planner/subquery/flatten_dependent_join.cpp>
+#include </Users/carlo/duckdb/src/planner/subquery/has_correlated_expressions.cpp>
+#include </Users/carlo/duckdb/src/planner/subquery/rewrite_correlated_expressions.cpp>

package/src/duckdb/src/planner/ub_duckdb_planner.cpp

@@ -0,0 +1,15 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/planner/bound_result_modifier.cpp>
+#include </Users/carlo/duckdb/src/planner/bound_parameter_map.cpp>
+#include </Users/carlo/duckdb/src/planner/expression_iterator.cpp>
+#include </Users/carlo/duckdb/src/planner/expression.cpp>
+#include </Users/carlo/duckdb/src/planner/table_binding.cpp>
+#include </Users/carlo/duckdb/src/planner/expression_binder.cpp>
+#include </Users/carlo/duckdb/src/planner/joinside.cpp>
+#include </Users/carlo/duckdb/src/planner/logical_operator.cpp>
+#include </Users/carlo/duckdb/src/planner/binder.cpp>
+#include </Users/carlo/duckdb/src/planner/bind_context.cpp>
+#include </Users/carlo/duckdb/src/planner/planner.cpp>
+#include </Users/carlo/duckdb/src/planner/pragma_handler.cpp>
+#include </Users/carlo/duckdb/src/planner/logical_operator_visitor.cpp>
+#include </Users/carlo/duckdb/src/planner/table_filter.cpp>

package/src/duckdb/src/storage/arena_allocator.cpp

@@ -72,6 +72,7 @@ data_ptr_t ArenaAllocator::Allocate(idx_t len) {
 			tail = new_chunk.get();
 		}
 		head = std::move(new_chunk);
+		allocated_size += current_capacity;
 	}
 	D_ASSERT(head->current_position + len <= head->maximum_size);
 	auto result = head->data.get() + head->current_position;
@@ -123,12 +124,14 @@ void ArenaAllocator::Reset() {
 		head->current_position = 0;
 		head->prev = nullptr;
 	}
+	allocated_size = 0;
 }
 
 void ArenaAllocator::Destroy() {
 	head = nullptr;
 	tail = nullptr;
 	current_capacity = ARENA_ALLOCATOR_INITIAL_CAPACITY;
+	allocated_size = 0;
 }
 
 void ArenaAllocator::Move(ArenaAllocator &other) {
@@ -136,6 +139,7 @@ void ArenaAllocator::Move(ArenaAllocator &other) {
 	other.tail = tail;
 	other.head = std::move(head);
 	other.current_capacity = current_capacity;
+	other.allocated_size = allocated_size;
 	Destroy();
 }
 
@@ -163,4 +167,9 @@ idx_t ArenaAllocator::SizeInBytes() const {
 	return total_size;
 }
 
+idx_t ArenaAllocator::AllocationSize() const {
+	D_ASSERT(head || allocated_size == 0);
+	return allocated_size;
+}
+
 } // namespace duckdb

package/src/duckdb/src/storage/buffer/block_handle.cpp

@@ -31,7 +31,12 @@ BlockHandle::BlockHandle(BlockManager &block_manager, block_id_t block_id_p, Mem
 BlockHandle::~BlockHandle() { // NOLINT: allow internal exceptions
 	// being destroyed, so any unswizzled pointers are just binary junk now.
 	unswizzled = nullptr;
-	auto &buffer_manager = block_manager.buffer_manager;
+	if (buffer && buffer->type != FileBufferType::TINY_BUFFER) {
+		// we kill the latest version in the eviction queue
+		auto &buffer_manager = block_manager.buffer_manager;
+		buffer_manager.GetBufferPool().IncrementDeadNodes();
+	}
+
 	// no references remain to this block: erase
 	if (buffer && state == BlockState::BLOCK_LOADED) {
 		D_ASSERT(memory_charge.size > 0);
@@ -41,7 +46,7 @@ BlockHandle::~BlockHandle() { // NOLINT: allow internal exceptions
 	} else {
 		D_ASSERT(memory_charge.size == 0);
 	}
-	buffer_manager.GetBufferPool().PurgeQueue();
+
 	block_manager.UnregisterBlock(block_id, can_destroy);
 }
 

package/src/duckdb/src/storage/buffer/block_manager.cpp

@@ -35,8 +35,8 @@ shared_ptr<BlockHandle> BlockManager::ConvertToPersistent(block_id_t block_id, s
 	D_ASSERT(old_block->state == BlockState::BLOCK_LOADED);
 	D_ASSERT(old_block->buffer);
 
-	// Temp buffers can be larger than the storage block size. But persistent buffers
-	// cannot.
+	// Temp buffers can be larger than the storage block size.
+	// But persistent buffers cannot.
 	D_ASSERT(old_block->buffer->AllocSize() <= Storage::BLOCK_ALLOC_SIZE);
 
 	// register a block with the new block id
@@ -60,7 +60,11 @@ shared_ptr<BlockHandle> BlockManager::ConvertToPersistent(block_id_t block_id, s
 	// persist the new block to disk
 	Write(*new_block->buffer, block_id);
 
-	buffer_manager.GetBufferPool().AddToEvictionQueue(new_block);
+	// potentially purge the queue
+	auto purge_queue = buffer_manager.GetBufferPool().AddToEvictionQueue(new_block);
+	if (purge_queue) {
+		buffer_manager.GetBufferPool().PurgeQueue();
+	}
 
 	return new_block;
 }

package/src/duckdb/src/storage/buffer/buffer_pool.cpp

@@ -35,8 +35,8 @@ shared_ptr<BlockHandle> BufferEvictionNode::TryGetBlockHandle() {
 }
 
 BufferPool::BufferPool(idx_t maximum_memory)
-    : current_memory(0), maximum_memory(maximum_memory), queue(make_uniq<EvictionQueue>()), queue_insertions(0),
-      temporary_memory_manager(make_uniq<TemporaryMemoryManager>()) {
+    : current_memory(0), maximum_memory(maximum_memory), queue(make_uniq<EvictionQueue>()),
+      temporary_memory_manager(make_uniq<TemporaryMemoryManager>()), evict_queue_insertions(0), total_dead_nodes(0) {
 	for (idx_t i = 0; i < MEMORY_TAG_COUNT; i++) {
 		memory_usage_per_tag[i] = 0;
 	}
@@ -44,16 +44,26 @@ BufferPool::BufferPool(idx_t maximum_memory)
 BufferPool::~BufferPool() {
 }
 
-void BufferPool::AddToEvictionQueue(shared_ptr<BlockHandle> &handle) {
-	constexpr int INSERT_INTERVAL = 1024;
+bool BufferPool::AddToEvictionQueue(shared_ptr<BlockHandle> &handle) {
+
+	// The block handle is locked during this operation (Unpin),
+	// or the block handle is still a local variable (ConvertToPersistent)
 
 	D_ASSERT(handle->readers == 0);
-	handle->eviction_timestamp++;
-	// After each 1024 insertions, run through the queue and purge.
-	if ((++queue_insertions % INSERT_INTERVAL) == 0) {
-		PurgeQueue();
+	auto ts = ++handle->eviction_timestamp;
+
+	BufferEvictionNode evict_node(weak_ptr<BlockHandle>(handle), ts);
+	queue->q.enqueue(evict_node);
+
+	if (ts != 1) {
+		// we add a newer version, i.e., we kill exactly one previous version
+		IncrementDeadNodes();
 	}
-	queue->q.enqueue(BufferEvictionNode(weak_ptr<BlockHandle>(handle), handle->eviction_timestamp));
+
+	if (++evict_queue_insertions % INSERT_INTERVAL == 0) {
+		return true;
+	}
+	return false;
 }
 
 void BufferPool::IncreaseUsedMemory(MemoryTag tag, idx_t size) {
@@ -81,50 +91,137 @@ BufferPool::EvictionResult BufferPool::EvictBlocks(MemoryTag tag, idx_t extra_me
                                                    unique_ptr<FileBuffer> *buffer) {
 	BufferEvictionNode node;
 	TempBufferPoolReservation r(tag, *this, extra_memory);
+
 	while (current_memory > memory_limit) {
 		// get a block to unpin from the queue
 		if (!queue->q.try_dequeue(node)) {
-			// Failed to reserve. Adjust size of temp reservation to 0.
-			r.Resize(0);
-			return {false, std::move(r)};
+			// we could not dequeue any eviction node, so we try one more time,
+			// but more aggressively
+			if (!TryDequeueWithLock(node)) {
+				// still no success, we return
+				r.Resize(0);
+				return {false, std::move(r)};
+			}
 		}
+
 		// get a reference to the underlying block pointer
 		auto handle = node.TryGetBlockHandle();
 		if (!handle) {
+			DecrementDeadNodes();
 			continue;
 		}
+
 		// we might be able to free this block: grab the mutex and check if we can free it
 		lock_guard<mutex> lock(handle->lock);
 		if (!node.CanUnload(*handle)) {
 			// something changed in the mean-time, bail out
+			DecrementDeadNodes();
 			continue;
 		}
+
 		// hooray, we can unload the block
 		if (buffer && handle->buffer->AllocSize() == extra_memory) {
-			// we can actually re-use the memory directly!
+			// we can re-use the memory directly
 			*buffer = handle->UnloadAndTakeBlock();
 			return {true, std::move(r)};
-		} else {
-			// release the memory and mark the block as unloaded
-			handle->Unload();
 		}
+
+		// release the memory and mark the block as unloaded
+		handle->Unload();
 	}
 	return {true, std::move(r)};
 }
 
+bool BufferPool::TryDequeueWithLock(BufferEvictionNode &node) {
+	lock_guard<mutex> lock(purge_lock);
+	return queue->q.try_dequeue(node);
+}
+
+void BufferPool::PurgeIteration(const idx_t purge_size) {
+	// if this purge is significantly smaller or bigger than the previous purge, then
+	// we need to resize the purge_nodes vector. Note that this barely happens, as we
+	// purge queue_insertions * PURGE_SIZE_MULTIPLIER nodes
+	idx_t previous_purge_size = purge_nodes.size();
+	if (purge_size < previous_purge_size / 2 || purge_size > previous_purge_size) {
+		purge_nodes.resize(purge_size);
+	}
+
+	// bulk purge
+	idx_t actually_dequeued = queue->q.try_dequeue_bulk(purge_nodes.begin(), purge_size);
+
+	// retrieve all alive nodes that have been wrongly dequeued
+	idx_t alive_nodes = 0;
+	for (idx_t i = 0; i < actually_dequeued; i++) {
+		auto &node = purge_nodes[i];
+		auto handle = node.TryGetBlockHandle();
+		if (handle) {
+			queue->q.enqueue(std::move(node));
+			alive_nodes++;
+		}
+	}
+
+	total_dead_nodes -= actually_dequeued - alive_nodes;
+}
+
 void BufferPool::PurgeQueue() {
-	BufferEvictionNode node;
-	while (true) {
-		if (!queue->q.try_dequeue(node)) {
+
+	// only one thread purges the queue, all other threads early-out
+	if (!purge_lock.try_lock()) {
+		return;
+	}
+	lock_guard<mutex> lock {purge_lock, std::adopt_lock};
+
+	// we purge INSERT_INTERVAL * PURGE_SIZE_MULTIPLIER nodes
+	idx_t purge_size = INSERT_INTERVAL * PURGE_SIZE_MULTIPLIER;
+
+	// get an estimate of the queue size as-of now
+	idx_t approx_q_size = queue->q.size_approx();
+
+	// early-out, if the queue is not big enough to justify purging
+	// - we want to keep the LRU characteristic alive
+	if (approx_q_size < purge_size * EARLY_OUT_MULTIPLIER) {
+		return;
+	}
+
+	// There are two types of situations.
+
+	// For most scenarios, purging INSERT_INTERVAL * PURGE_SIZE_MULTIPLIER nodes is enough.
+	// Purging more nodes than we insert also counters oscillation for scenarios where most nodes are dead.
+	// If we always purge slightly more, we trigger a purge less often, as we purge below the trigger.
+
+	// However, if the pressure on the queue becomes too contested, we need to purge more aggressively,
+	// i.e., we actively seek a specific number of dead nodes to purge. We use the total number of existing dead nodes.
+	// We detect this situation by observing the queue's ratio between alive vs. dead nodes. If the ratio of alive vs.
+	// dead nodes grows faster than we can purge, we keep purging until we hit one of the following conditions.
+
+	// 2.1. We're back at an approximate queue size less than purge_size * EARLY_OUT_MULTIPLIER.
+	// 2.2. We're back at a ratio of 1*alive_node:ALIVE_NODE_MULTIPLIER*dead_nodes.
+	// 2.3. We've purged the entire queue: max_purges is zero. This is a worst-case scenario,
+	// guaranteeing that we always exit the loop.
+
+	idx_t max_purges = approx_q_size / purge_size;
+	while (max_purges != 0) {
+
+		PurgeIteration(purge_size);
+
+		// update relevant sizes and potentially early-out
+		approx_q_size = queue->q.size_approx();
+
+		// early-out according to (2.1)
+		if (approx_q_size < purge_size * EARLY_OUT_MULTIPLIER) {
 			break;
 		}
-		auto handle = node.TryGetBlockHandle();
-		if (!handle) {
-			continue;
-		} else {
-			queue->q.enqueue(std::move(node));
+
+		idx_t approx_dead_nodes = total_dead_nodes;
+		approx_dead_nodes = approx_dead_nodes > approx_q_size ? approx_q_size : approx_dead_nodes;
+		idx_t approx_alive_nodes = approx_q_size - approx_dead_nodes;
+
+		// early-out according to (2.2)
+		if (approx_alive_nodes * (ALIVE_NODE_MULTIPLIER - 1) > approx_dead_nodes) {
 			break;
 		}
+
+		max_purges--;
 	}
 }
 

package/src/duckdb/src/storage/buffer/ub_duckdb_storage_buffer.cpp

@@ -0,0 +1,6 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/storage/buffer/buffer_handle.cpp>
+#include </Users/carlo/duckdb/src/storage/buffer/block_handle.cpp>
+#include </Users/carlo/duckdb/src/storage/buffer/block_manager.cpp>
+#include </Users/carlo/duckdb/src/storage/buffer/buffer_pool.cpp>
+#include </Users/carlo/duckdb/src/storage/buffer/buffer_pool_reservation.cpp>

package/src/duckdb/src/storage/checkpoint/ub_duckdb_storage_checkpoint.cpp

@@ -0,0 +1,5 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/storage/checkpoint/row_group_writer.cpp>
+#include </Users/carlo/duckdb/src/storage/checkpoint/table_data_writer.cpp>
+#include </Users/carlo/duckdb/src/storage/checkpoint/table_data_reader.cpp>
+#include </Users/carlo/duckdb/src/storage/checkpoint/write_overflow_strings_to_disk.cpp>

package/src/duckdb/src/storage/checkpoint/write_overflow_strings_to_disk.cpp

@@ -47,19 +47,19 @@ void WriteOverflowStringsToDisk::WriteString(UncompressedStringSegmentState &sta
 		AllocateNewBlock(state, block_manager.GetFreeBlockId());
 	}
 	result_block = block_id;
-	result_offset = offset;
+	result_offset = UnsafeNumericCast<int32_t>(offset);
 
 	// write the length field
 	auto data_ptr = handle.Ptr();
 	auto string_length = string.GetSize();
-	Store<uint32_t>(string_length, data_ptr + offset);
+	Store<uint32_t>(UnsafeNumericCast<uint32_t>(string_length), data_ptr + offset);
 	offset += sizeof(uint32_t);
 
 	// now write the remainder of the string
 	auto strptr = string.GetData();
-	uint32_t remaining = string_length;
+	auto remaining = UnsafeNumericCast<uint32_t>(string_length);
 	while (remaining > 0) {
-		uint32_t to_write = MinValue<uint32_t>(remaining, STRING_SPACE - offset);
+		uint32_t to_write = MinValue<uint32_t>(remaining, UnsafeNumericCast<uint32_t>(STRING_SPACE - offset));
 		if (to_write > 0) {
 			memcpy(data_ptr + offset, strptr, to_write);
 

package/src/duckdb/src/storage/compression/chimp/ub_duckdb_storage_compression_chimp.cpp

@@ -0,0 +1,6 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/storage/compression/chimp/bit_reader.cpp>
+#include </Users/carlo/duckdb/src/storage/compression/chimp/chimp_constants.cpp>
+#include </Users/carlo/duckdb/src/storage/compression/chimp/flag_buffer.cpp>
+#include </Users/carlo/duckdb/src/storage/compression/chimp/leading_zero_buffer.cpp>
+#include </Users/carlo/duckdb/src/storage/compression/chimp/chimp.cpp>

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

@@ -1,4 +1,5 @@
 #include "duckdb/common/bitpacking.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 #include "duckdb/common/operator/comparison_operators.hpp"
 #include "duckdb/common/string_map_set.hpp"
 #include "duckdb/common/types/vector_buffer.hpp"
@@ -212,7 +213,7 @@ public:
 
 		// Update buffers and map
 		index_buffer.push_back(current_dictionary.size);
-		selection_buffer.push_back(index_buffer.size() - 1);
+		selection_buffer.push_back(UnsafeNumericCast<uint32_t>(index_buffer.size() - 1));
 		if (str.IsInlined()) {
 			current_string_map.insert({str, index_buffer.size() - 1});
 		} else {
@@ -285,8 +286,8 @@ public:
 		memcpy(base_ptr + index_buffer_offset, index_buffer.data(), index_buffer_size);
 
 		// Store sizes and offsets in segment header
-		Store<uint32_t>(index_buffer_offset, data_ptr_cast(&header_ptr->index_buffer_offset));
-		Store<uint32_t>(index_buffer.size(), data_ptr_cast(&header_ptr->index_buffer_count));
+		Store<uint32_t>(NumericCast<uint32_t>(index_buffer_offset), data_ptr_cast(&header_ptr->index_buffer_offset));
+		Store<uint32_t>(NumericCast<uint32_t>(index_buffer.size()), data_ptr_cast(&header_ptr->index_buffer_count));
 		Store<uint32_t>((uint32_t)current_width, data_ptr_cast(&header_ptr->bitpacking_width));
 
 		D_ASSERT(current_width == BitpackingPrimitives::MinimumBitWidth(index_buffer.size() - 1));
@@ -507,7 +508,7 @@ void DictionaryCompressionStorage::StringScanPartial(ColumnSegment &segment, Col
 			// Lookup dict offset in index buffer
 			auto string_number = scan_state.sel_vec->get_index(i + start_offset);
 			auto dict_offset = index_buffer_ptr[string_number];
-			uint16_t str_len = GetStringLength(index_buffer_ptr, string_number);
+			auto str_len = GetStringLength(index_buffer_ptr, UnsafeNumericCast<sel_t>(string_number));
 			result_data[result_offset + i] = FetchStringFromDict(segment, dict, baseptr, dict_offset, str_len);
 		}
 
@@ -627,7 +628,7 @@ uint16_t DictionaryCompressionStorage::GetStringLength(uint32_t *index_buffer_pt
 	if (index == 0) {
 		return 0;
 	} else {
-		return index_buffer_ptr[index] - index_buffer_ptr[index - 1];
+		return UnsafeNumericCast<uint16_t>(index_buffer_ptr[index] - index_buffer_ptr[index - 1]);
 	}
 }
 

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

@@ -249,7 +249,7 @@ public:
 		current_dictionary.Verify();
 
 		// We just push the string length to effectively delta encode the strings
-		index_buffer.push_back(compressed_string_len);
+		index_buffer.push_back(NumericCast<uint32_t>(compressed_string_len));
 
 		max_compressed_string_length = MaxValue(max_compressed_string_length, compressed_string_len);
 
@@ -348,7 +348,8 @@ public:
 			memset(base_ptr + symbol_table_offset, 0, fsst_serialized_symbol_table_size);
 		}
 
-		Store<uint32_t>(symbol_table_offset, data_ptr_cast(&header_ptr->fsst_symbol_table_offset));
+		Store<uint32_t>(NumericCast<uint32_t>(symbol_table_offset),
+		                data_ptr_cast(&header_ptr->fsst_symbol_table_offset));
 		Store<uint32_t>((uint32_t)current_width, data_ptr_cast(&header_ptr->bitpacking_width));
 
 		if (total_size >= FSSTStorage::COMPACTION_FLUSH_LIMIT) {

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

@@ -250,7 +250,7 @@ struct RLEScanState : public SegmentScanState {
 		handle = buffer_manager.Pin(segment.block);
 		entry_pos = 0;
 		position_in_entry = 0;
-		rle_count_offset = Load<uint64_t>(handle.Ptr() + segment.GetBlockOffset());
+		rle_count_offset = UnsafeNumericCast<uint32_t>(Load<uint64_t>(handle.Ptr() + segment.GetBlockOffset()));
 		D_ASSERT(rle_count_offset <= Storage::BLOCK_SIZE);
 	}
 

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

@@ -164,7 +164,7 @@ UncompressedStringStorage::StringInitSegment(ColumnSegment &segment, block_id_t
 		auto handle = buffer_manager.Pin(segment.block);
 		StringDictionaryContainer dictionary;
 		dictionary.size = 0;
-		dictionary.end = segment.SegmentSize();
+		dictionary.end = UnsafeNumericCast<uint32_t>(segment.SegmentSize());
 		SetDictionary(segment, handle, dictionary);
 	}
 	auto result = make_uniq<UncompressedStringSegmentState>();
@@ -283,7 +283,7 @@ void UncompressedStringStorage::WriteString(ColumnSegment &segment, string_t str
 
 void UncompressedStringStorage::WriteStringMemory(ColumnSegment &segment, string_t string, block_id_t &result_block,
                                                   int32_t &result_offset) {
-	uint32_t total_length = string.GetSize() + sizeof(uint32_t);
+	auto total_length = UnsafeNumericCast<uint32_t>(string.GetSize() + sizeof(uint32_t));
 	shared_ptr<BlockHandle> block;
 	BufferHandle handle;
 
@@ -309,11 +309,11 @@ void UncompressedStringStorage::WriteStringMemory(ColumnSegment &segment, string
 	}
 
 	result_block = state.head->block->BlockId();
-	result_offset = state.head->offset;
+	result_offset = UnsafeNumericCast<int32_t>(state.head->offset);
 
 	// copy the string and the length there
 	auto ptr = handle.Ptr() + state.head->offset;
-	Store<uint32_t>(string.GetSize(), ptr);
+	Store<uint32_t>(UnsafeNumericCast<uint32_t>(string.GetSize()), ptr);
 	ptr += sizeof(uint32_t);
 	memcpy(ptr, string.GetData(), string.GetSize());
 	state.head->offset += total_length;

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

@@ -0,0 +1,12 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/storage/compression/numeric_constant.cpp>
+#include </Users/carlo/duckdb/src/storage/compression/fixed_size_uncompressed.cpp>
+#include </Users/carlo/duckdb/src/storage/compression/rle.cpp>
+#include </Users/carlo/duckdb/src/storage/compression/dictionary_compression.cpp>
+#include </Users/carlo/duckdb/src/storage/compression/string_uncompressed.cpp>
+#include </Users/carlo/duckdb/src/storage/compression/uncompressed.cpp>
+#include </Users/carlo/duckdb/src/storage/compression/validity_uncompressed.cpp>
+#include </Users/carlo/duckdb/src/storage/compression/bitpacking.cpp>
+#include </Users/carlo/duckdb/src/storage/compression/bitpacking_hugeint.cpp>
+#include </Users/carlo/duckdb/src/storage/compression/patas.cpp>
+#include </Users/carlo/duckdb/src/storage/compression/fsst.cpp>

package/src/duckdb/src/storage/data_table.cpp

@@ -237,7 +237,6 @@ bool DataTable::NextParallelScan(ClientContext &context, ParallelTableScanState
 	if (row_groups->NextParallelScan(context, state.scan_state, scan_state.table_state)) {
 		return true;
 	}
-	scan_state.table_state.batch_index = state.scan_state.batch_index;
 	auto &local_storage = LocalStorage::Get(context, db);
 	if (local_storage.NextParallelScan(context, *this, state.local_state, scan_state.local_state)) {
 		return true;
@@ -747,12 +746,12 @@ void DataTable::AppendLock(TableAppendState &state) {
 	state.current_row = state.row_start;
 }
 
-void DataTable::InitializeAppend(DuckTransaction &transaction, TableAppendState &state, idx_t append_count) {
+void DataTable::InitializeAppend(DuckTransaction &transaction, TableAppendState &state) {
 	// obtain the append lock for this table
 	if (!state.append_lock) {
 		throw InternalException("DataTable::AppendLock should be called before DataTable::InitializeAppend");
 	}
-	row_groups->InitializeAppend(transaction, state, append_count);
+	row_groups->InitializeAppend(transaction, state);
 }
 
 void DataTable::Append(DataChunk &chunk, TableAppendState &state) {
@@ -760,6 +759,10 @@ void DataTable::Append(DataChunk &chunk, TableAppendState &state) {
 	row_groups->Append(chunk, state);
 }
 
+void DataTable::FinalizeAppend(DuckTransaction &transaction, TableAppendState &state) {
+	row_groups->FinalizeAppend(transaction, state);
+}
+
 void DataTable::ScanTableSegment(idx_t row_start, idx_t count, const std::function<void(DataChunk &chunk)> &function) {
 	if (count == 0) {
 		return;