duckdb 0.10.3-dev0.0 → 0.10.3-dev13.0

package/src/duckdb/src/execution/aggregate_hashtable.cpp

@@ -40,7 +40,7 @@ GroupedAggregateHashTable::GroupedAggregateHashTable(ClientContext &context, All
                                                      vector<AggregateObject> aggregate_objects_p,
                                                      idx_t initial_capacity, idx_t radix_bits)
     : BaseAggregateHashTable(context, allocator, aggregate_objects_p, std::move(payload_types_p)),
-      radix_bits(radix_bits), count(0), capacity(0), aggregate_allocator(make_shared<ArenaAllocator>(allocator)) {
+      radix_bits(radix_bits), count(0), capacity(0), aggregate_allocator(make_shared_ptr<ArenaAllocator>(allocator)) {
 
 	// Append hash column to the end and initialise the row layout
 	group_types_p.emplace_back(LogicalType::HASH);
@@ -122,7 +122,7 @@ idx_t GroupedAggregateHashTable::InitialCapacity() {
 
 idx_t GroupedAggregateHashTable::GetCapacityForCount(idx_t count) {
 	count = MaxValue<idx_t>(InitialCapacity(), count);
-	return NextPowerOfTwo(count * LOAD_FACTOR);
+	return NextPowerOfTwo(NumericCast<uint64_t>(static_cast<double>(count) * LOAD_FACTOR));
 }
 
 idx_t GroupedAggregateHashTable::Capacity() const {
@@ -130,7 +130,7 @@ idx_t GroupedAggregateHashTable::Capacity() const {
 }
 
 idx_t GroupedAggregateHashTable::ResizeThreshold() const {
-	return Capacity() / LOAD_FACTOR;
+	return NumericCast<idx_t>(static_cast<double>(Capacity()) / LOAD_FACTOR);
 }
 
 idx_t GroupedAggregateHashTable::ApplyBitMask(hash_t hash) const {
@@ -246,7 +246,7 @@ idx_t GroupedAggregateHashTable::AddChunk(DataChunk &groups, Vector &group_hashe
 #endif
 
 	const auto new_group_count = FindOrCreateGroups(groups, group_hashes, state.addresses, state.new_groups);
-	VectorOperations::AddInPlace(state.addresses, layout.GetAggrOffset(), payload.size());
+	VectorOperations::AddInPlace(state.addresses, NumericCast<int64_t>(layout.GetAggrOffset()), payload.size());
 
 	// Now every cell has an entry, update the aggregates
 	auto &aggregates = layout.GetAggregates();
@@ -258,7 +258,7 @@ idx_t GroupedAggregateHashTable::AddChunk(DataChunk &groups, Vector &group_hashe
 		if (filter_idx >= filter.size() || i < filter[filter_idx]) {
 			// Skip all the aggregates that are not in the filter
 			payload_idx += aggr.child_count;
-			VectorOperations::AddInPlace(state.addresses, aggr.payload_size, payload.size());
+			VectorOperations::AddInPlace(state.addresses, NumericCast<int64_t>(aggr.payload_size), payload.size());
 			continue;
 		}
 		D_ASSERT(i == filter[filter_idx]);
@@ -272,7 +272,7 @@ idx_t GroupedAggregateHashTable::AddChunk(DataChunk &groups, Vector &group_hashe
 
 		// Move to the next aggregate
 		payload_idx += aggr.child_count;
-		VectorOperations::AddInPlace(state.addresses, aggr.payload_size, payload.size());
+		VectorOperations::AddInPlace(state.addresses, NumericCast<int64_t>(aggr.payload_size), payload.size());
 		filter_idx++;
 	}
 
@@ -360,7 +360,8 @@ idx_t GroupedAggregateHashTable::FindOrCreateGroupsInternal(DataChunk &groups, V
 
 	idx_t new_group_count = 0;
 	idx_t remaining_entries = groups.size();
-	while (remaining_entries > 0) {
+	idx_t iteration_count;
+	for (iteration_count = 0; remaining_entries > 0 && iteration_count < capacity; iteration_count++) {
 		idx_t new_entry_count = 0;
 		idx_t need_compare_count = 0;
 		idx_t no_match_count = 0;
@@ -370,7 +371,9 @@ idx_t GroupedAggregateHashTable::FindOrCreateGroupsInternal(DataChunk &groups, V
 			const auto index = sel_vector->get_index(i);
 			const auto &salt = hash_salts[index];
 			auto &ht_offset = ht_offsets[index];
-			while (true) {
+
+			idx_t inner_iteration_count;
+			for (inner_iteration_count = 0; inner_iteration_count < capacity; inner_iteration_count++) {
 				auto &entry = entries[ht_offset];
 				if (entry.IsOccupied()) { // Cell is occupied: Compare salts
 					if (entry.GetSalt() == salt) {
@@ -393,6 +396,9 @@ idx_t GroupedAggregateHashTable::FindOrCreateGroupsInternal(DataChunk &groups, V
 					break;
 				}
 			}
+			if (inner_iteration_count == capacity) {
+				throw InternalException("Maximum inner iteration count reached in GroupedAggregateHashTable");
+			}
 		}
 
 		if (new_entry_count != 0) {
@@ -440,6 +446,9 @@ idx_t GroupedAggregateHashTable::FindOrCreateGroupsInternal(DataChunk &groups, V
 		sel_vector = &state.no_match_vector;
 		remaining_entries = no_match_count;
 	}
+	if (iteration_count == capacity) {
+		throw InternalException("Maximum outer iteration count reached in GroupedAggregateHashTable");
+	}
 
 	count += new_group_count;
 	return new_group_count;

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

@@ -39,7 +39,7 @@ ART::ART(const string &name, const IndexConstraintType index_constraint_type, co
          TableIOManager &table_io_manager, const vector<unique_ptr<Expression>> &unbound_expressions,
          AttachedDatabase &db, const shared_ptr<array<unique_ptr<FixedSizeAllocator>, ALLOCATOR_COUNT>> &allocators_ptr,
          const IndexStorageInfo &info)
-    : Index(name, ART::TYPE_NAME, index_constraint_type, column_ids, table_io_manager, unbound_expressions, db),
+    : BoundIndex(name, ART::TYPE_NAME, index_constraint_type, column_ids, table_io_manager, unbound_expressions, db),
       allocators(allocators_ptr), owns_data(false) {
 
 	// initialize all allocators
@@ -54,7 +54,8 @@ ART::ART(const string &name, const IndexConstraintType index_constraint_type, co
 		    make_uniq<FixedSizeAllocator>(sizeof(Node16), block_manager),
 		    make_uniq<FixedSizeAllocator>(sizeof(Node48), block_manager),
 		    make_uniq<FixedSizeAllocator>(sizeof(Node256), block_manager)};
-		allocators = make_shared<array<unique_ptr<FixedSizeAllocator>, ALLOCATOR_COUNT>>(std::move(allocator_array));
+		allocators =
+		    make_shared_ptr<array<unique_ptr<FixedSizeAllocator>, ALLOCATOR_COUNT>>(std::move(allocator_array));
 	}
 
 	// deserialize lazily
@@ -1114,7 +1115,7 @@ void ART::WritePartialBlocks() {
 
 	// use the partial block manager to serialize all allocator data
 	auto &block_manager = table_io_manager.GetIndexBlockManager();
-	PartialBlockManager partial_block_manager(block_manager, CheckpointType::FULL_CHECKPOINT);
+	PartialBlockManager partial_block_manager(block_manager, PartialBlockType::FULL_CHECKPOINT);
 
 	for (auto &allocator : *allocators) {
 		allocator->SerializeBuffers(partial_block_manager);
@@ -1151,8 +1152,7 @@ void ART::Deserialize(const BlockPointer &pointer) {
 //===--------------------------------------------------------------------===//
 
 void ART::InitializeVacuum(ARTFlags &flags) {
-
-	flags.vacuum_flags.reserve(allocators->size());
+	flags.vacuum_flags.reserve(flags.vacuum_flags.size() + allocators->size());
 	for (auto &allocator : *allocators) {
 		flags.vacuum_flags.push_back(allocator->InitializeVacuum());
 	}
@@ -1230,7 +1230,7 @@ void ART::InitializeMerge(ARTFlags &flags) {
 	}
 }
 
-bool ART::MergeIndexes(IndexLock &state, Index &other_index) {
+bool ART::MergeIndexes(IndexLock &state, BoundIndex &other_index) {
 
 	auto &other_art = other_index.Cast<ART>();
 	if (!other_art.tree.HasMetadata()) {

package/src/duckdb/src/execution/index/bound_index.cpp

@@ -0,0 +1,115 @@
+#include "duckdb/execution/index/bound_index.hpp"
+
+#include "duckdb/common/radix.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/planner/expression/bound_columnref_expression.hpp"
+#include "duckdb/planner/expression/bound_reference_expression.hpp"
+#include "duckdb/planner/expression_iterator.hpp"
+#include "duckdb/storage/table/append_state.hpp"
+
+namespace duckdb {
+
+//-------------------------------------------------------------------------------
+// Bound index
+//-------------------------------------------------------------------------------
+
+BoundIndex::BoundIndex(const string &name, const string &index_type, IndexConstraintType index_constraint_type,
+                       const vector<column_t> &column_ids, TableIOManager &table_io_manager,
+                       const vector<unique_ptr<Expression>> &unbound_expressions_p, AttachedDatabase &db)
+    : Index(column_ids, table_io_manager, db), name(name), index_type(index_type),
+      index_constraint_type(index_constraint_type) {
+
+	for (auto &expr : unbound_expressions_p) {
+		types.push_back(expr->return_type.InternalType());
+		logical_types.push_back(expr->return_type);
+		unbound_expressions.emplace_back(expr->Copy());
+		bound_expressions.push_back(BindExpression(expr->Copy()));
+		executor.AddExpression(*bound_expressions.back());
+	}
+}
+
+void BoundIndex::InitializeLock(IndexLock &state) {
+	state.index_lock = unique_lock<mutex>(lock);
+}
+
+ErrorData BoundIndex::Append(DataChunk &entries, Vector &row_identifiers) {
+	IndexLock state;
+	InitializeLock(state);
+	return Append(state, entries, row_identifiers);
+}
+
+void BoundIndex::CommitDrop() {
+	IndexLock index_lock;
+	InitializeLock(index_lock);
+	CommitDrop(index_lock);
+}
+
+void BoundIndex::Delete(DataChunk &entries, Vector &row_identifiers) {
+	IndexLock state;
+	InitializeLock(state);
+	Delete(state, entries, row_identifiers);
+}
+
+bool BoundIndex::MergeIndexes(BoundIndex &other_index) {
+	IndexLock state;
+	InitializeLock(state);
+	return MergeIndexes(state, other_index);
+}
+
+string BoundIndex::VerifyAndToString(const bool only_verify) {
+	IndexLock state;
+	InitializeLock(state);
+	return VerifyAndToString(state, only_verify);
+}
+
+void BoundIndex::Vacuum() {
+	IndexLock state;
+	InitializeLock(state);
+	Vacuum(state);
+}
+
+idx_t BoundIndex::GetInMemorySize() {
+	IndexLock state;
+	InitializeLock(state);
+	return GetInMemorySize(state);
+}
+
+void BoundIndex::ExecuteExpressions(DataChunk &input, DataChunk &result) {
+	executor.Execute(input, result);
+}
+
+unique_ptr<Expression> BoundIndex::BindExpression(unique_ptr<Expression> expr) {
+	if (expr->type == ExpressionType::BOUND_COLUMN_REF) {
+		auto &bound_colref = expr->Cast<BoundColumnRefExpression>();
+		return make_uniq<BoundReferenceExpression>(expr->return_type, column_ids[bound_colref.binding.column_index]);
+	}
+	ExpressionIterator::EnumerateChildren(
+	    *expr, [this](unique_ptr<Expression> &expr) { expr = BindExpression(std::move(expr)); });
+	return expr;
+}
+
+bool BoundIndex::IndexIsUpdated(const vector<PhysicalIndex> &column_ids_p) const {
+	for (auto &column : column_ids_p) {
+		if (column_id_set.find(column.index) != column_id_set.end()) {
+			return true;
+		}
+	}
+	return false;
+}
+
+IndexStorageInfo BoundIndex::GetStorageInfo(const bool get_buffers) {
+	throw NotImplementedException("The implementation of this index serialization does not exist.");
+}
+
+string BoundIndex::AppendRowError(DataChunk &input, idx_t index) {
+	string error;
+	for (idx_t c = 0; c < input.ColumnCount(); c++) {
+		if (c > 0) {
+			error += ", ";
+		}
+		error += input.GetValue(c, index).ToString();
+	}
+	return error;
+}
+
+} // namespace duckdb

package/src/duckdb/src/execution/index/unbound_index.cpp

@@ -0,0 +1,30 @@
+#include "duckdb/execution/index/unbound_index.hpp"
+#include "duckdb/parser/parsed_data/create_index_info.hpp"
+#include "duckdb/storage/table_io_manager.hpp"
+#include "duckdb/storage/block_manager.hpp"
+#include "duckdb/storage/index_storage_info.hpp"
+
+namespace duckdb {
+
+//-------------------------------------------------------------------------------
+// Unbound index
+//-------------------------------------------------------------------------------
+
+UnboundIndex::UnboundIndex(unique_ptr<CreateInfo> create_info, IndexStorageInfo storage_info_p,
+                           TableIOManager &table_io_manager, AttachedDatabase &db)
+    : Index(create_info->Cast<CreateIndexInfo>().column_ids, table_io_manager, db), create_info(std::move(create_info)),
+      storage_info(std::move(storage_info_p)) {
+}
+
+void UnboundIndex::CommitDrop() {
+	auto &block_manager = table_io_manager.GetIndexBlockManager();
+	for (auto &info : storage_info.allocator_infos) {
+		for (auto &block : info.block_pointers) {
+			if (block.IsValid()) {
+				block_manager.MarkBlockAsModified(block.block_id);
+			}
+		}
+	}
+}
+
+} // namespace duckdb

package/src/duckdb/src/execution/join_hashtable.cpp

@@ -940,7 +940,8 @@ void JoinHashTable::SetRepartitionRadixBits(vector<unique_ptr<JoinHashTable>> &l
 
 		auto new_estimated_size = double(max_partition_size) / partition_multiplier;
 		auto new_estimated_count = double(max_partition_count) / partition_multiplier;
-		auto new_estimated_ht_size = new_estimated_size + PointerTableSize(new_estimated_count);
+		auto new_estimated_ht_size =
+		    new_estimated_size + static_cast<double>(PointerTableSize(NumericCast<idx_t>(new_estimated_count)));
 
 		if (new_estimated_ht_size <= double(max_ht_size) / 4) {
 			// Aim for an estimated partition size of max_ht_size / 4

package/src/duckdb/src/execution/operator/aggregate/aggregate_object.cpp

@@ -9,7 +9,7 @@ AggregateObject::AggregateObject(AggregateFunction function, FunctionData *bind_
                                  idx_t payload_size, AggregateType aggr_type, PhysicalType return_type,
                                  Expression *filter)
     : function(std::move(function)),
-      bind_data_wrapper(bind_data ? make_shared<FunctionDataWrapper>(bind_data->Copy()) : nullptr),
+      bind_data_wrapper(bind_data ? make_shared_ptr<FunctionDataWrapper>(bind_data->Copy()) : nullptr),
       child_count(child_count), payload_size(payload_size), aggr_type(aggr_type), return_type(return_type),
       filter(filter) {
 }

package/src/duckdb/src/execution/operator/aggregate/distinct_aggregate_data.cpp

@@ -151,7 +151,7 @@ idx_t DistinctAggregateCollectionInfo::CreateTableIndexMap() {
 		    std::find_if(table_inputs.begin(), table_inputs.end(), FindMatchingAggregate(std::ref(aggregate)));
 		if (matching_inputs != table_inputs.end()) {
 			//! Assign the existing table to the aggregate
-			idx_t found_idx = std::distance(table_inputs.begin(), matching_inputs);
+			auto found_idx = NumericCast<idx_t>(std::distance(table_inputs.begin(), matching_inputs));
 			table_map[agg_idx] = found_idx;
 			continue;
 		}

package/src/duckdb/src/execution/operator/aggregate/physical_hash_aggregate.cpp

@@ -565,7 +565,7 @@ private:
 
 void HashAggregateDistinctFinalizeEvent::Schedule() {
 	auto n_tasks = CreateGlobalSources();
-	n_tasks = MinValue<idx_t>(n_tasks, TaskScheduler::GetScheduler(context).NumberOfThreads());
+	n_tasks = MinValue<idx_t>(n_tasks, NumericCast<idx_t>(TaskScheduler::GetScheduler(context).NumberOfThreads()));
 	vector<shared_ptr<Task>> tasks;
 	for (idx_t i = 0; i < n_tasks; i++) {
 		tasks.push_back(make_uniq<HashAggregateDistinctFinalizeTask>(*pipeline, shared_from_this(), op, gstate));
@@ -608,7 +608,7 @@ idx_t HashAggregateDistinctFinalizeEvent::CreateGlobalSources() {
 
 void HashAggregateDistinctFinalizeEvent::FinishEvent() {
 	// Now that everything is added to the main ht, we can actually finalize
-	auto new_event = make_shared<HashAggregateFinalizeEvent>(context, pipeline.get(), op, gstate);
+	auto new_event = make_shared_ptr<HashAggregateFinalizeEvent>(context, pipeline.get(), op, gstate);
 	this->InsertEvent(std::move(new_event));
 }
 
@@ -755,7 +755,7 @@ SinkFinalizeType PhysicalHashAggregate::FinalizeDistinct(Pipeline &pipeline, Eve
 			radix_table->Finalize(context, radix_state);
 		}
 	}
-	auto new_event = make_shared<HashAggregateDistinctFinalizeEvent>(context, pipeline, *this, gstate);
+	auto new_event = make_shared_ptr<HashAggregateDistinctFinalizeEvent>(context, pipeline, *this, gstate);
 	event.InsertEvent(std::move(new_event));
 	return SinkFinalizeType::READY;
 }

package/src/duckdb/src/execution/operator/aggregate/physical_streaming_window.cpp

@@ -8,6 +8,30 @@
 
 namespace duckdb {
 
+bool PhysicalStreamingWindow::IsStreamingFunction(unique_ptr<Expression> &expr) {
+	auto &wexpr = expr->Cast<BoundWindowExpression>();
+	if (!wexpr.partitions.empty() || !wexpr.orders.empty() || wexpr.ignore_nulls ||
+	    wexpr.exclude_clause != WindowExcludeMode::NO_OTHER) {
+		return false;
+	}
+	switch (wexpr.type) {
+	// TODO: add more expression types here?
+	case ExpressionType::WINDOW_AGGREGATE:
+		// We can stream aggregates if they are "running totals"
+		// TODO: Support FILTER and DISTINCT
+		return wexpr.start == WindowBoundary::UNBOUNDED_PRECEDING && wexpr.end == WindowBoundary::CURRENT_ROW_ROWS &&
+		       !wexpr.filter_expr && !wexpr.distinct;
+	case ExpressionType::WINDOW_FIRST_VALUE:
+	case ExpressionType::WINDOW_PERCENT_RANK:
+	case ExpressionType::WINDOW_RANK:
+	case ExpressionType::WINDOW_RANK_DENSE:
+	case ExpressionType::WINDOW_ROW_NUMBER:
+		return true;
+	default:
+		return false;
+	}
+}
+
 PhysicalStreamingWindow::PhysicalStreamingWindow(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
                                                  idx_t estimated_cardinality, PhysicalOperatorType type)
     : PhysicalOperator(type, std::move(types), estimated_cardinality), select_list(std::move(select_list)) {
@@ -142,7 +166,7 @@ OperatorResultType PhysicalStreamingWindow::Execute(ExecutionContext &context, D
 				auto data = FlatVector::GetData<int64_t>(result);
 				int64_t start_row = gstate.row_number;
 				for (idx_t i = 0; i < input.size(); ++i) {
-					data[i] = start_row + i;
+					data[i] = NumericCast<int64_t>(start_row + NumericCast<int64_t>(i));
 				}
 				break;
 			}
@@ -167,13 +191,24 @@ OperatorResultType PhysicalStreamingWindow::Execute(ExecutionContext &context, D
 			sel_t s = 0;
 			SelectionVector sel(&s);
 			row.Slice(sel, 1);
-			for (size_t col_idx = 0; col_idx < payload.ColumnCount(); ++col_idx) {
-				DictionaryVector::Child(row.data[col_idx]).Reference(payload.data[col_idx]);
+			// This doesn't work for STRUCTs because the SV
+			// is not copied to the children when you slice
+			vector<column_t> structs;
+			for (column_t col_idx = 0; col_idx < payload.ColumnCount(); ++col_idx) {
+				auto &col_vec = row.data[col_idx];
+				DictionaryVector::Child(col_vec).Reference(payload.data[col_idx]);
+				if (col_vec.GetType().InternalType() == PhysicalType::STRUCT) {
+					structs.emplace_back(col_idx);
+				}
 			}
 
 			// Update the state and finalize it one row at a time.
 			for (idx_t i = 0; i < input.size(); ++i) {
 				sel.set_index(0, i);
+				for (const auto struct_idx : structs) {
+					row.data[struct_idx].Slice(payload.data[struct_idx], sel, 1);
+				}
+				// TODO: FILTER and DISTINCT would just skip this.
 				aggregate.update(row.data.data(), aggr_input_data, row.ColumnCount(), statev, 1);
 				aggregate.finalize(statev, aggr_input_data, result, 1, i);
 			}
@@ -192,7 +227,7 @@ OperatorResultType PhysicalStreamingWindow::Execute(ExecutionContext &context, D
 			int64_t start_row = gstate.row_number;
 			auto rdata = FlatVector::GetData<int64_t>(chunk.data[col_idx]);
 			for (idx_t i = 0; i < count; i++) {
-				rdata[i] = start_row + i;
+				rdata[i] = NumericCast<int64_t>(start_row + NumericCast<int64_t>(i));
 			}
 			break;
 		}
@@ -200,7 +235,7 @@ OperatorResultType PhysicalStreamingWindow::Execute(ExecutionContext &context, D
 			throw NotImplementedException("%s for StreamingWindow", ExpressionTypeToString(expr.GetExpressionType()));
 		}
 	}
-	gstate.row_number += count;
+	gstate.row_number += NumericCast<int64_t>(count);
 	chunk.SetCardinality(count);
 	return OperatorResultType::NEED_MORE_INPUT;
 }

package/src/duckdb/src/execution/operator/aggregate/physical_ungrouped_aggregate.cpp

@@ -454,7 +454,7 @@ void UngroupedDistinctAggregateFinalizeEvent::Schedule() {
 		global_source_states.push_back(radix_table_p.GetGlobalSourceState(context));
 	}
 	n_tasks = MaxValue<idx_t>(n_tasks, 1);
-	n_tasks = MinValue<idx_t>(n_tasks, TaskScheduler::GetScheduler(context).NumberOfThreads());
+	n_tasks = MinValue<idx_t>(n_tasks, NumericCast<idx_t>(TaskScheduler::GetScheduler(context).NumberOfThreads()));
 
 	vector<shared_ptr<Task>> tasks;
 	for (idx_t i = 0; i < n_tasks; i++) {
@@ -586,7 +586,7 @@ SinkFinalizeType PhysicalUngroupedAggregate::FinalizeDistinct(Pipeline &pipeline
 		auto &radix_state = *distinct_state.radix_states[table_idx];
 		radix_table_p->Finalize(context, radix_state);
 	}
-	auto new_event = make_shared<UngroupedDistinctAggregateFinalizeEvent>(context, *this, gstate, pipeline);
+	auto new_event = make_shared_ptr<UngroupedDistinctAggregateFinalizeEvent>(context, *this, gstate, pipeline);
 	event.InsertEvent(std::move(new_event));
 	return SinkFinalizeType::READY;
 }

package/src/duckdb/src/execution/operator/aggregate/physical_window.cpp

@@ -171,7 +171,7 @@ SinkFinalizeType PhysicalWindow::Finalize(Pipeline &pipeline, Event &event, Clie
 	}
 
 	// Schedule all the sorts for maximum thread utilisation
-	auto new_event = make_shared<PartitionMergeEvent>(*state.global_partition, pipeline);
+	auto new_event = make_shared_ptr<PartitionMergeEvent>(*state.global_partition, pipeline);
 	event.InsertEvent(std::move(new_event));
 
 	return SinkFinalizeType::READY;
@@ -205,6 +205,8 @@ public:
 	mutable mutex built_lock;
 	//! The number of unfinished tasks
 	atomic<idx_t> tasks_remaining;
+	//! The number of rows returned
+	atomic<idx_t> returned;
 
 public:
 	idx_t MaxThreads() override {
@@ -217,7 +219,7 @@ private:
 };
 
 WindowGlobalSourceState::WindowGlobalSourceState(ClientContext &context_p, WindowGlobalSinkState &gsink_p)
-    : context(context_p), gsink(gsink_p), next_build(0), tasks_remaining(0) {
+    : context(context_p), gsink(gsink_p), next_build(0), tasks_remaining(0), returned(0) {
 	auto &hash_groups = gsink.global_partition->hash_groups;
 
 	auto &gpart = gsink.global_partition;
@@ -327,7 +329,7 @@ void WindowPartitionSourceState::MaterializeSortedData() {
 		heap->blocks = std::move(sd.heap_blocks);
 		hash_group.reset();
 	} else {
-		heap = make_uniq<RowDataCollection>(buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1, true);
+		heap = make_uniq<RowDataCollection>(buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1U, true);
 	}
 	heap->count = std::accumulate(heap->blocks.begin(), heap->blocks.end(), idx_t(0),
 	                              [&](idx_t c, const unique_ptr<RowDataBlock> &b) { return c + b->count; });
@@ -681,6 +683,15 @@ OrderPreservationType PhysicalWindow::SourceOrder() const {
 	return SupportsBatchIndex() ? OrderPreservationType::FIXED_ORDER : OrderPreservationType::NO_ORDER;
 }
 
+double PhysicalWindow::GetProgress(ClientContext &context, GlobalSourceState &gsource_p) const {
+	auto &gsource = gsource_p.Cast<WindowGlobalSourceState>();
+	const auto returned = gsource.returned.load();
+
+	auto &gsink = gsource.gsink;
+	const auto count = gsink.global_partition->count.load();
+	return count ? (returned / double(count)) : -1;
+}
+
 idx_t PhysicalWindow::GetBatchIndex(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
                                     LocalSourceState &lstate_p) const {
 	auto &lstate = lstate_p.Cast<WindowLocalSourceState>();
@@ -689,6 +700,7 @@ idx_t PhysicalWindow::GetBatchIndex(ExecutionContext &context, DataChunk &chunk,
 
 SourceResultType PhysicalWindow::GetData(ExecutionContext &context, DataChunk &chunk,
                                          OperatorSourceInput &input) const {
+	auto &gsource = input.global_state.Cast<WindowGlobalSourceState>();
 	auto &lsource = input.local_state.Cast<WindowLocalSourceState>();
 	while (chunk.size() == 0) {
 		//	Move to the next bin if we are done.
@@ -699,6 +711,7 @@ SourceResultType PhysicalWindow::GetData(ExecutionContext &context, DataChunk &c
 		}
 
 		lsource.Scan(chunk);
+		gsource.returned += chunk.size();
 	}
 
 	return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;

package/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_buffer.cpp

@@ -41,8 +41,8 @@ shared_ptr<CSVBuffer> CSVBuffer::Next(CSVFileHandle &file_handle, idx_t buffer_s
 		file_handle.Seek(global_csv_start + actual_buffer_size);
 		has_seaked = false;
 	}
-	auto next_csv_buffer = make_shared<CSVBuffer>(file_handle, context, buffer_size,
-	                                              global_csv_start + actual_buffer_size, file_number_p, buffer_idx + 1);
+	auto next_csv_buffer = make_shared_ptr<CSVBuffer>(
+	    file_handle, context, buffer_size, global_csv_start + actual_buffer_size, file_number_p, buffer_idx + 1);
 	if (next_csv_buffer->GetBufferSize() == 0) {
 		// We are done reading
 		return nullptr;
@@ -76,8 +76,8 @@ shared_ptr<CSVBufferHandle> CSVBuffer::Pin(CSVFileHandle &file_handle, bool &has
 		Reload(file_handle);
 		has_seeked = true;
 	}
-	return make_shared<CSVBufferHandle>(buffer_manager.Pin(block), actual_buffer_size, requested_size, last_buffer,
-	                                    file_number, buffer_idx);
+	return make_shared_ptr<CSVBufferHandle>(buffer_manager.Pin(block), actual_buffer_size, requested_size, last_buffer,
+	                                        file_number, buffer_idx);
 }
 
 void CSVBuffer::Unpin() {

package/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_buffer_manager.cpp

@@ -29,7 +29,7 @@ void CSVBufferManager::UnpinBuffer(const idx_t cache_idx) {
 void CSVBufferManager::Initialize() {
 	if (cached_buffers.empty()) {
 		cached_buffers.emplace_back(
-		    make_shared<CSVBuffer>(context, buffer_size, *file_handle, global_csv_pos, file_idx));
+		    make_shared_ptr<CSVBuffer>(context, buffer_size, *file_handle, global_csv_pos, file_idx));
 		last_buffer = cached_buffers.front();
 	}
 }
@@ -38,17 +38,7 @@ bool CSVBufferManager::ReadNextAndCacheIt() {
 	D_ASSERT(last_buffer);
 	for (idx_t i = 0; i < 2; i++) {
 		if (!last_buffer->IsCSVFileLastBuffer()) {
-			auto cur_buffer_size = buffer_size;
-			if (file_handle->uncompressed) {
-				if (file_handle->FileSize() - bytes_read) {
-					cur_buffer_size = file_handle->FileSize() - bytes_read;
-				}
-			}
-			if (cur_buffer_size == 0) {
-				last_buffer->last_buffer = true;
-				return false;
-			}
-			auto maybe_last_buffer = last_buffer->Next(*file_handle, cur_buffer_size, file_idx, has_seeked);
+			auto maybe_last_buffer = last_buffer->Next(*file_handle, buffer_size, file_idx, has_seeked);
 			if (!maybe_last_buffer) {
 				last_buffer->last_buffer = true;
 				return false;

package/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_file_handle.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/execution/operator/csv_scanner/csv_file_handle.hpp"
 #include "duckdb/common/exception/binder_exception.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 
 namespace duckdb {
 
@@ -71,7 +72,7 @@ idx_t CSVFileHandle::Read(void *buffer, idx_t nr_bytes) {
 	if (!finished) {
 		finished = bytes_read == 0;
 	}
-	return bytes_read;
+	return UnsafeNumericCast<idx_t>(bytes_read);
 }
 
 string CSVFileHandle::ReadLine() {

package/src/duckdb/src/execution/operator/csv_scanner/scanner/base_scanner.cpp

@@ -1,10 +1,12 @@
-#include "duckdb/execution/operator/csv_scanner/csv_sniffer.hpp"
 #include "duckdb/execution/operator/csv_scanner/base_scanner.hpp"
 
+#include "duckdb/execution/operator/csv_scanner/csv_sniffer.hpp"
+#include "duckdb/execution/operator/csv_scanner/skip_scanner.hpp"
+
 namespace duckdb {
 
 ScannerResult::ScannerResult(CSVStates &states_p, CSVStateMachine &state_machine_p)
-    : states(states_p), state_machine(state_machine_p) {
+    : state_machine(state_machine_p), states(states_p) {
 }
 
 BaseScanner::BaseScanner(shared_ptr<CSVBufferManager> buffer_manager_p, shared_ptr<CSVStateMachine> state_machine_p,
@@ -39,15 +41,29 @@ bool BaseScanner::FinishedFile() {
 	return iterator.pos.buffer_pos + 1 == cur_buffer_handle->actual_size;
 }
 
-void BaseScanner::Reset() {
-	iterator.SetCurrentPositionToBoundary();
-	lines_read = 0;
+void BaseScanner::SkipCSVRows(idx_t rows_to_skip) {
+	if (rows_to_skip == 0) {
+		return;
+	}
+	SkipScanner row_skipper(buffer_manager, state_machine, error_handler, rows_to_skip);
+	row_skipper.ParseChunk();
+	iterator.pos.buffer_pos = row_skipper.GetIteratorPosition();
+	if (row_skipper.state_machine->options.dialect_options.state_machine_options.new_line ==
+	        NewLineIdentifier::CARRY_ON &&
+	    row_skipper.states.states[1] == CSVState::CARRIAGE_RETURN) {
+		iterator.pos.buffer_pos++;
+	}
+	lines_read += row_skipper.GetLinesRead();
 }
 
 CSVIterator &BaseScanner::GetIterator() {
 	return iterator;
 }
 
+void BaseScanner::SetIterator(const CSVIterator &it) {
+	iterator = it;
+}
+
 ScannerResult &BaseScanner::ParseChunk() {
 	throw InternalException("ParseChunk() from CSV Base Scanner is mot implemented");
 }

package/src/duckdb/src/execution/operator/csv_scanner/scanner/column_count_scanner.cpp

@@ -50,7 +50,7 @@ ColumnCountScanner::ColumnCountScanner(shared_ptr<CSVBufferManager> buffer_manag
 }
 
 unique_ptr<StringValueScanner> ColumnCountScanner::UpgradeToStringValueScanner() {
-	auto scanner = make_uniq<StringValueScanner>(0, buffer_manager, state_machine, error_handler, nullptr, true);
+	auto scanner = make_uniq<StringValueScanner>(0U, buffer_manager, state_machine, error_handler, nullptr, true);
 	return scanner;
 }