duckdb 0.9.3-dev2.0 → 0.10.0

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/scanner/base_scanner.hpp

@@ -0,0 +1,228 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/csv_scanner/scanner/base_scanner.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/execution/operator/csv_scanner/buffer_manager/csv_buffer_manager.hpp"
+#include "duckdb/execution/operator/csv_scanner/scanner/scanner_boundary.hpp"
+#include "duckdb/execution/operator/csv_scanner/state_machine/csv_state_machine.hpp"
+#include "duckdb/execution/operator/csv_scanner/util/csv_error.hpp"
+
+namespace duckdb {
+
+class CSVFileScan;
+class ScannerResult {
+public:
+	ScannerResult(CSVStates &states, CSVStateMachine &state_machine);
+
+	//! Adds a Value to the result
+	static inline void SetQuoted(ScannerResult &result, idx_t quoted_position) {
+		if (!result.quoted) {
+			result.quoted_position = quoted_position;
+		}
+		result.quoted = true;
+	}
+	//! Adds a Row to the result
+	static inline void SetEscaped(ScannerResult &result) {
+		result.escaped = true;
+	}
+	// Variable to keep information regarding quoted and escaped values
+	bool quoted = false;
+	bool escaped = false;
+	idx_t quoted_position = 0;
+
+protected:
+	CSVStates &states;
+	CSVStateMachine &state_machine;
+};
+
+//! This is the base of our CSV scanners.
+//! Scanners differ on what they are used for, and consequently have different performance benefits.
+class BaseScanner {
+public:
+	explicit BaseScanner(shared_ptr<CSVBufferManager> buffer_manager, shared_ptr<CSVStateMachine> state_machine,
+	                     shared_ptr<CSVErrorHandler> error_handler, shared_ptr<CSVFileScan> csv_file_scan = nullptr,
+	                     CSVIterator iterator = {});
+
+	virtual ~BaseScanner() = default;
+	//! Returns true if the scanner is finished
+	bool FinishedFile();
+	//! Resets the scanner
+	void Reset();
+	//! Parses data into a output_chunk
+	virtual ScannerResult &ParseChunk();
+
+	//! Returns the result from the last Parse call. Shouts at you if you call it wrong
+	virtual ScannerResult &GetResult();
+
+	CSVIterator &GetIterator();
+
+	idx_t GetBoundaryIndex() {
+		return iterator.GetBoundaryIdx();
+	}
+
+	idx_t GetLinesRead() {
+		return lines_read;
+	}
+
+	idx_t GetIteratorPosition() {
+		return iterator.pos.buffer_pos;
+	}
+
+	CSVStateMachine &GetStateMachine();
+
+	shared_ptr<CSVFileScan> csv_file_scan;
+
+	//! If this scanner is being used for sniffing
+	bool sniffing = false;
+	//! The guy that handles errors
+	shared_ptr<CSVErrorHandler> error_handler;
+
+	//! Shared pointer to the state machine, this is used across multiple scanners
+	shared_ptr<CSVStateMachine> state_machine;
+
+	//! States
+	CSVStates states;
+
+protected:
+	//! Boundaries of this scanner
+	CSVIterator iterator;
+
+	//! Unique pointer to the buffer_handle, this is unique per scanner, since it also contains the necessary counters
+	//! To offload buffers to disk if necessary
+	shared_ptr<CSVBufferHandle> cur_buffer_handle;
+
+	//! Hold the current buffer ptr
+	char *buffer_handle_ptr = nullptr;
+
+	//! Shared pointer to the buffer_manager, this is shared across multiple scanners
+	shared_ptr<CSVBufferManager> buffer_manager;
+
+	//! If this scanner has been initialized
+	bool initialized = false;
+	//! How many lines were read by this scanner
+	idx_t lines_read = 0;
+	idx_t bytes_read = 0;
+	//! Internal Functions used to perform the parsing
+	//! Initializes the scanner
+	virtual void Initialize();
+
+	//! Process one chunk
+	template <class T>
+	void Process(T &result) {
+		idx_t to_pos;
+		const idx_t start_pos = iterator.pos.buffer_pos;
+		if (iterator.IsBoundarySet()) {
+			to_pos = iterator.GetEndPos();
+			if (to_pos > cur_buffer_handle->actual_size) {
+				to_pos = cur_buffer_handle->actual_size;
+			}
+		} else {
+			to_pos = cur_buffer_handle->actual_size;
+		}
+		while (iterator.pos.buffer_pos < to_pos) {
+			state_machine->Transition(states, buffer_handle_ptr[iterator.pos.buffer_pos]);
+			switch (states.states[1]) {
+			case CSVState::INVALID:
+				T::InvalidState(result);
+				iterator.pos.buffer_pos++;
+				bytes_read = iterator.pos.buffer_pos - start_pos;
+				return;
+			case CSVState::RECORD_SEPARATOR:
+				if (states.states[0] == CSVState::RECORD_SEPARATOR || states.states[0] == CSVState::NOT_SET) {
+					lines_read++;
+					if (T::EmptyLine(result, iterator.pos.buffer_pos)) {
+						iterator.pos.buffer_pos++;
+						bytes_read = iterator.pos.buffer_pos - start_pos;
+						return;
+					}
+				} else if (states.states[0] != CSVState::CARRIAGE_RETURN) {
+					lines_read++;
+					if (T::AddRow(result, iterator.pos.buffer_pos)) {
+						iterator.pos.buffer_pos++;
+						bytes_read = iterator.pos.buffer_pos - start_pos;
+						return;
+					}
+				}
+				iterator.pos.buffer_pos++;
+				break;
+			case CSVState::CARRIAGE_RETURN:
+				lines_read++;
+				if (states.states[0] == CSVState::RECORD_SEPARATOR || states.states[0] == CSVState::NOT_SET) {
+					if (T::EmptyLine(result, iterator.pos.buffer_pos)) {
+						iterator.pos.buffer_pos++;
+						bytes_read = iterator.pos.buffer_pos - start_pos;
+						return;
+					}
+				} else if (states.states[0] != CSVState::CARRIAGE_RETURN) {
+					if (T::AddRow(result, iterator.pos.buffer_pos)) {
+						iterator.pos.buffer_pos++;
+						bytes_read = iterator.pos.buffer_pos - start_pos;
+						return;
+					}
+				}
+				iterator.pos.buffer_pos++;
+				break;
+			case CSVState::DELIMITER:
+				T::AddValue(result, iterator.pos.buffer_pos);
+				iterator.pos.buffer_pos++;
+				break;
+			case CSVState::QUOTED:
+				if (states.states[0] == CSVState::UNQUOTED) {
+					T::SetEscaped(result);
+				}
+				T::SetQuoted(result, iterator.pos.buffer_pos);
+				iterator.pos.buffer_pos++;
+				while (state_machine->transition_array
+				           .skip_quoted[static_cast<uint8_t>(buffer_handle_ptr[iterator.pos.buffer_pos])] &&
+				       iterator.pos.buffer_pos < to_pos - 1) {
+					iterator.pos.buffer_pos++;
+				}
+				break;
+			case CSVState::ESCAPE:
+				T::SetEscaped(result);
+				iterator.pos.buffer_pos++;
+				break;
+			case CSVState::STANDARD:
+				iterator.pos.buffer_pos++;
+				while (state_machine->transition_array
+				           .skip_standard[static_cast<uint8_t>(buffer_handle_ptr[iterator.pos.buffer_pos])] &&
+				       iterator.pos.buffer_pos < to_pos - 1) {
+					iterator.pos.buffer_pos++;
+				}
+				break;
+			case CSVState::QUOTED_NEW_LINE:
+				T::QuotedNewLine(result);
+				iterator.pos.buffer_pos++;
+				break;
+			default:
+				iterator.pos.buffer_pos++;
+				break;
+			}
+		}
+		bytes_read = iterator.pos.buffer_pos - start_pos;
+	}
+
+	//! Finalizes the process of the chunk
+	virtual void FinalizeChunkProcess();
+
+	//! Internal function for parse chunk
+	template <class T>
+	void ParseChunkInternal(T &result) {
+		if (!initialized) {
+			Initialize();
+			initialized = true;
+		}
+		if (!iterator.done) {
+			Process(result);
+		}
+		FinalizeChunkProcess();
+	}
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/scanner/column_count_scanner.hpp

@@ -0,0 +1,70 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/csv_scanner/scanner/column_count_scanner.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/execution/operator/csv_scanner/buffer_manager/csv_buffer_manager.hpp"
+#include "duckdb/execution/operator/csv_scanner/state_machine/csv_state_machine.hpp"
+#include "duckdb/execution/operator/csv_scanner/scanner/scanner_boundary.hpp"
+#include "duckdb/execution/operator/csv_scanner/scanner/string_value_scanner.hpp"
+#include "duckdb/execution/operator/csv_scanner/scanner/base_scanner.hpp"
+
+namespace duckdb {
+
+class ColumnCountResult : public ScannerResult {
+public:
+	ColumnCountResult(CSVStates &states, CSVStateMachine &state_machine);
+	inline idx_t &operator[](size_t index) {
+		return column_counts[index];
+	}
+
+	idx_t column_counts[STANDARD_VECTOR_SIZE];
+	idx_t current_column_count = 0;
+	bool error = false;
+	bool last_value_always_empty = true;
+	idx_t result_position = 0;
+
+	//! Adds a Value to the result
+	static inline void AddValue(ColumnCountResult &result, const idx_t buffer_pos);
+	//! Adds a Row to the result
+	static inline bool AddRow(ColumnCountResult &result, const idx_t buffer_pos);
+	//! Behavior when hitting an invalid state
+	static inline void InvalidState(ColumnCountResult &result);
+	//! Handles QuotedNewline State
+	static inline void QuotedNewLine(ColumnCountResult &result);
+	//! Handles EmptyLine states
+	static inline bool EmptyLine(ColumnCountResult &result, const idx_t buffer_pos);
+	inline void InternalAddRow();
+};
+
+//! Scanner that goes over the CSV and figures out how many columns each row has. Used for dialect sniffing
+class ColumnCountScanner : public BaseScanner {
+public:
+	ColumnCountScanner(shared_ptr<CSVBufferManager> buffer_manager, const shared_ptr<CSVStateMachine> &state_machine,
+	                   shared_ptr<CSVErrorHandler> error_handler);
+
+	~ColumnCountScanner() {
+	}
+
+	ColumnCountResult &ParseChunk() override;
+
+	ColumnCountResult &GetResult() override;
+
+	unique_ptr<StringValueScanner> UpgradeToStringValueScanner();
+
+private:
+	void Initialize() override;
+
+	void FinalizeChunkProcess() override;
+
+	ColumnCountResult result;
+
+	idx_t column_count;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/scanner/scanner_boundary.hpp

@@ -0,0 +1,93 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/csv_scanner/scanner/scanner_boundary.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/execution/operator/csv_scanner/buffer_manager/csv_buffer_manager.hpp"
+#include "duckdb/execution/operator/csv_scanner/buffer_manager/csv_file_handle.hpp"
+#include "duckdb/execution/operator/csv_scanner/options/csv_reader_options.hpp"
+#include "duckdb/execution/operator/csv_scanner/state_machine/csv_state_machine.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/common/multi_file_reader.hpp"
+#include "duckdb/common/fast_mem.hpp"
+
+//! We all need boundaries every now and then, CSV Scans also need them
+//! This class keeps track of what a scan should read, so which buffer and from where to where
+//! As in real life, much like my childhood country, the rules are not really enforced.
+//! So the end boundaries of a Scanner Boundary can and will be pushed.
+//! In practice this means that a scanner is tolerated to read one line over it's end.
+namespace duckdb {
+
+//! Information stored in the buffer
+struct CSVBoundary {
+	CSVBoundary(idx_t file_idx, idx_t buffer_idx, idx_t buffer_pos, idx_t boundary_idx, idx_t end_pos);
+	CSVBoundary();
+	void Print();
+	//! File index where we start scanning [0-idx], a scanner can never go over one file.
+	idx_t file_idx = 0;
+	//! Start Buffer index of the file where we start scanning
+	idx_t buffer_idx = 0;
+	//! Start Buffer position of the buffer of the file where we start scanning
+	//! This position moves as we move through the buffer
+	idx_t buffer_pos = 0;
+	//! The boundary index relative to the total scan, only used for parallel reading to enforce
+	//! Insertion Order
+	idx_t boundary_idx = 0;
+	//! Last position this iterator should read.
+	idx_t end_pos;
+};
+
+struct CSVPosition {
+	CSVPosition(idx_t file_idx, idx_t buffer_idx, idx_t buffer_pos);
+	CSVPosition();
+	//! File index where we start scanning [0-idx], a scanner can never go over one file.
+	idx_t file_idx = 0;
+	//! Start Buffer index of the file where we start scanning
+	idx_t buffer_idx = 0;
+	//! Start Buffer position of the buffer of the file where we start scanning
+	//! This position moves as we move through the buffer
+	idx_t buffer_pos = 0;
+};
+struct CSVIterator {
+public:
+	CSVIterator(idx_t file_idx, idx_t buffer_idx, idx_t buffer_pos, idx_t boundary_idx, idx_t buffer_size);
+
+	CSVIterator();
+
+	void Print();
+	//! Moves the boundary to the next one to be scanned, if there are no next boundaries, it returns False
+	//! Otherwise, if there are boundaries, it returns True
+	bool Next(CSVBufferManager &buffer_manager);
+	//! If boundary is set
+	bool IsBoundarySet() const;
+
+	//! Getters
+	idx_t GetEndPos() const;
+	idx_t GetFileIdx() const;
+	idx_t GetBufferIdx() const;
+	idx_t GetBoundaryIdx() const;
+
+	void SetCurrentPositionToBoundary();
+
+	void SetStart(idx_t pos);
+
+	//! 8 MB TODO: Should benchmarks other values
+	static constexpr idx_t BYTES_PER_THREAD = 8000000;
+
+	CSVPosition pos;
+
+	bool done = false;
+
+private:
+	//! The original setting
+	CSVBoundary boundary;
+	//! Sometimes life knows no boundaries.
+	//! The boundaries don't have to be set for single-threaded execution.
+	bool is_set;
+};
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/scanner/skip_scanner.hpp

@@ -0,0 +1,60 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/csv_scanner/scanner/skip_scanner.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/execution/operator/csv_scanner/buffer_manager/csv_buffer_manager.hpp"
+#include "duckdb/execution/operator/csv_scanner/state_machine/csv_state_machine.hpp"
+#include "duckdb/execution/operator/csv_scanner/scanner/scanner_boundary.hpp"
+#include "duckdb/execution/operator/csv_scanner/scanner/string_value_scanner.hpp"
+#include "duckdb/execution/operator/csv_scanner/scanner/base_scanner.hpp"
+
+namespace duckdb {
+
+class SkipResult : public ScannerResult {
+public:
+	SkipResult(CSVStates &states, CSVStateMachine &state_machine, idx_t rows_to_skip);
+
+	idx_t row_count = 0;
+	idx_t rows_to_skip;
+
+	//! Adds a Value to the result
+	static inline void AddValue(SkipResult &result, const idx_t buffer_pos);
+	//! Adds a Row to the result
+	static inline bool AddRow(SkipResult &result, const idx_t buffer_pos);
+	//! Behavior when hitting an invalid state
+	static inline void InvalidState(SkipResult &result);
+	//! Handles EmptyLine states
+	static inline bool EmptyLine(SkipResult &result, const idx_t buffer_pos);
+	//! Handles QuotedNewline State
+	static inline void QuotedNewLine(SkipResult &result);
+	inline void InternalAddRow();
+};
+
+//! Scanner used to skip lines in a CSV File
+class SkipScanner : public BaseScanner {
+public:
+	SkipScanner(shared_ptr<CSVBufferManager> buffer_manager, const shared_ptr<CSVStateMachine> &state_machine,
+	            shared_ptr<CSVErrorHandler> error_handler, idx_t rows_to_skip);
+
+	~SkipScanner() {
+	}
+
+	SkipResult &ParseChunk() override;
+
+	SkipResult &GetResult() override;
+
+private:
+	void Initialize() override;
+
+	void FinalizeChunkProcess() override;
+
+	SkipResult result;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/scanner/string_value_scanner.hpp

@@ -0,0 +1,197 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/csv_scanner/scanner/string_value_scanner.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/execution/operator/csv_scanner/buffer_manager/csv_buffer_manager.hpp"
+#include "duckdb/execution/operator/csv_scanner/state_machine/csv_state_machine.hpp"
+#include "duckdb/execution/operator/csv_scanner/scanner/scanner_boundary.hpp"
+#include "duckdb/execution/operator/csv_scanner/scanner/base_scanner.hpp"
+
+namespace duckdb {
+
+struct CSVBufferUsage {
+	CSVBufferUsage(CSVBufferManager &buffer_manager_p, idx_t buffer_idx_p)
+	    : buffer_manager(buffer_manager_p), buffer_idx(buffer_idx_p) {
+
+	                                        };
+	~CSVBufferUsage() {
+		buffer_manager.ResetBuffer(buffer_idx);
+	}
+	CSVBufferManager &buffer_manager;
+	idx_t buffer_idx;
+};
+
+//! Class that keeps track of line starts, used for line size verification
+class LinePosition {
+public:
+	LinePosition() {
+	}
+	LinePosition(idx_t buffer_idx_p, idx_t buffer_pos_p, idx_t buffer_size_p)
+	    : buffer_pos(buffer_pos_p), buffer_size(buffer_size_p), buffer_idx(buffer_idx_p) {
+	}
+
+	idx_t operator-(const LinePosition &other) {
+		if (other.buffer_idx == buffer_idx) {
+			return buffer_pos - other.buffer_pos;
+		}
+		return other.buffer_size - other.buffer_pos + buffer_pos;
+	}
+	idx_t buffer_pos = 0;
+	idx_t buffer_size = 0;
+	idx_t buffer_idx = 0;
+};
+
+class StringValueResult : public ScannerResult {
+public:
+	StringValueResult(CSVStates &states, CSVStateMachine &state_machine,
+	                  const shared_ptr<CSVBufferHandle> &buffer_handle, Allocator &buffer_allocator, idx_t result_size,
+	                  idx_t buffer_position, CSVErrorHandler &error_hander, CSVIterator &iterator, bool store_line_size,
+	                  shared_ptr<CSVFileScan> csv_file_scan, idx_t &lines_read);
+
+	//! Information on the vector
+	unsafe_vector<void *> vector_ptr;
+	unsafe_vector<ValidityMask *> validity_mask;
+
+	//! Variables to iterate over the CSV buffers
+	idx_t last_position;
+	char *buffer_ptr;
+	idx_t buffer_size;
+
+	//! CSV Options that impact the parsing
+	const uint32_t number_of_columns;
+	const bool null_padding;
+	const bool ignore_errors;
+	const char *null_str_ptr;
+	const idx_t null_str_size;
+
+	//! Internal Data Chunk used for flushing
+	DataChunk parse_chunk;
+	idx_t number_of_rows = 0;
+	idx_t cur_col_id = 0;
+	idx_t result_size;
+	//! Information to properly handle errors
+	CSVErrorHandler &error_handler;
+	CSVIterator &iterator;
+	//! Where the previous line started, used to validate the maximum_line_size option
+	LinePosition previous_line_start;
+	LinePosition pre_previous_line_start;
+	bool store_line_size = false;
+	bool added_last_line = false;
+	bool quoted_new_line = false;
+
+	unsafe_unique_array<LogicalTypeId> parse_types;
+	vector<string> names;
+	unordered_map<idx_t, string> cast_errors;
+
+	shared_ptr<CSVFileScan> csv_file_scan;
+	idx_t &lines_read;
+	//! Information regarding projected columns
+	unsafe_unique_array<bool> projected_columns;
+	bool projecting_columns = false;
+	idx_t chunk_col_id = 0;
+
+	//! We must ensure that we keep the buffers alive until processing the query result
+	vector<shared_ptr<CSVBufferHandle>> buffer_handles;
+
+	//! If the current row has an error, we have to skip it
+	bool ignore_current_row = false;
+	//! Specialized code for quoted values, makes sure to remove quotes and escapes
+	static inline void AddQuotedValue(StringValueResult &result, const idx_t buffer_pos);
+	//! Adds a Value to the result
+	static inline void AddValue(StringValueResult &result, const idx_t buffer_pos);
+	//! Adds a Row to the result
+	static inline bool AddRow(StringValueResult &result, const idx_t buffer_pos);
+	//! Behavior when hitting an invalid state
+	static inline void InvalidState(StringValueResult &result);
+	//! Handles QuotedNewline State
+	static inline void QuotedNewLine(StringValueResult &result);
+	void NullPaddingQuotedNewlineCheck();
+	//! Handles EmptyLine states
+	static inline bool EmptyLine(StringValueResult &result, const idx_t buffer_pos);
+	inline bool AddRowInternal();
+
+	void HandleOverLimitRows();
+
+	inline void AddValueToVector(const char *value_ptr, const idx_t size, bool allocate = false);
+
+	Value GetValue(idx_t row_idx, idx_t col_idx);
+
+	DataChunk &ToChunk();
+
+	//! Resets the state of the result
+	void Reset();
+};
+
+//! Our dialect scanner basically goes over the CSV and actually parses the values to a DuckDB vector of string_t
+class StringValueScanner : public BaseScanner {
+public:
+	StringValueScanner(idx_t scanner_idx, const shared_ptr<CSVBufferManager> &buffer_manager,
+	                   const shared_ptr<CSVStateMachine> &state_machine,
+	                   const shared_ptr<CSVErrorHandler> &error_handler, const shared_ptr<CSVFileScan> &csv_file_scan,
+	                   CSVIterator boundary = {}, idx_t result_size = STANDARD_VECTOR_SIZE);
+
+	StringValueScanner(const shared_ptr<CSVBufferManager> &buffer_manager,
+	                   const shared_ptr<CSVStateMachine> &state_machine,
+	                   const shared_ptr<CSVErrorHandler> &error_handler);
+
+	~StringValueScanner() {
+	}
+
+	StringValueResult &ParseChunk() override;
+
+	//! Flushes the result to the insert_chunk
+	void Flush(DataChunk &insert_chunk);
+
+	//! Function that creates and returns a non-boundary CSV Scanner, can be used for internal csv reading.
+	static unique_ptr<StringValueScanner> GetCSVScanner(ClientContext &context, CSVReaderOptions &options);
+
+	bool FinishedIterator();
+
+	//! Creates a new string with all escaped values removed
+	static string_t RemoveEscape(const char *str_ptr, idx_t end, char escape, Vector &vector);
+
+	//! If we can directly cast the type when consuming the CSV file, or we have to do it later
+	static bool CanDirectlyCast(const LogicalType &type,
+	                            const map<LogicalTypeId, CSVOption<StrpTimeFormat>> &format_options);
+
+	const idx_t scanner_idx;
+
+	//! Variable that manages buffer tracking
+	shared_ptr<CSVBufferUsage> buffer_tracker;
+
+private:
+	void Initialize() override;
+
+	void FinalizeChunkProcess() override;
+
+	//! Function used to process values that go over the first buffer, extra allocation might be necessary
+	void ProcessOverbufferValue();
+
+	void ProcessExtraRow();
+	//! Function used to move from one buffer to the other, if necessary
+	bool MoveToNextBuffer();
+
+	//! BOM skipping (https://en.wikipedia.org/wiki/Byte_order_mark)
+	void SkipBOM();
+
+	//! Skips Notes, notes are dirty lines on top of the file, before the actual data
+	void SkipCSVRows();
+
+	void SkipUntilNewLine();
+
+	void SetStart();
+
+	StringValueResult result;
+	vector<LogicalType> types;
+
+	//! Pointer to the previous buffer handle, necessary for overbuffer values
+	shared_ptr<CSVBufferHandle> previous_buffer_handle;
+};
+
+} // namespace duckdb