duckdb 0.9.3-dev0.0 → 0.9.3-dev3.0

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

@@ -0,0 +1,90 @@
+#include "duckdb/execution/operator/csv_scanner/buffer_manager/csv_buffer.hpp"
+#include "duckdb/common/string_util.hpp"
+
+namespace duckdb {
+
+CSVBuffer::CSVBuffer(ClientContext &context, idx_t buffer_size_p, CSVFileHandle &file_handle,
+                     idx_t &global_csv_current_position, idx_t file_number_p)
+    : context(context), file_number(file_number_p), can_seek(file_handle.CanSeek()) {
+	AllocateBuffer(buffer_size_p);
+	auto buffer = Ptr();
+	actual_buffer_size = file_handle.Read(buffer, buffer_size_p);
+	while (actual_buffer_size < buffer_size_p && !file_handle.FinishedReading()) {
+		// We keep reading until this block is full
+		actual_buffer_size += file_handle.Read(&buffer[actual_buffer_size], buffer_size_p - actual_buffer_size);
+	}
+	global_csv_start = global_csv_current_position;
+	last_buffer = file_handle.FinishedReading();
+}
+
+CSVBuffer::CSVBuffer(CSVFileHandle &file_handle, ClientContext &context, idx_t buffer_size,
+                     idx_t global_csv_current_position, idx_t file_number_p, idx_t buffer_idx_p)
+    : context(context), global_csv_start(global_csv_current_position), file_number(file_number_p),
+      can_seek(file_handle.CanSeek()), buffer_idx(buffer_idx_p) {
+	AllocateBuffer(buffer_size);
+	auto buffer = handle.Ptr();
+	actual_buffer_size = file_handle.Read(handle.Ptr(), buffer_size);
+	while (actual_buffer_size < buffer_size && !file_handle.FinishedReading()) {
+		// We keep reading until this block is full
+		actual_buffer_size += file_handle.Read(&buffer[actual_buffer_size], buffer_size - actual_buffer_size);
+	}
+	last_buffer = file_handle.FinishedReading();
+}
+
+shared_ptr<CSVBuffer> CSVBuffer::Next(CSVFileHandle &file_handle, idx_t buffer_size, idx_t file_number_p,
+                                      bool &has_seaked) {
+	if (has_seaked) {
+		// This means that at some point a reload was done, and we are currently on the incorrect position in our file
+		// handle
+		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);
+	if (next_csv_buffer->GetBufferSize() == 0) {
+		// We are done reading
+		return nullptr;
+	}
+	return next_csv_buffer;
+}
+
+void CSVBuffer::AllocateBuffer(idx_t buffer_size) {
+	auto &buffer_manager = BufferManager::GetBufferManager(context);
+	bool can_destroy = can_seek;
+	handle = buffer_manager.Allocate(MemoryTag::CSV_READER, MaxValue<idx_t>(Storage::BLOCK_SIZE, buffer_size),
+	                                 can_destroy, &block);
+}
+
+idx_t CSVBuffer::GetBufferSize() {
+	return actual_buffer_size;
+}
+
+void CSVBuffer::Reload(CSVFileHandle &file_handle) {
+	AllocateBuffer(actual_buffer_size);
+	file_handle.Seek(global_csv_start);
+	file_handle.Read(handle.Ptr(), actual_buffer_size);
+}
+
+shared_ptr<CSVBufferHandle> CSVBuffer::Pin(CSVFileHandle &file_handle, bool &has_seeked) {
+	auto &buffer_manager = BufferManager::GetBufferManager(context);
+	if (can_seek && block->IsUnloaded()) {
+		// We have to reload it from disk
+		block = nullptr;
+		Reload(file_handle);
+		has_seeked = true;
+	}
+	return make_shared<CSVBufferHandle>(buffer_manager.Pin(block), actual_buffer_size, last_buffer, file_number,
+	                                    buffer_idx);
+}
+
+void CSVBuffer::Unpin() {
+	if (handle.IsValid()) {
+		handle.Destroy();
+	}
+}
+
+bool CSVBuffer::IsCSVFileLastBuffer() {
+	return last_buffer;
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,124 @@
+#include "duckdb/execution/operator/csv_scanner/buffer_manager/csv_buffer_manager.hpp"
+#include "duckdb/execution/operator/csv_scanner/buffer_manager/csv_buffer.hpp"
+#include "duckdb/function/table/read_csv.hpp"
+namespace duckdb {
+
+CSVBufferManager::CSVBufferManager(ClientContext &context_p, const CSVReaderOptions &options, const string &file_path_p,
+                                   const idx_t file_idx_p)
+    : context(context_p), file_idx(file_idx_p), file_path(file_path_p), buffer_size(CSVBuffer::CSV_BUFFER_SIZE) {
+	D_ASSERT(!file_path.empty());
+	file_handle = ReadCSV::OpenCSV(file_path, options.compression, context);
+	skip_rows = options.dialect_options.skip_rows.GetValue();
+	auto file_size = file_handle->FileSize();
+	if (file_size > 0 && file_size < buffer_size) {
+		buffer_size = CSVBuffer::CSV_MINIMUM_BUFFER_SIZE;
+	}
+	if (options.buffer_size < buffer_size) {
+		buffer_size = options.buffer_size;
+	}
+	Initialize();
+}
+
+void CSVBufferManager::UnpinBuffer(const idx_t cache_idx) {
+	if (cache_idx < cached_buffers.size()) {
+		cached_buffers[cache_idx]->Unpin();
+	}
+}
+
+void CSVBufferManager::Initialize() {
+	if (cached_buffers.empty()) {
+		cached_buffers.emplace_back(
+		    make_shared<CSVBuffer>(context, buffer_size, *file_handle, global_csv_pos, file_idx));
+		last_buffer = cached_buffers.front();
+	}
+}
+
+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);
+			if (!maybe_last_buffer) {
+				last_buffer->last_buffer = true;
+				return false;
+			}
+			last_buffer = std::move(maybe_last_buffer);
+			bytes_read += last_buffer->GetBufferSize();
+			cached_buffers.emplace_back(last_buffer);
+			return true;
+		}
+	}
+	return false;
+}
+
+shared_ptr<CSVBufferHandle> CSVBufferManager::GetBuffer(const idx_t pos) {
+	lock_guard<mutex> parallel_lock(main_mutex);
+	while (pos >= cached_buffers.size()) {
+		if (done) {
+			return nullptr;
+		}
+		if (!ReadNextAndCacheIt()) {
+			done = true;
+		}
+	}
+	if (pos != 0) {
+		if (cached_buffers[pos - 1]) {
+			cached_buffers[pos - 1]->Unpin();
+		}
+	}
+	return cached_buffers[pos]->Pin(*file_handle, has_seeked);
+}
+
+void CSVBufferManager::ResetBuffer(const idx_t buffer_idx) {
+	D_ASSERT(buffer_idx < cached_buffers.size() && cached_buffers[buffer_idx]);
+	if (buffer_idx == 0 && cached_buffers.size() > 1) {
+		cached_buffers[buffer_idx].reset();
+		idx_t cur_buffer = buffer_idx + 1;
+		while (reset_when_possible.find(cur_buffer) != reset_when_possible.end()) {
+			cached_buffers[cur_buffer].reset();
+			reset_when_possible.erase(cur_buffer);
+			cur_buffer++;
+		}
+		return;
+	}
+	// We only reset if previous one was also already reset
+	if (buffer_idx > 0 && !cached_buffers[buffer_idx - 1]) {
+		cached_buffers[buffer_idx].reset();
+		idx_t cur_buffer = buffer_idx + 1;
+		while (reset_when_possible.find(cur_buffer) != reset_when_possible.end()) {
+			cached_buffers[cur_buffer].reset();
+			reset_when_possible.erase(cur_buffer);
+			cur_buffer++;
+		}
+	} else {
+		reset_when_possible.insert(buffer_idx);
+	}
+}
+
+idx_t CSVBufferManager::GetBufferSize() {
+	return buffer_size;
+}
+
+idx_t CSVBufferManager::BufferCount() {
+	return cached_buffers.size();
+}
+
+bool CSVBufferManager::Done() {
+	return done;
+}
+
+string CSVBufferManager::GetFilePath() {
+	return file_path;
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,97 @@
+#include "duckdb/execution/operator/csv_scanner/buffer_manager/csv_file_handle.hpp"
+#include "duckdb/common/exception/binder_exception.hpp"
+
+namespace duckdb {
+
+CSVFileHandle::CSVFileHandle(FileSystem &fs, Allocator &allocator, unique_ptr<FileHandle> file_handle_p,
+                             const string &path_p, FileCompressionType compression)
+    : file_handle(std::move(file_handle_p)), path(path_p) {
+	can_seek = file_handle->CanSeek();
+	on_disk_file = file_handle->OnDiskFile();
+	file_size = file_handle->GetFileSize();
+	uncompressed = compression == FileCompressionType::UNCOMPRESSED;
+}
+
+unique_ptr<FileHandle> CSVFileHandle::OpenFileHandle(FileSystem &fs, Allocator &allocator, const string &path,
+                                                     FileCompressionType compression) {
+	auto file_handle = fs.OpenFile(path, FileFlags::FILE_FLAGS_READ, FileLockType::NO_LOCK, compression);
+	if (file_handle->CanSeek()) {
+		file_handle->Reset();
+	}
+	return file_handle;
+}
+
+unique_ptr<CSVFileHandle> CSVFileHandle::OpenFile(FileSystem &fs, Allocator &allocator, const string &path,
+                                                  FileCompressionType compression) {
+	auto file_handle = CSVFileHandle::OpenFileHandle(fs, allocator, path, compression);
+	return make_uniq<CSVFileHandle>(fs, allocator, std::move(file_handle), path, compression);
+}
+
+bool CSVFileHandle::CanSeek() {
+	return can_seek;
+}
+
+void CSVFileHandle::Seek(idx_t position) {
+	if (!can_seek) {
+		throw InternalException("Cannot seek in this file");
+	}
+	file_handle->Seek(position);
+}
+
+bool CSVFileHandle::OnDiskFile() {
+	return on_disk_file;
+}
+
+idx_t CSVFileHandle::FileSize() {
+	return file_size;
+}
+
+bool CSVFileHandle::FinishedReading() {
+	return finished;
+}
+
+idx_t CSVFileHandle::Read(void *buffer, idx_t nr_bytes) {
+	requested_bytes += nr_bytes;
+	// if this is a plain file source OR we can seek we are not caching anything
+	auto bytes_read = file_handle->Read(buffer, nr_bytes);
+	if (!finished) {
+		finished = bytes_read == 0;
+	}
+	return bytes_read;
+}
+
+string CSVFileHandle::ReadLine() {
+	bool carriage_return = false;
+	string result;
+	char buffer[1];
+	while (true) {
+		idx_t bytes_read = Read(buffer, 1);
+		if (bytes_read == 0) {
+			return result;
+		}
+		if (carriage_return) {
+			if (buffer[0] != '\n') {
+				if (!file_handle->CanSeek()) {
+					throw BinderException(
+					    "Carriage return newlines not supported when reading CSV files in which we cannot seek");
+				}
+				file_handle->Seek(file_handle->SeekPosition() - 1);
+				return result;
+			}
+		}
+		if (buffer[0] == '\n') {
+			return result;
+		}
+		if (buffer[0] != '\r') {
+			result += buffer[0];
+		} else {
+			carriage_return = true;
+		}
+	}
+}
+
+string CSVFileHandle::GetFilePath() {
+	return path;
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,71 @@
+#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp"
+#include "duckdb/execution/operator/csv_scanner/scanner/base_scanner.hpp"
+
+namespace duckdb {
+
+ScannerResult::ScannerResult(CSVStates &states_p, CSVStateMachine &state_machine_p)
+    : states(states_p), state_machine(state_machine_p) {
+}
+
+BaseScanner::BaseScanner(shared_ptr<CSVBufferManager> buffer_manager_p, shared_ptr<CSVStateMachine> state_machine_p,
+                         shared_ptr<CSVErrorHandler> error_handler_p, shared_ptr<CSVFileScan> csv_file_scan_p,
+                         CSVIterator iterator_p)
+    : csv_file_scan(std::move(csv_file_scan_p)), error_handler(std::move(error_handler_p)),
+      state_machine(std::move(state_machine_p)), iterator(iterator_p), buffer_manager(std::move(buffer_manager_p)) {
+	D_ASSERT(buffer_manager);
+	D_ASSERT(state_machine);
+	// Initialize current buffer handle
+	cur_buffer_handle = buffer_manager->GetBuffer(iterator.GetBufferIdx());
+	if (!cur_buffer_handle) {
+		buffer_handle_ptr = nullptr;
+	} else {
+		buffer_handle_ptr = cur_buffer_handle->Ptr();
+	}
+}
+
+bool BaseScanner::FinishedFile() {
+	if (!cur_buffer_handle) {
+		return true;
+	}
+	// we have to scan to infinity, so we must check if we are done checking the whole file
+	if (!buffer_manager->Done()) {
+		return false;
+	}
+	// If yes, are we in the last buffer?
+	if (iterator.pos.buffer_idx != buffer_manager->BufferCount()) {
+		return false;
+	}
+	// If yes, are we in the last position?
+	return iterator.pos.buffer_pos + 1 == cur_buffer_handle->actual_size;
+}
+
+void BaseScanner::Reset() {
+	iterator.SetCurrentPositionToBoundary();
+	lines_read = 0;
+}
+
+CSVIterator &BaseScanner::GetIterator() {
+	return iterator;
+}
+
+ScannerResult &BaseScanner::ParseChunk() {
+	throw InternalException("ParseChunk() from CSV Base Scanner is mot implemented");
+}
+
+ScannerResult &BaseScanner::GetResult() {
+	throw InternalException("GetResult() from CSV Base Scanner is mot implemented");
+}
+
+void BaseScanner::Initialize() {
+	throw InternalException("Initialize() from CSV Base Scanner is mot implemented");
+}
+
+void BaseScanner::FinalizeChunkProcess() {
+	throw InternalException("FinalizeChunkProcess() from CSV Base Scanner is mot implemented");
+}
+
+CSVStateMachine &BaseScanner::GetStateMachine() {
+	return *state_machine;
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,98 @@
+#include "duckdb/execution/operator/csv_scanner/scanner/column_count_scanner.hpp"
+
+namespace duckdb {
+
+ColumnCountResult::ColumnCountResult(CSVStates &states, CSVStateMachine &state_machine)
+    : ScannerResult(states, state_machine) {
+}
+
+void ColumnCountResult::AddValue(ColumnCountResult &result, const idx_t buffer_pos) {
+	result.current_column_count++;
+}
+
+inline void ColumnCountResult::InternalAddRow() {
+	column_counts[result_position++] = current_column_count + 1;
+	current_column_count = 0;
+}
+
+bool ColumnCountResult::AddRow(ColumnCountResult &result, const idx_t buffer_pos) {
+	result.InternalAddRow();
+	if (!result.states.EmptyLastValue()) {
+		result.last_value_always_empty = false;
+	}
+	if (result.result_position >= STANDARD_VECTOR_SIZE) {
+		// We sniffed enough rows
+		return true;
+	}
+	return false;
+}
+
+void ColumnCountResult::InvalidState(ColumnCountResult &result) {
+	result.result_position = 0;
+	result.error = true;
+}
+
+bool ColumnCountResult::EmptyLine(ColumnCountResult &result, const idx_t buffer_pos) {
+	// nop
+	return false;
+}
+
+void ColumnCountResult::QuotedNewLine(ColumnCountResult &result) {
+	// nop
+}
+
+ColumnCountScanner::ColumnCountScanner(shared_ptr<CSVBufferManager> buffer_manager,
+                                       const shared_ptr<CSVStateMachine> &state_machine,
+                                       shared_ptr<CSVErrorHandler> error_handler)
+    : BaseScanner(std::move(buffer_manager), state_machine, std::move(error_handler)), result(states, *state_machine),
+      column_count(1) {
+	sniffing = true;
+}
+
+unique_ptr<StringValueScanner> ColumnCountScanner::UpgradeToStringValueScanner() {
+	auto scanner = make_uniq<StringValueScanner>(0, buffer_manager, state_machine, error_handler, nullptr);
+	scanner->sniffing = true;
+	return scanner;
+}
+
+ColumnCountResult &ColumnCountScanner::ParseChunk() {
+	result.result_position = 0;
+	column_count = 1;
+	ParseChunkInternal(result);
+	return result;
+}
+
+ColumnCountResult &ColumnCountScanner::GetResult() {
+	return result;
+}
+
+void ColumnCountScanner::Initialize() {
+	states.Initialize();
+}
+
+void ColumnCountScanner::FinalizeChunkProcess() {
+	if (result.result_position == STANDARD_VECTOR_SIZE || result.error) {
+		// We are done
+		return;
+	}
+	// We run until we have a full chunk, or we are done scanning
+	while (!FinishedFile() && result.result_position < STANDARD_VECTOR_SIZE && !result.error) {
+		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.EmptyLine() || states.NewRow() || states.IsCurrentNewRow() || states.IsNotSet()) {
+					return;
+				}
+				// This means we reached the end of the file, we must add a last line if there is any to be added
+				result.InternalAddRow();
+				return;
+			}
+			iterator.pos.buffer_pos = 0;
+			buffer_handle_ptr = cur_buffer_handle->Ptr();
+		}
+		Process(result);
+	}
+}
+} // namespace duckdb

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

@@ -0,0 +1,105 @@
+#include "duckdb/execution/operator/csv_scanner/scanner/scanner_boundary.hpp"
+
+namespace duckdb {
+
+CSVPosition::CSVPosition(idx_t file_idx_p, idx_t buffer_idx_p, idx_t buffer_pos_p)
+    : file_idx(file_idx_p), buffer_idx(buffer_idx_p), buffer_pos(buffer_pos_p) {
+}
+CSVPosition::CSVPosition() {
+}
+
+CSVBoundary::CSVBoundary(idx_t file_idx_p, idx_t buffer_idx_p, idx_t buffer_pos_p, idx_t boundary_idx_p,
+                         idx_t end_pos_p)
+    : file_idx(file_idx_p), buffer_idx(buffer_idx_p), buffer_pos(buffer_pos_p), boundary_idx(boundary_idx_p),
+      end_pos(end_pos_p) {
+}
+CSVBoundary::CSVBoundary()
+    : file_idx(0), buffer_idx(0), buffer_pos(0), boundary_idx(0), end_pos(NumericLimits<idx_t>::Maximum()) {
+}
+CSVIterator::CSVIterator(idx_t file_idx, idx_t buffer_idx, idx_t buffer_pos, idx_t boundary_idx, idx_t buffer_size)
+    : pos(file_idx, buffer_idx, buffer_pos), is_set(true) {
+	// The end of our boundary will be the buffer size itself it that's smaller than where we want to go
+	if (buffer_size < buffer_pos + BYTES_PER_THREAD) {
+		boundary = {file_idx, buffer_idx, buffer_pos, boundary_idx, buffer_size};
+	} else {
+		boundary = {file_idx, buffer_idx, buffer_pos, boundary_idx, buffer_pos + BYTES_PER_THREAD};
+	}
+}
+
+CSVIterator::CSVIterator() : is_set(false) {
+}
+
+void CSVBoundary::Print() {
+	std::cout << "---Boundary: " << boundary_idx << " ---" << std::endl;
+	std::cout << "File Index:: " << file_idx << std::endl;
+	std::cout << "Buffer Index: " << buffer_idx << std::endl;
+	std::cout << "Buffer Pos: " << buffer_pos << std::endl;
+	std::cout << "End Pos: " << end_pos << std::endl;
+	std::cout << "------------" << end_pos << std::endl;
+}
+
+void CSVIterator::Print() {
+	boundary.Print();
+	std::cout << "Is set: " << is_set << std::endl;
+}
+
+bool CSVIterator::Next(CSVBufferManager &buffer_manager) {
+	if (!is_set) {
+		return false;
+	}
+	boundary.boundary_idx++;
+	// This is our start buffer
+	auto buffer = buffer_manager.GetBuffer(boundary.buffer_idx);
+	if (buffer->is_last_buffer && boundary.buffer_pos + CSVIterator::BYTES_PER_THREAD > buffer->actual_size) {
+		// 1) We are done with the current file
+		return false;
+	} else if (boundary.buffer_pos + BYTES_PER_THREAD >= buffer->actual_size) {
+		// 2) We still have data to scan in this file, we set the iterator accordingly.
+		// We must move the buffer
+		boundary.buffer_idx++;
+		boundary.buffer_pos = 0;
+		// Verify this buffer really exists
+		auto next_buffer = buffer_manager.GetBuffer(boundary.buffer_idx);
+		if (!next_buffer) {
+			return false;
+		}
+
+	} else {
+		// 3) We are not done with the current buffer, hence we just move where we start within the buffer
+		boundary.buffer_pos += BYTES_PER_THREAD;
+	}
+	boundary.end_pos = boundary.buffer_pos + BYTES_PER_THREAD;
+	SetCurrentPositionToBoundary();
+	return true;
+}
+
+bool CSVIterator::IsBoundarySet() const {
+	return is_set;
+}
+idx_t CSVIterator::GetEndPos() const {
+	return boundary.end_pos;
+}
+
+idx_t CSVIterator::GetFileIdx() const {
+	return pos.file_idx;
+}
+
+idx_t CSVIterator::GetBufferIdx() const {
+	return boundary.buffer_idx;
+}
+
+idx_t CSVIterator::GetBoundaryIdx() const {
+	return boundary.boundary_idx;
+}
+
+void CSVIterator::SetCurrentPositionToBoundary() {
+	pos.file_idx = boundary.file_idx;
+	pos.buffer_idx = boundary.buffer_idx;
+	pos.buffer_pos = boundary.buffer_pos;
+}
+
+void CSVIterator::SetStart(idx_t start) {
+	boundary.buffer_pos = start;
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,63 @@
+#include "duckdb/execution/operator/csv_scanner/scanner/skip_scanner.hpp"
+#include "duckdb/execution/operator/csv_scanner/scanner/column_count_scanner.hpp"
+
+namespace duckdb {
+
+SkipResult::SkipResult(CSVStates &states, CSVStateMachine &state_machine, idx_t rows_to_skip_p)
+    : ScannerResult(states, state_machine), rows_to_skip(rows_to_skip_p) {
+}
+
+void SkipResult::AddValue(SkipResult &result, const idx_t buffer_pos) {
+	// nop
+}
+
+inline void SkipResult::InternalAddRow() {
+	row_count++;
+}
+
+void SkipResult::QuotedNewLine(SkipResult &result) {
+	// nop
+}
+
+bool SkipResult::AddRow(SkipResult &result, const idx_t buffer_pos) {
+	result.InternalAddRow();
+	if (result.row_count >= result.rows_to_skip) {
+		// We skipped enough rows
+		return true;
+	}
+	return false;
+}
+
+void SkipResult::InvalidState(SkipResult &result) {
+	// nop
+}
+
+bool SkipResult::EmptyLine(SkipResult &result, const idx_t buffer_pos) {
+	if (result.state_machine.dialect_options.num_cols == 1) {
+		return AddRow(result, buffer_pos);
+	}
+	return false;
+}
+SkipScanner::SkipScanner(shared_ptr<CSVBufferManager> buffer_manager, const shared_ptr<CSVStateMachine> &state_machine,
+                         shared_ptr<CSVErrorHandler> error_handler, idx_t rows_to_skip)
+    : BaseScanner(std::move(buffer_manager), state_machine, std::move(error_handler)),
+      result(states, *state_machine, rows_to_skip) {
+}
+
+SkipResult &SkipScanner::ParseChunk() {
+	ParseChunkInternal(result);
+	return result;
+}
+
+SkipResult &SkipScanner::GetResult() {
+	return result;
+}
+
+void SkipScanner::Initialize() {
+	states.Initialize();
+}
+
+void SkipScanner::FinalizeChunkProcess() {
+	// nop
+}
+} // namespace duckdb