duckdb 1.1.4-dev9.0 → 1.2.0

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

@@ -49,14 +49,13 @@ IndexPointer FixedSizeAllocator::New() {
 
 		// add a new buffer
 		auto buffer_id = GetAvailableBufferId();
-		FixedSizeBuffer new_buffer(block_manager);
-		buffers.insert(make_pair(buffer_id, std::move(new_buffer)));
+		buffers[buffer_id] = make_uniq<FixedSizeBuffer>(block_manager);
 		buffers_with_free_space.insert(buffer_id);
 
 		// set the bitmask
 		D_ASSERT(buffers.find(buffer_id) != buffers.end());
 		auto &buffer = buffers.find(buffer_id)->second;
-		ValidityMask mask(reinterpret_cast<validity_t *>(buffer.Get()), available_segments_per_buffer);
+		ValidityMask mask(reinterpret_cast<validity_t *>(buffer->Get()), available_segments_per_buffer);
 
 		// zero-initialize the bitmask to avoid leaking memory to disk
 		auto data = mask.GetData();
@@ -74,16 +73,16 @@ IndexPointer FixedSizeAllocator::New() {
 
 	D_ASSERT(buffers.find(buffer_id) != buffers.end());
 	auto &buffer = buffers.find(buffer_id)->second;
-	auto offset = buffer.GetOffset(bitmask_count, available_segments_per_buffer);
+	auto offset = buffer->GetOffset(bitmask_count, available_segments_per_buffer);
 
 	total_segment_count++;
-	buffer.segment_count++;
-	if (buffer.segment_count == available_segments_per_buffer) {
+	buffer->segment_count++;
+	if (buffer->segment_count == available_segments_per_buffer) {
 		buffers_with_free_space.erase(buffer_id);
 	}
 
 	// zero-initialize that segment
-	auto buffer_ptr = buffer.Get();
+	auto buffer_ptr = buffer->Get();
 	auto offset_in_buffer = buffer_ptr + offset * segment_size + bitmask_offset;
 	memset(offset_in_buffer, 0, segment_size);
 
@@ -98,24 +97,21 @@ void FixedSizeAllocator::Free(const IndexPointer ptr) {
 	D_ASSERT(buffers.find(buffer_id) != buffers.end());
 	auto &buffer = buffers.find(buffer_id)->second;
 
-	auto bitmask_ptr = reinterpret_cast<validity_t *>(buffer.Get());
+	auto bitmask_ptr = reinterpret_cast<validity_t *>(buffer->Get());
 	ValidityMask mask(bitmask_ptr, offset + 1); // FIXME
 	D_ASSERT(!mask.RowIsValid(offset));
 	mask.SetValid(offset);
 
 	D_ASSERT(total_segment_count > 0);
-	D_ASSERT(buffer.segment_count > 0);
+	D_ASSERT(buffer->segment_count > 0);
 
 	// adjust the allocator fields
 	buffers_with_free_space.insert(buffer_id);
 	total_segment_count--;
-	buffer.segment_count--;
+	buffer->segment_count--;
 }
 
 void FixedSizeAllocator::Reset() {
-	for (auto &buffer : buffers) {
-		buffer.second.Destroy();
-	}
 	buffers.clear();
 	buffers_with_free_space.clear();
 	total_segment_count = 0;
@@ -124,7 +120,7 @@ void FixedSizeAllocator::Reset() {
 idx_t FixedSizeAllocator::GetInMemorySize() const {
 	idx_t memory_usage = 0;
 	for (auto &buffer : buffers) {
-		if (buffer.second.InMemory()) {
+		if (buffer.second->InMemory()) {
 			memory_usage += block_manager.GetBlockSize();
 		}
 	}
@@ -179,9 +175,9 @@ bool FixedSizeAllocator::InitializeVacuum() {
 	idx_t available_segments_in_memory = 0;
 
 	for (auto &buffer : buffers) {
-		buffer.second.vacuum = false;
-		if (buffer.second.InMemory()) {
-			auto available_segments_in_buffer = available_segments_per_buffer - buffer.second.segment_count;
+		buffer.second->vacuum = false;
+		if (buffer.second->InMemory()) {
+			auto available_segments_in_buffer = available_segments_per_buffer - buffer.second->segment_count;
 			available_segments_in_memory += available_segments_in_buffer;
 			temporary_vacuum_buffers.emplace(available_segments_in_buffer, buffer.first);
 		}
@@ -216,7 +212,7 @@ bool FixedSizeAllocator::InitializeVacuum() {
 	for (auto &vacuum_buffer : temporary_vacuum_buffers) {
 		auto buffer_id = vacuum_buffer.second;
 		D_ASSERT(buffers.find(buffer_id) != buffers.end());
-		buffers.find(buffer_id)->second.vacuum = true;
+		buffers.find(buffer_id)->second->vacuum = true;
 		buffers_with_free_space.erase(buffer_id);
 	}
 
@@ -231,9 +227,7 @@ void FixedSizeAllocator::FinalizeVacuum() {
 
 	for (auto &buffer_id : vacuum_buffers) {
 		D_ASSERT(buffers.find(buffer_id) != buffers.end());
-		auto &buffer = buffers.find(buffer_id)->second;
-		D_ASSERT(buffer.InMemory());
-		buffer.Destroy();
+		D_ASSERT(buffers.find(buffer_id)->second->InMemory());
 		buffers.erase(buffer_id);
 	}
 	vacuum_buffers.clear();
@@ -259,9 +253,15 @@ FixedSizeAllocatorInfo FixedSizeAllocator::GetInfo() const {
 
 	for (const auto &buffer : buffers) {
 		info.buffer_ids.push_back(buffer.first);
-		info.block_pointers.push_back(buffer.second.block_pointer);
-		info.segment_counts.push_back(buffer.second.segment_count);
-		info.allocation_sizes.push_back(buffer.second.allocation_size);
+
+		// Memory safety check.
+		if (buffer.first > idx_t(MAX_ROW_ID)) {
+			throw InternalException("Initializing invalid buffer ID in FixedSizeAllocator::GetInfo");
+		}
+
+		info.block_pointers.push_back(buffer.second->block_pointer);
+		info.segment_counts.push_back(buffer.second->segment_count);
+		info.allocation_sizes.push_back(buffer.second->allocation_size);
 	}
 
 	for (auto &buffer_id : buffers_with_free_space) {
@@ -273,7 +273,7 @@ FixedSizeAllocatorInfo FixedSizeAllocator::GetInfo() const {
 
 void FixedSizeAllocator::SerializeBuffers(PartialBlockManager &partial_block_manager) {
 	for (auto &buffer : buffers) {
-		buffer.second.Serialize(partial_block_manager, available_segments_per_buffer, segment_size, bitmask_offset);
+		buffer.second->Serialize(partial_block_manager, available_segments_per_buffer, segment_size, bitmask_offset);
 	}
 }
 
@@ -281,8 +281,8 @@ vector<IndexBufferInfo> FixedSizeAllocator::InitSerializationToWAL() {
 
 	vector<IndexBufferInfo> buffer_infos;
 	for (auto &buffer : buffers) {
-		buffer.second.SetAllocationSize(available_segments_per_buffer, segment_size, bitmask_offset);
-		buffer_infos.emplace_back(buffer.second.Get(), buffer.second.allocation_size);
+		buffer.second->SetAllocationSize(available_segments_per_buffer, segment_size, bitmask_offset);
+		buffer_infos.emplace_back(buffer.second->Get(), buffer.second->allocation_size);
 	}
 	return buffer_infos;
 }
@@ -295,13 +295,19 @@ void FixedSizeAllocator::Init(const FixedSizeAllocatorInfo &info) {
 
 		// read all FixedSizeBuffer data
 		auto buffer_id = info.buffer_ids[i];
+
+		// Memory safety check.
+		if (buffer_id > idx_t(MAX_ROW_ID)) {
+			throw InternalException("Initializing invalid buffer ID in FixedSizeAllocator::Init");
+		}
+
 		auto buffer_block_pointer = info.block_pointers[i];
 		auto segment_count = info.segment_counts[i];
 		auto allocation_size = info.allocation_sizes[i];
 
 		// create the FixedSizeBuffer
-		FixedSizeBuffer new_buffer(block_manager, segment_count, allocation_size, buffer_block_pointer);
-		buffers.insert(make_pair(buffer_id, std::move(new_buffer)));
+		buffers[buffer_id] =
+		    make_uniq<FixedSizeBuffer>(block_manager, segment_count, allocation_size, buffer_block_pointer);
 		total_segment_count += segment_count;
 	}
 
@@ -324,8 +330,8 @@ void FixedSizeAllocator::Deserialize(MetadataManager &metadata_manager, const Bl
 		auto buffer_block_pointer = reader.Read<BlockPointer>();
 		auto segment_count = reader.Read<idx_t>();
 		auto allocation_size = reader.Read<idx_t>();
-		FixedSizeBuffer new_buffer(block_manager, segment_count, allocation_size, buffer_block_pointer);
-		buffers.insert(make_pair(buffer_id, std::move(new_buffer)));
+		buffers[buffer_id] =
+		    make_uniq<FixedSizeBuffer>(block_manager, segment_count, allocation_size, buffer_block_pointer);
 		total_segment_count += segment_count;
 	}
 	for (idx_t i = 0; i < buffers_with_free_space_count; i++) {
@@ -346,13 +352,12 @@ void FixedSizeAllocator::RemoveEmptyBuffers() {
 
 	auto buffer_it = buffers.begin();
 	while (buffer_it != buffers.end()) {
-		if (buffer_it->second.segment_count != 0) {
-			buffer_it++;
+		if (buffer_it->second->segment_count != 0) {
+			++buffer_it;
 			continue;
 		}
 
 		buffers_with_free_space.erase(buffer_it->first);
-		buffer_it->second.Destroy();
 		buffer_it = buffers.erase(buffer_it);
 	}
 }

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

@@ -54,7 +54,8 @@ FixedSizeBuffer::FixedSizeBuffer(BlockManager &block_manager, const idx_t segmen
 	D_ASSERT(block_handle->BlockId() < MAXIMUM_BLOCK);
 }
 
-void FixedSizeBuffer::Destroy() {
+FixedSizeBuffer::~FixedSizeBuffer() {
+	lock_guard<mutex> l(lock);
 	if (InMemory()) {
 		// we can have multiple readers on a pinned block, and unpinning the buffer handle
 		// decrements the reader count on the underlying block handle (Destroy() unpins)

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

@@ -14,6 +14,16 @@ UnboundIndex::UnboundIndex(unique_ptr<CreateInfo> create_info, IndexStorageInfo
                            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)) {
+
+	// Memory safety check.
+	for (idx_t info_idx = 0; info_idx < storage_info.allocator_infos.size(); info_idx++) {
+		auto &info = storage_info.allocator_infos[info_idx];
+		for (idx_t buffer_idx = 0; buffer_idx < info.buffer_ids.size(); buffer_idx++) {
+			if (info.buffer_ids[buffer_idx] > idx_t(MAX_ROW_ID)) {
+				throw InternalException("Found invalid buffer ID in UnboundIndex constructor");
+			}
+		}
+	}
 }
 
 void UnboundIndex::CommitDrop() {

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

@@ -153,8 +153,6 @@ public:
 			ComputeOffset(context, wexpr, offset);
 			ComputeDefault(context, wexpr, dflt);
 
-			curr_chunk.Initialize(context, {wexpr.return_type});
-
 			buffered = idx_t(std::abs(offset));
 			prev.Reference(dflt);
 			prev.Flatten(buffered);
@@ -162,6 +160,10 @@ public:
 		}
 
 		void Execute(ExecutionContext &context, DataChunk &input, DataChunk &delayed, Vector &result) {
+			if (!curr_chunk.ColumnCount()) {
+				curr_chunk.Initialize(context.client, {result.GetType()}, delayed.GetCapacity());
+			}
+
 			if (offset >= 0) {
 				ExecuteLag(context, input, result);
 			} else {
@@ -212,7 +214,7 @@ public:
 			idx_t pos = 0;
 			idx_t unified_offset = buffered;
 			if (unified_offset < count) {
-				curr_chunk.Reset();
+				Reset(curr_chunk);
 				executor.Execute(input, curr_chunk);
 				VectorOperations::Copy(curr, result, count, unified_offset, pos);
 				pos += count - unified_offset;
@@ -221,7 +223,7 @@ public:
 			// Copy unified[unified_offset:] => result[pos:]
 			idx_t unified_count = count + delayed.size();
 			if (unified_offset < unified_count) {
-				curr_chunk.Reset();
+				Reset(curr_chunk);
 				executor.Execute(delayed, curr_chunk);
 				idx_t delayed_offset = unified_offset - count;
 				// Only copy as many values as we need
@@ -312,6 +314,13 @@ public:
 		initialized = true;
 	}
 
+	static inline void Reset(DataChunk &chunk) {
+		//	Reset trashes the capacity...
+		const auto capacity = chunk.GetCapacity();
+		chunk.Reset();
+		chunk.SetCapacity(capacity);
+	}
+
 public:
 	//! We can't initialise until we have an input chunk
 	bool initialized;
@@ -470,34 +479,34 @@ void StreamingWindowState::AggregateState::Execute(ExecutionContext &context, Da
 	}
 }
 
-void PhysicalStreamingWindow::ExecuteFunctions(ExecutionContext &context, DataChunk &chunk, DataChunk &delayed,
+void PhysicalStreamingWindow::ExecuteFunctions(ExecutionContext &context, DataChunk &output, DataChunk &delayed,
                                                GlobalOperatorState &gstate_p, OperatorState &state_p) const {
 	auto &gstate = gstate_p.Cast<StreamingWindowGlobalState>();
 	auto &state = state_p.Cast<StreamingWindowState>();
 
 	// Compute window functions
-	const idx_t count = chunk.size();
+	const idx_t count = output.size();
 	const column_t input_width = children[0]->GetTypes().size();
 	for (column_t expr_idx = 0; expr_idx < select_list.size(); expr_idx++) {
 		column_t col_idx = input_width + expr_idx;
 		auto &expr = *select_list[expr_idx];
-		auto &result = chunk.data[col_idx];
+		auto &result = output.data[col_idx];
 		switch (expr.GetExpressionType()) {
 		case ExpressionType::WINDOW_AGGREGATE:
-			state.aggregate_states[expr_idx]->Execute(context, chunk, result);
+			state.aggregate_states[expr_idx]->Execute(context, output, result);
 			break;
 		case ExpressionType::WINDOW_FIRST_VALUE:
 		case ExpressionType::WINDOW_PERCENT_RANK:
 		case ExpressionType::WINDOW_RANK:
 		case ExpressionType::WINDOW_RANK_DENSE: {
 			// Reference constant vector
-			chunk.data[col_idx].Reference(*state.const_vectors[expr_idx]);
+			output.data[col_idx].Reference(*state.const_vectors[expr_idx]);
 			break;
 		}
 		case ExpressionType::WINDOW_ROW_NUMBER: {
 			// Set row numbers
 			int64_t start_row = gstate.row_number;
-			auto rdata = FlatVector::GetData<int64_t>(chunk.data[col_idx]);
+			auto rdata = FlatVector::GetData<int64_t>(output.data[col_idx]);
 			for (idx_t i = 0; i < count; i++) {
 				rdata[i] = NumericCast<int64_t>(start_row + NumericCast<int64_t>(i));
 			}
@@ -505,7 +514,7 @@ void PhysicalStreamingWindow::ExecuteFunctions(ExecutionContext &context, DataCh
 		}
 		case ExpressionType::WINDOW_LAG:
 		case ExpressionType::WINDOW_LEAD:
-			state.lead_lag_states[expr_idx]->Execute(context, chunk, delayed, result);
+			state.lead_lag_states[expr_idx]->Execute(context, output, delayed, result);
 			break;
 		default:
 			throw NotImplementedException("%s for StreamingWindow", ExpressionTypeToString(expr.GetExpressionType()));
@@ -515,13 +524,13 @@ void PhysicalStreamingWindow::ExecuteFunctions(ExecutionContext &context, DataCh
 }
 
 void PhysicalStreamingWindow::ExecuteInput(ExecutionContext &context, DataChunk &delayed, DataChunk &input,
-                                           DataChunk &chunk, GlobalOperatorState &gstate_p,
+                                           DataChunk &output, GlobalOperatorState &gstate_p,
                                            OperatorState &state_p) const {
 	auto &state = state_p.Cast<StreamingWindowState>();
 
 	// Put payload columns in place
 	for (idx_t col_idx = 0; col_idx < input.data.size(); col_idx++) {
-		chunk.data[col_idx].Reference(input.data[col_idx]);
+		output.data[col_idx].Reference(input.data[col_idx]);
 	}
 	idx_t count = input.size();
 
@@ -531,51 +540,53 @@ void PhysicalStreamingWindow::ExecuteInput(ExecutionContext &context, DataChunk
 		count -= state.lead_count;
 		input.Copy(delayed, count);
 	}
-	chunk.SetCardinality(count);
+	output.SetCardinality(count);
 
-	ExecuteFunctions(context, chunk, state.delayed, gstate_p, state_p);
+	ExecuteFunctions(context, output, state.delayed, gstate_p, state_p);
 }
 
 void PhysicalStreamingWindow::ExecuteShifted(ExecutionContext &context, DataChunk &delayed, DataChunk &input,
-                                             DataChunk &chunk, GlobalOperatorState &gstate_p,
+                                             DataChunk &output, GlobalOperatorState &gstate_p,
                                              OperatorState &state_p) const {
 	auto &state = state_p.Cast<StreamingWindowState>();
 	auto &shifted = state.shifted;
 
-	idx_t i = input.size();
-	idx_t d = delayed.size();
-	shifted.Reset();
+	idx_t out = output.size();
+	idx_t in = input.size();
+	idx_t delay = delayed.size();
+	D_ASSERT(out <= delay);
+
+	state.Reset(shifted);
 	// shifted = delayed
 	delayed.Copy(shifted);
-	delayed.Reset();
+	state.Reset(delayed);
 	for (idx_t col_idx = 0; col_idx < delayed.data.size(); ++col_idx) {
-		// chunk[0:i] = shifted[0:i]
-		chunk.data[col_idx].Reference(shifted.data[col_idx]);
-		// delayed[0:i] = chunk[i:d-i]
-		VectorOperations::Copy(shifted.data[col_idx], delayed.data[col_idx], d, i, 0);
-		// delayed[d-i:d] = input[0:i]
-		VectorOperations::Copy(input.data[col_idx], delayed.data[col_idx], i, 0, d - i);
+		// output[0:out] = delayed[0:out]
+		output.data[col_idx].Reference(shifted.data[col_idx]);
+		// delayed[0:out] = delayed[out:delay-out]
+		VectorOperations::Copy(shifted.data[col_idx], delayed.data[col_idx], delay, out, 0);
+		// delayed[delay-out:delay-out+in] = input[0:in]
+		VectorOperations::Copy(input.data[col_idx], delayed.data[col_idx], in, 0, delay - out);
 	}
-	chunk.SetCardinality(i);
-	delayed.SetCardinality(d);
+	delayed.SetCardinality(delay - out + in);
 
-	ExecuteFunctions(context, chunk, delayed, gstate_p, state_p);
+	ExecuteFunctions(context, output, delayed, gstate_p, state_p);
 }
 
 void PhysicalStreamingWindow::ExecuteDelayed(ExecutionContext &context, DataChunk &delayed, DataChunk &input,
-                                             DataChunk &chunk, GlobalOperatorState &gstate_p,
+                                             DataChunk &output, GlobalOperatorState &gstate_p,
                                              OperatorState &state_p) const {
 	// Put payload columns in place
 	for (idx_t col_idx = 0; col_idx < delayed.data.size(); col_idx++) {
-		chunk.data[col_idx].Reference(delayed.data[col_idx]);
+		output.data[col_idx].Reference(delayed.data[col_idx]);
 	}
 	idx_t count = delayed.size();
-	chunk.SetCardinality(count);
+	output.SetCardinality(count);
 
-	ExecuteFunctions(context, chunk, input, gstate_p, state_p);
+	ExecuteFunctions(context, output, input, gstate_p, state_p);
 }
 
-OperatorResultType PhysicalStreamingWindow::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
+OperatorResultType PhysicalStreamingWindow::Execute(ExecutionContext &context, DataChunk &input, DataChunk &output,
                                                     GlobalOperatorState &gstate_p, OperatorState &state_p) const {
 	auto &state = state_p.Cast<StreamingWindowState>();
 	if (!state.initialized) {
@@ -585,37 +596,37 @@ OperatorResultType PhysicalStreamingWindow::Execute(ExecutionContext &context, D
 	auto &delayed = state.delayed;
 	// We can Reset delayed now that no one can be referencing it.
 	if (!delayed.size()) {
-		delayed.Reset();
+		state.Reset(delayed);
 	}
-	const idx_t available = delayed.size() + input.size();
-	if (available <= state.lead_count) {
+	if (delayed.size() < state.lead_count) {
 		//	If we don't have enough to produce a single row,
 		//	then just delay more rows, return nothing
 		//	and ask for more data.
 		delayed.Append(input);
-		chunk.SetCardinality(0);
+		output.SetCardinality(0);
 		return OperatorResultType::NEED_MORE_INPUT;
 	} else if (input.size() < delayed.size()) {
 		// If we can't consume all of the delayed values,
 		// we need to split them instead of referencing them all
-		ExecuteShifted(context, delayed, input, chunk, gstate_p, state_p);
+		output.SetCardinality(input.size());
+		ExecuteShifted(context, delayed, input, output, gstate_p, state_p);
 		// We delayed the unused input so ask for more
 		return OperatorResultType::NEED_MORE_INPUT;
 	} else if (delayed.size()) {
 		//	We have enough delayed rows so flush them
-		ExecuteDelayed(context, delayed, input, chunk, gstate_p, state_p);
+		ExecuteDelayed(context, delayed, input, output, gstate_p, state_p);
 		// Defer resetting delayed as it may be referenced.
 		delayed.SetCardinality(0);
 		// Come back to process the input
 		return OperatorResultType::HAVE_MORE_OUTPUT;
 	} else {
 		//	No delayed rows, so emit what we can and delay the rest.
-		ExecuteInput(context, delayed, input, chunk, gstate_p, state_p);
+		ExecuteInput(context, delayed, input, output, gstate_p, state_p);
 		return OperatorResultType::NEED_MORE_INPUT;
 	}
 }
 
-OperatorFinalizeResultType PhysicalStreamingWindow::FinalExecute(ExecutionContext &context, DataChunk &chunk,
+OperatorFinalizeResultType PhysicalStreamingWindow::FinalExecute(ExecutionContext &context, DataChunk &output,
                                                                  GlobalOperatorState &gstate_p,
                                                                  OperatorState &state_p) const {
 	auto &state = state_p.Cast<StreamingWindowState>();
@@ -624,8 +635,15 @@ OperatorFinalizeResultType PhysicalStreamingWindow::FinalExecute(ExecutionContex
 		auto &delayed = state.delayed;
 		//	There are no more input rows
 		auto &input = state.shifted;
-		input.Reset();
-		ExecuteDelayed(context, delayed, input, chunk, gstate_p, state_p);
+		state.Reset(input);
+
+		if (output.GetCapacity() < delayed.size()) {
+			//	More than one output buffer was delayed, so shift in what we can
+			output.SetCardinality(output.GetCapacity());
+			ExecuteShifted(context, delayed, input, output, gstate_p, state_p);
+			return OperatorFinalizeResultType::HAVE_MORE_OUTPUT;
+		}
+		ExecuteDelayed(context, delayed, input, output, gstate_p, state_p);
 	}
 
 	return OperatorFinalizeResultType::FINISHED;

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

@@ -39,7 +39,13 @@ idx_t ColumnCountResult::GetMostFrequentColumnCount() const {
 }
 
 bool ColumnCountResult::AddRow(ColumnCountResult &result, idx_t buffer_pos) {
+	const LinePosition cur_position(result.cur_buffer_idx, buffer_pos + 1, result.current_buffer_size);
+	if (cur_position - result.last_position > result.state_machine.options.maximum_line_size.GetValue() &&
+	    buffer_pos != NumericLimits<idx_t>::Maximum()) {
+		result.error = true;
+	}
 	result.InternalAddRow();
+	result.last_position = cur_position;
 	if (!result.states.EmptyLastValue()) {
 		idx_t col_count_idx = result.result_position;
 		for (idx_t i = 0; i < result.result_position + 1; i++) {
@@ -99,6 +105,13 @@ ColumnCountScanner::ColumnCountScanner(shared_ptr<CSVBufferManager> buffer_manag
     : BaseScanner(std::move(buffer_manager), state_machine, std::move(error_handler), true, nullptr, iterator),
       result(states, *state_machine, result_size_p), column_count(1), result_size(result_size_p) {
 	sniffing = true;
+	idx_t actual_size = 0;
+	if (cur_buffer_handle) {
+		actual_size = cur_buffer_handle->actual_size;
+	}
+	result.last_position = {iterator.pos.buffer_idx, iterator.pos.buffer_pos, actual_size};
+	result.current_buffer_size = actual_size;
+	result.cur_buffer_idx = iterator.pos.buffer_idx;
 }
 
 unique_ptr<StringValueScanner> ColumnCountScanner::UpgradeToStringValueScanner() {
@@ -117,6 +130,9 @@ unique_ptr<StringValueScanner> ColumnCountScanner::UpgradeToStringValueScanner()
 ColumnCountResult &ColumnCountScanner::ParseChunk() {
 	result.result_position = 0;
 	column_count = 1;
+	if (cur_buffer_handle) {
+		result.current_buffer_size = cur_buffer_handle->actual_size;
+	}
 	ParseChunkInternal(result);
 	return result;
 }
@@ -139,6 +155,7 @@ void ColumnCountScanner::FinalizeChunkProcess() {
 		if (iterator.pos.buffer_pos == cur_buffer_handle->actual_size) {
 			// Move to next buffer
 			cur_buffer_handle = buffer_manager->GetBuffer(++iterator.pos.buffer_idx);
+
 			if (!cur_buffer_handle) {
 				buffer_handle_ptr = nullptr;
 				if (states.IsQuotedCurrent() && !states.IsUnquoted()) {
@@ -158,6 +175,15 @@ void ColumnCountScanner::FinalizeChunkProcess() {
 					result.AddRow(result, NumericLimits<idx_t>::Maximum());
 				}
 				return;
+			} else {
+				result.cur_buffer_idx = iterator.pos.buffer_idx;
+				result.current_buffer_size = cur_buffer_handle->actual_size;
+				// Do a quick check that the line is still sane
+				const LinePosition cur_position(result.cur_buffer_idx, 0, result.current_buffer_size);
+				if (cur_position - result.last_position > result.state_machine.options.maximum_line_size.GetValue()) {
+					result.error = true;
+					return;
+				}
 			}
 			iterator.pos.buffer_pos = 0;
 			buffer_handle_ptr = cur_buffer_handle->Ptr();