duckdb 1.1.4-dev2.0 → 1.1.4-dev9.0

package/src/duckdb/src/execution/operator/csv_scanner/buffered_csv_reader.cpp

@@ -1,434 +0,0 @@
-#include "duckdb/execution/operator/scan/csv/buffered_csv_reader.hpp"
-
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/to_string.hpp"
-#include "duckdb/common/types/cast_helpers.hpp"
-#include "duckdb/common/vector_operations/unary_executor.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/operator/scan/csv/csv_sniffer.hpp"
-#include "duckdb/execution/operator/scan/csv/csv_state_machine.hpp"
-#include "duckdb/function/scalar/strftime_format.hpp"
-#include "duckdb/main/client_data.hpp"
-#include "duckdb/main/database.hpp"
-#include "duckdb/main/error_manager.hpp"
-#include "duckdb/parser/column_definition.hpp"
-#include "duckdb/parser/keyword_helper.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "utf8proc.hpp"
-#include "utf8proc_wrapper.hpp"
-
-#include <algorithm>
-#include <cctype>
-#include <cstring>
-#include <fstream>
-
-namespace duckdb {
-
-BufferedCSVReader::BufferedCSVReader(ClientContext &context, CSVReaderOptions options_p,
-                                     const vector<LogicalType> &requested_types)
-    : BaseCSVReader(context, std::move(options_p), requested_types), buffer_size(0), position(0), start(0) {
-	file_handle = OpenCSV(context, options);
-	Initialize(requested_types);
-}
-
-BufferedCSVReader::BufferedCSVReader(ClientContext &context, string filename, CSVReaderOptions options_p,
-                                     const vector<LogicalType> &requested_types)
-    : BaseCSVReader(context, std::move(options_p), requested_types), buffer_size(0), position(0), start(0) {
-	options.file_path = std::move(filename);
-	file_handle = OpenCSV(context, options);
-	Initialize(requested_types);
-}
-
-void BufferedCSVReader::Initialize(const vector<LogicalType> &requested_types) {
-	if (options.auto_detect && options.file_options.union_by_name) {
-		// This is required for the sniffer to work on Union By Name
-		D_ASSERT(options.file_path == file_handle->GetFilePath());
-		auto bm_file_handle = BaseCSVReader::OpenCSV(context, options);
-		auto csv_buffer_manager = make_shared<CSVBufferManager>(context, std::move(bm_file_handle), options);
-		CSVSniffer sniffer(options, csv_buffer_manager, state_machine_cache);
-		auto sniffer_result = sniffer.SniffCSV();
-		return_types = sniffer_result.return_types;
-		names = sniffer_result.names;
-		if (return_types.empty()) {
-			throw InvalidInputException("Failed to detect column types from CSV: is the file a valid CSV file?");
-		}
-	} else {
-		return_types = requested_types;
-		ResetBuffer();
-	}
-	SkipRowsAndReadHeader(options.dialect_options.skip_rows, options.dialect_options.header);
-	InitParseChunk(return_types.size());
-}
-
-void BufferedCSVReader::ResetBuffer() {
-	buffer.reset();
-	buffer_size = 0;
-	position = 0;
-	start = 0;
-	cached_buffers.clear();
-}
-
-void BufferedCSVReader::SkipRowsAndReadHeader(idx_t skip_rows, bool skip_header) {
-	for (idx_t i = 0; i < skip_rows; i++) {
-		// ignore skip rows
-		string read_line = file_handle->ReadLine();
-		linenr++;
-	}
-
-	if (skip_header) {
-		// ignore the first line as a header line
-		InitParseChunk(return_types.size());
-		ParseCSV(ParserMode::PARSING_HEADER);
-	}
-}
-
-string BufferedCSVReader::ColumnTypesError(case_insensitive_map_t<idx_t> sql_types_per_column,
-                                           const vector<string> &names) {
-	for (idx_t i = 0; i < names.size(); i++) {
-		auto it = sql_types_per_column.find(names[i]);
-		if (it != sql_types_per_column.end()) {
-			sql_types_per_column.erase(names[i]);
-			continue;
-		}
-	}
-	if (sql_types_per_column.empty()) {
-		return string();
-	}
-	string exception = "COLUMN_TYPES error: Columns with names: ";
-	for (auto &col : sql_types_per_column) {
-		exception += "\"" + col.first + "\",";
-	}
-	exception.pop_back();
-	exception += " do not exist in the CSV File";
-	return exception;
-}
-
-void BufferedCSVReader::SkipEmptyLines() {
-	if (parse_chunk.data.size() == 1) {
-		// Empty lines are null data.
-		return;
-	}
-	for (; position < buffer_size; position++) {
-		if (!StringUtil::CharacterIsNewline(buffer[position])) {
-			return;
-		}
-	}
-}
-
-void UpdateMaxLineLength(ClientContext &context, idx_t line_length) {
-	if (!context.client_data->debug_set_max_line_length) {
-		return;
-	}
-	if (line_length < context.client_data->debug_max_line_length) {
-		return;
-	}
-	context.client_data->debug_max_line_length = line_length;
-}
-
-bool BufferedCSVReader::ReadBuffer(idx_t &start, idx_t &line_start) {
-	if (start > buffer_size) {
-		return false;
-	}
-	auto old_buffer = std::move(buffer);
-
-	// the remaining part of the last buffer
-	idx_t remaining = buffer_size - start;
-
-	idx_t buffer_read_size = INITIAL_BUFFER_SIZE_LARGE;
-
-	while (remaining > buffer_read_size) {
-		buffer_read_size *= 2;
-	}
-
-	// Check line length
-	if (remaining > options.maximum_line_size) {
-		throw InvalidInputException("Maximum line size of %llu bytes exceeded on line %s!", options.maximum_line_size,
-		                            GetLineNumberStr(linenr, linenr_estimated));
-	}
-
-	buffer = make_unsafe_uniq_array<char>(buffer_read_size + remaining + 1);
-	buffer_size = remaining + buffer_read_size;
-	if (remaining > 0) {
-		// remaining from last buffer: copy it here
-		memcpy(buffer.get(), old_buffer.get() + start, remaining);
-	}
-	idx_t read_count = file_handle->Read(buffer.get() + remaining, buffer_read_size);
-
-	bytes_in_chunk += read_count;
-	buffer_size = remaining + read_count;
-	buffer[buffer_size] = '\0';
-	if (old_buffer) {
-		cached_buffers.push_back(std::move(old_buffer));
-	}
-	start = 0;
-	position = remaining;
-	if (!bom_checked) {
-		bom_checked = true;
-		if (read_count >= 3 && buffer[0] == '\xEF' && buffer[1] == '\xBB' && buffer[2] == '\xBF') {
-			start += 3;
-			position += 3;
-		}
-	}
-	line_start = start;
-
-	return read_count > 0;
-}
-
-void BufferedCSVReader::ParseCSV(DataChunk &insert_chunk) {
-	string error_message;
-	if (!TryParseCSV(ParserMode::PARSING, insert_chunk, error_message)) {
-		throw InvalidInputException(error_message);
-	}
-}
-
-void BufferedCSVReader::ParseCSV(ParserMode mode) {
-	DataChunk dummy_chunk;
-	string error_message;
-	if (!TryParseCSV(mode, dummy_chunk, error_message)) {
-		throw InvalidInputException(error_message);
-	}
-}
-
-bool BufferedCSVReader::TryParseCSV(ParserMode parser_mode, DataChunk &insert_chunk, string &error_message) {
-	cached_buffers.clear();
-	mode = parser_mode;
-	// used for parsing algorithm
-	bool finished_chunk = false;
-	idx_t column = 0;
-	idx_t offset = 0;
-	bool has_quotes = false;
-	vector<idx_t> escape_positions;
-
-	idx_t line_start = position;
-	idx_t line_size = 0;
-	// read values into the buffer (if any)
-	if (position >= buffer_size) {
-		if (!ReadBuffer(start, line_start)) {
-			return true;
-		}
-	}
-
-	// start parsing the first value
-	goto value_start;
-value_start:
-	offset = 0;
-	/* state: value_start */
-	// this state parses the first character of a value
-	if (buffer[position] == options.dialect_options.state_machine_options.quote) {
-		// quote: actual value starts in the next position
-		// move to in_quotes state
-		start = position + 1;
-		line_size++;
-		goto in_quotes;
-	} else {
-		// no quote, move to normal parsing state
-		start = position;
-		goto normal;
-	}
-normal:
-	/* state: normal parsing state */
-	// this state parses the remainder of a non-quoted value until we reach a delimiter or newline
-	do {
-		for (; position < buffer_size; position++) {
-			line_size++;
-			if (buffer[position] == options.dialect_options.state_machine_options.delimiter) {
-				// delimiter: end the value and add it to the chunk
-				goto add_value;
-			} else if (StringUtil::CharacterIsNewline(buffer[position])) {
-				// newline: add row
-				goto add_row;
-			}
-		}
-	} while (ReadBuffer(start, line_start));
-	// file ends during normal scan: go to end state
-	goto final_state;
-add_value:
-	AddValue(string_t(buffer.get() + start, position - start - offset), column, escape_positions, has_quotes);
-	// increase position by 1 and move start to the new position
-	offset = 0;
-	has_quotes = false;
-	start = ++position;
-	line_size++;
-	if (position >= buffer_size && !ReadBuffer(start, line_start)) {
-		// file ends right after delimiter, go to final state
-		goto final_state;
-	}
-	goto value_start;
-add_row : {
-	// check type of newline (\r or \n)
-	bool carriage_return = buffer[position] == '\r';
-	AddValue(string_t(buffer.get() + start, position - start - offset), column, escape_positions, has_quotes);
-	if (!error_message.empty()) {
-		return false;
-	}
-	VerifyLineLength(position - line_start);
-
-	finished_chunk = AddRow(insert_chunk, column, error_message);
-	UpdateMaxLineLength(context, position - line_start);
-	if (!error_message.empty()) {
-		return false;
-	}
-	// increase position by 1 and move start to the new position
-	offset = 0;
-	has_quotes = false;
-	position++;
-	line_size = 0;
-	start = position;
-	line_start = position;
-	if (position >= buffer_size && !ReadBuffer(start, line_start)) {
-		// file ends right after delimiter, go to final state
-		goto final_state;
-	}
-	if (carriage_return) {
-		// \r newline, go to special state that parses an optional \n afterwards
-		goto carriage_return;
-	} else {
-		SetNewLineDelimiter();
-		SkipEmptyLines();
-
-		start = position;
-		line_start = position;
-		if (position >= buffer_size && !ReadBuffer(start, line_start)) {
-			// file ends right after delimiter, go to final state
-			goto final_state;
-		}
-		// \n newline, move to value start
-		if (finished_chunk) {
-			return true;
-		}
-		goto value_start;
-	}
-}
-in_quotes:
-	/* state: in_quotes */
-	// this state parses the remainder of a quoted value
-	has_quotes = true;
-	position++;
-	line_size++;
-	do {
-		for (; position < buffer_size; position++) {
-			line_size++;
-			if (buffer[position] == options.dialect_options.state_machine_options.quote) {
-				// quote: move to unquoted state
-				goto unquote;
-			} else if (buffer[position] == options.dialect_options.state_machine_options.escape) {
-				// escape: store the escaped position and move to handle_escape state
-				escape_positions.push_back(position - start);
-				goto handle_escape;
-			}
-		}
-	} while (ReadBuffer(start, line_start));
-	// still in quoted state at the end of the file, error:
-	throw InvalidInputException("Error in file \"%s\" on line %s: unterminated quotes. (%s)", options.file_path,
-	                            GetLineNumberStr(linenr, linenr_estimated).c_str(), options.ToString());
-unquote:
-	/* state: unquote */
-	// this state handles the state directly after we unquote
-	// in this state we expect either another quote (entering the quoted state again, and escaping the quote)
-	// or a delimiter/newline, ending the current value and moving on to the next value
-	position++;
-	line_size++;
-	if (position >= buffer_size && !ReadBuffer(start, line_start)) {
-		// file ends right after unquote, go to final state
-		offset = 1;
-		goto final_state;
-	}
-	if (buffer[position] == options.dialect_options.state_machine_options.quote &&
-	    (options.dialect_options.state_machine_options.escape == '\0' ||
-	     options.dialect_options.state_machine_options.escape == options.dialect_options.state_machine_options.quote)) {
-		// escaped quote, return to quoted state and store escape position
-		escape_positions.push_back(position - start);
-		goto in_quotes;
-	} else if (buffer[position] == options.dialect_options.state_machine_options.delimiter) {
-		// delimiter, add value
-		offset = 1;
-		goto add_value;
-	} else if (StringUtil::CharacterIsNewline(buffer[position])) {
-		offset = 1;
-		goto add_row;
-	} else {
-		error_message = StringUtil::Format(
-		    "Error in file \"%s\" on line %s: quote should be followed by end of value, end of "
-		    "row or another quote. (%s)",
-		    options.file_path, GetLineNumberStr(linenr, linenr_estimated).c_str(), options.ToString());
-		return false;
-	}
-handle_escape:
-	/* state: handle_escape */
-	// escape should be followed by a quote or another escape character
-	position++;
-	line_size++;
-	if (position >= buffer_size && !ReadBuffer(start, line_start)) {
-		error_message = StringUtil::Format(
-		    "Error in file \"%s\" on line %s: neither QUOTE nor ESCAPE is proceeded by ESCAPE. (%s)", options.file_path,
-		    GetLineNumberStr(linenr, linenr_estimated).c_str(), options.ToString());
-		return false;
-	}
-	if (buffer[position] != options.dialect_options.state_machine_options.quote &&
-	    buffer[position] != options.dialect_options.state_machine_options.escape) {
-		error_message = StringUtil::Format(
-		    "Error in file \"%s\" on line %s: neither QUOTE nor ESCAPE is proceeded by ESCAPE. (%s)", options.file_path,
-		    GetLineNumberStr(linenr, linenr_estimated).c_str(), options.ToString());
-		return false;
-	}
-	// escape was followed by quote or escape, go back to quoted state
-	goto in_quotes;
-carriage_return:
-	/* state: carriage_return */
-	// this stage optionally skips a newline (\n) character, which allows \r\n to be interpreted as a single line
-	if (buffer[position] == '\n') {
-		SetNewLineDelimiter(true, true);
-		// newline after carriage return: skip
-		// increase position by 1 and move start to the new position
-		start = ++position;
-		line_size++;
-
-		if (position >= buffer_size && !ReadBuffer(start, line_start)) {
-			// file ends right after delimiter, go to final state
-			goto final_state;
-		}
-	} else {
-		SetNewLineDelimiter(true, false);
-	}
-	if (finished_chunk) {
-		return true;
-	}
-	SkipEmptyLines();
-	start = position;
-	line_start = position;
-	if (position >= buffer_size && !ReadBuffer(start, line_start)) {
-		// file ends right after delimiter, go to final state
-		goto final_state;
-	}
-
-	goto value_start;
-final_state:
-	if (finished_chunk) {
-		return true;
-	}
-
-	if (column > 0 || position > start) {
-		// remaining values to be added to the chunk
-		AddValue(string_t(buffer.get() + start, position - start - offset), column, escape_positions, has_quotes);
-		VerifyLineLength(position - line_start);
-
-		finished_chunk = AddRow(insert_chunk, column, error_message);
-		SkipEmptyLines();
-		UpdateMaxLineLength(context, line_size);
-		if (!error_message.empty()) {
-			return false;
-		}
-	}
-
-	// final stage, only reached after parsing the file is finished
-	// flush the parsed chunk and finalize parsing
-	if (mode == ParserMode::PARSING) {
-		Flush(insert_chunk);
-	}
-
-	return true;
-}
-
-} // namespace duckdb

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

@@ -1,89 +0,0 @@
-#include "duckdb/execution/operator/scan/csv/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), first_buffer(true), 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;
-	// BOM check (https://en.wikipedia.org/wiki/Byte_order_mark)
-	if (actual_buffer_size >= 3 && buffer[0] == '\xEF' && buffer[1] == '\xBB' && buffer[2] == '\xBF') {
-		start_position += 3;
-	}
-	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)
-    : context(context), global_csv_start(global_csv_current_position), file_number(file_number_p),
-      can_seek(file_handle.CanSeek()) {
-	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) {
-	auto next_csv_buffer =
-	    make_shared<CSVBuffer>(file_handle, context, buffer_size, global_csv_start + actual_buffer_size, file_number_p);
-	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(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);
-}
-
-unique_ptr<CSVBufferHandle> CSVBuffer::Pin(CSVFileHandle &file_handle) {
-	auto &buffer_manager = BufferManager::GetBufferManager(context);
-	if (can_seek && block->IsUnloaded()) {
-		// We have to reload it from disk
-		block = nullptr;
-		Reload(file_handle);
-	}
-	return make_uniq<CSVBufferHandle>(buffer_manager.Pin(block), actual_buffer_size, first_buffer, last_buffer,
-	                                  global_csv_start, start_position, file_number);
-}
-
-void CSVBuffer::Unpin() {
-	if (handle.IsValid()) {
-		handle.Destroy();
-	}
-}
-
-idx_t CSVBuffer::GetStart() {
-	return start_position;
-}
-
-bool CSVBuffer::IsCSVFileLastBuffer() {
-	return last_buffer;
-}
-
-} // namespace duckdb

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

@@ -1,90 +0,0 @@
-#include "duckdb/execution/operator/scan/csv/csv_buffer_manager.hpp"
-#include "duckdb/execution/operator/scan/csv/csv_buffer.hpp"
-namespace duckdb {
-
-CSVBufferManager::CSVBufferManager(ClientContext &context_p, unique_ptr<CSVFileHandle> file_handle_p,
-                                   const CSVReaderOptions &options, idx_t file_idx_p)
-    : file_handle(std::move(file_handle_p)), context(context_p), file_idx(file_idx_p),
-      buffer_size(CSVBuffer::CSV_BUFFER_SIZE) {
-	if (options.skip_rows_set) {
-		// Skip rows if they are set
-		skip_rows = options.dialect_options.skip_rows;
-	}
-	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;
-	}
-	for (idx_t i = 0; i < skip_rows; i++) {
-		file_handle->ReadLine();
-	}
-	Initialize();
-}
-
-void CSVBufferManager::UnpinBuffer(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();
-	}
-	start_pos = last_buffer->GetStart();
-}
-
-idx_t CSVBufferManager::GetStartPos() {
-	return start_pos;
-}
-bool CSVBufferManager::ReadNextAndCacheIt() {
-	D_ASSERT(last_buffer);
-	if (!last_buffer->IsCSVFileLastBuffer()) {
-		auto maybe_last_buffer = last_buffer->Next(*file_handle, buffer_size, file_idx);
-		if (!maybe_last_buffer) {
-			last_buffer->last_buffer = true;
-			return false;
-		}
-		last_buffer = std::move(maybe_last_buffer);
-		cached_buffers.emplace_back(last_buffer);
-		return true;
-	}
-	return false;
-}
-
-unique_ptr<CSVBufferHandle> CSVBufferManager::GetBuffer(const idx_t pos) {
-	while (pos >= cached_buffers.size()) {
-		if (done) {
-			return nullptr;
-		}
-		if (!ReadNextAndCacheIt()) {
-			done = true;
-		}
-	}
-	if (pos != 0) {
-		cached_buffers[pos - 1]->Unpin();
-	}
-	return cached_buffers[pos]->Pin(*file_handle);
-}
-
-bool CSVBufferIterator::Finished() {
-	return !cur_buffer_handle;
-}
-
-void CSVBufferIterator::Reset() {
-	if (cur_buffer_handle) {
-		cur_buffer_handle.reset();
-	}
-	if (cur_buffer_idx > 0) {
-		buffer_manager->UnpinBuffer(cur_buffer_idx - 1);
-	}
-	cur_buffer_idx = 0;
-	buffer_manager->Initialize();
-	cur_pos = buffer_manager->GetStartPos();
-}
-
-} // namespace duckdb

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

@@ -1,95 +0,0 @@
-#include "duckdb/execution/operator/scan/csv/csv_file_handle.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();
-}
-
-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