duckdb 1.1.3 → 1.1.4-dev11.0

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/state_machine/csv_state.hpp

@@ -1,30 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/state_machine/csv_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <cstdint>
-
-namespace duckdb {
-
-//! All States of CSV Parsing
-enum class CSVState : uint8_t {
-	STANDARD = 0,         //! Regular unquoted field state
-	DELIMITER = 1,        //! State after encountering a field separator (e.g., ;)
-	RECORD_SEPARATOR = 2, //! State after encountering a record separator (i.e., \n)
-	CARRIAGE_RETURN = 3,  //! State after encountering a carriage return(i.e., \r)
-	QUOTED = 4,           //! State when inside a quoted field
-	UNQUOTED = 5,         //! State when leaving a quoted field
-	ESCAPE = 6,           //! State when encountering an escape character (e.g., \)
-	INVALID = 7,          //! Got to an Invalid State, this should error.
-	NOT_SET = 8,          //! If the state is not set, usually the first state before getting the first character
-	QUOTED_NEW_LINE = 9,  //! If we have a quoted newline
-	EMPTY_SPACE = 10      //! If we have empty spaces in the beginning and end of value
-};
-
-} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/state_machine/csv_state_machine.hpp

@@ -1,99 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/state_machine/csv_state_machine.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/csv_scanner/options/csv_reader_options.hpp"
-#include "duckdb/execution/operator/csv_scanner/buffer_manager/csv_buffer_manager.hpp"
-#include "duckdb/execution/operator/csv_scanner/state_machine/csv_state_machine_cache.hpp"
-
-namespace duckdb {
-
-//! State of necessary CSV States to parse file
-//! Current, previous, and state before the previous
-struct CSVStates {
-	void Initialize() {
-		states[0] = CSVState::NOT_SET;
-		states[1] = CSVState::NOT_SET;
-	}
-	inline bool NewValue() {
-		return states[1] == CSVState::DELIMITER;
-	}
-
-	inline bool NewRow() {
-		// It is a new row, if the previous state is not a record separator, and the current one is
-		return states[0] != CSVState::RECORD_SEPARATOR && states[0] != CSVState::CARRIAGE_RETURN &&
-		       (states[1] == CSVState::RECORD_SEPARATOR || states[1] == CSVState::CARRIAGE_RETURN);
-	}
-
-	inline bool EmptyLastValue() {
-		// It is a new row, if the previous state is not a record separator, and the current one is
-		return states[0] == CSVState::DELIMITER &&
-		       (states[1] == CSVState::RECORD_SEPARATOR || states[1] == CSVState::CARRIAGE_RETURN);
-	}
-
-	inline bool EmptyLine() {
-		return (states[1] == CSVState::CARRIAGE_RETURN || states[1] == CSVState::RECORD_SEPARATOR) &&
-		       (states[0] == CSVState::RECORD_SEPARATOR || states[0] == CSVState::NOT_SET);
-	}
-
-	inline bool IsNotSet() {
-		return states[1] == CSVState::NOT_SET;
-	}
-
-	inline bool IsCurrentNewRow() {
-		return states[1] == CSVState::RECORD_SEPARATOR || states[1] == CSVState::CARRIAGE_RETURN;
-	}
-
-	inline bool IsCarriageReturn() {
-		return states[1] == CSVState::CARRIAGE_RETURN;
-	}
-
-	inline bool IsQuoted() {
-		return states[0] == CSVState::QUOTED;
-	}
-	inline bool IsEscaped() {
-		return states[1] == CSVState::ESCAPE || (states[0] == CSVState::UNQUOTED && states[1] == CSVState::QUOTED);
-	}
-	inline bool IsQuotedCurrent() {
-		return states[1] == CSVState::QUOTED || states[1] == CSVState::QUOTED_NEW_LINE;
-	}
-	CSVState states[2];
-};
-
-//! The CSV State Machine comprises a state transition array (STA).
-//! The STA indicates the current state of parsing based on both the current and preceding characters.
-//! This reveals whether we are dealing with a Field, a New Line, a Delimiter, and so forth.
-//! The STA's creation depends on the provided quote, character, and delimiter options for that state machine.
-//! The motivation behind implementing an STA is to remove branching in regular CSV Parsing by predicting and detecting
-//! the states. Note: The State Machine is currently utilized solely in the CSV Sniffer.
-class CSVStateMachine {
-public:
-	explicit CSVStateMachine(CSVReaderOptions &options_p, const CSVStateMachineOptions &state_machine_options,
-	                         CSVStateMachineCache &csv_state_machine_cache_p);
-
-	explicit CSVStateMachine(const StateMachine &transition_array, const CSVReaderOptions &options);
-
-	//! Transition all states to next state, that depends on the current char
-	inline void Transition(CSVStates &states, char current_char) const {
-		states.states[0] = states.states[1];
-		states.states[1] = transition_array[static_cast<uint8_t>(current_char)][static_cast<uint8_t>(states.states[1])];
-	}
-
-	//! The Transition Array is a Finite State Machine
-	//! It holds the transitions of all states, on all 256 possible different characters
-	const StateMachine &transition_array;
-	//! Options of this state machine
-	const CSVStateMachineOptions state_machine_options;
-	//! CSV Reader Options
-	const CSVReaderOptions &options;
-	//! Dialect options resulting from sniffing
-	DialectOptions dialect_options;
-};
-
-} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/state_machine/csv_state_machine_cache.hpp

@@ -1,87 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/state_machine/csv_state_machine_cache.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/object_cache.hpp"
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/execution/operator/csv_scanner/options/state_machine_options.hpp"
-#include "duckdb/execution/operator/csv_scanner/sniffer/quote_rules.hpp"
-#include "duckdb/execution/operator/csv_scanner/state_machine/csv_state.hpp"
-
-namespace duckdb {
-
-//! Class to wrap the state machine matrix
-class StateMachine {
-public:
-	static constexpr uint32_t NUM_STATES = 11;
-	static constexpr uint32_t NUM_TRANSITIONS = 256;
-	CSVState state_machine[NUM_TRANSITIONS][NUM_STATES];
-	//! Transitions where we might skip processing
-	//! For the Standard State
-	bool skip_standard[256];
-	//! For the Quoted State
-	bool skip_quoted[256];
-
-	const CSVState *operator[](idx_t i) const {
-		return state_machine[i];
-	}
-
-	CSVState *operator[](idx_t i) {
-		return state_machine[i];
-	}
-};
-
-//! Hash function used in out state machine cache, it hashes and combines all options used to generate a state machine
-struct HashCSVStateMachineConfig {
-	size_t operator()(CSVStateMachineOptions const &config) const noexcept {
-		auto h_delimiter = Hash(config.delimiter.GetValue());
-		auto h_quote = Hash(config.quote.GetValue());
-		auto h_escape = Hash(config.escape.GetValue());
-		auto h_newline = Hash((uint8_t)config.new_line.GetValue());
-		return CombineHash(h_delimiter, CombineHash(h_quote, CombineHash(h_escape, h_newline)));
-	}
-};
-
-//! The CSVStateMachineCache caches state machines, although small ~2kb, the actual creation of multiple State Machines
-//! can become a bottleneck on sniffing, when reading very small csv files.
-//! Hence the cache stores State Machines based on their different delimiter|quote|escape options.
-class CSVStateMachineCache : public ObjectCacheEntry {
-public:
-	CSVStateMachineCache();
-	~CSVStateMachineCache() override = default;
-	//! Gets a state machine from the cache, if it's not from one the default options
-	//! It first caches it, then returns it.
-	static CSVStateMachineCache &Get(ClientContext &context);
-
-	//! Gets a state machine from the cache, if it's not from one the default options
-	//! It first caches it, then returns it.
-	const StateMachine &Get(const CSVStateMachineOptions &state_machine_options);
-
-	static const string STATE_KEY;
-	static string ObjectType() {
-		return "CSV_STATE_MACHINE_CACHE";
-	}
-
-	string GetObjectType() override {
-		return ObjectType();
-	}
-
-private:
-	void Insert(const CSVStateMachineOptions &state_machine_options);
-	//! Cache on delimiter|quote|escape|newline
-	unordered_map<CSVStateMachineOptions, StateMachine, HashCSVStateMachineConfig> state_machine_cache;
-	//! Default value for options used to intialize CSV State Machine Cache
-	const vector<char> default_delimiter = {',', '|', ';', '\t'};
-	const vector<vector<char>> default_quote = {{'\"'}, {'\"', '\''}, {'\0'}};
-	const vector<QuoteRule> default_quote_rule = {QuoteRule::QUOTES_RFC, QuoteRule::QUOTES_OTHER, QuoteRule::NO_QUOTES};
-	const vector<vector<char>> default_escape = {{'\0', '\"', '\''}, {'\\'}, {'\0'}};
-	//! Because the state machine cache can be accessed in Parallel we need a mutex.
-	mutex main_mutex;
-};
-} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/table_function/csv_file_scanner.hpp

@@ -1,70 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/table_function/csv_file_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 {
-struct ReadCSVData;
-//! Struct holding information over a CSV File we will scan
-class CSVFileScan {
-public:
-	//! Constructor for when a CSV File Scan is being constructed over information acquired during sniffing
-	//! This means the options are alreadu set, and the buffer manager is already up and runinng.
-	CSVFileScan(ClientContext &context, shared_ptr<CSVBufferManager> buffer_manager,
-	            shared_ptr<CSVStateMachine> state_machine, const CSVReaderOptions &options,
-	            const ReadCSVData &bind_data, const vector<column_t> &column_ids, vector<LogicalType> &file_schema);
-	//! Constructor for new CSV Files, we must initialize the buffer manager and the state machine
-	//! Path to this file
-	CSVFileScan(ClientContext &context, const string &file_path, const CSVReaderOptions &options, const idx_t file_idx,
-	            const ReadCSVData &bind_data, const vector<column_t> &column_ids,
-	            const vector<LogicalType> &file_schema);
-
-	CSVFileScan(ClientContext &context, const string &file_name, CSVReaderOptions &options);
-
-	const string &GetFileName();
-	const vector<string> &GetNames();
-	const vector<LogicalType> &GetTypes();
-	void InitializeProjection();
-
-	//! Initialize the actual names and types to be scanned from the file
-	void InitializeFileNamesTypes();
-	const string file_path;
-	//! File Index
-	idx_t file_idx;
-	//! Buffer Manager for the CSV File
-	shared_ptr<CSVBufferManager> buffer_manager;
-	//! State Machine for this file
-	shared_ptr<CSVStateMachine> state_machine;
-	//! How many bytes were read up to this point
-	atomic<idx_t> bytes_read {0};
-	//! Size of this file
-	idx_t file_size;
-	//! Line Info used in error messages
-	shared_ptr<CSVErrorHandler> error_handler;
-	//! Whether or not this is an on-disk file
-	bool on_disk_file = true;
-
-	vector<string> names;
-	vector<LogicalType> types;
-	MultiFileReaderData reader_data;
-
-	vector<LogicalType> file_types;
-
-	//! Variables to handle projection pushdown
-	set<idx_t> projected_columns;
-	std::vector<std::pair<idx_t, idx_t>> projection_ids;
-
-	//! Options for this CSV Reader
-	CSVReaderOptions options;
-};
-} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/table_function/global_csv_state.hpp

@@ -1,80 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/table_function/global_csv_state.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"
-#include "duckdb/function/table/read_csv.hpp"
-#include "duckdb/execution/operator/csv_scanner/table_function/csv_file_scanner.hpp"
-#include "duckdb/execution/operator/csv_scanner/scanner/string_value_scanner.hpp"
-
-namespace duckdb {
-
-//! CSV Global State is used in the CSV Reader Table Function, it controls what each thread
-struct CSVGlobalState : public GlobalTableFunctionState {
-public:
-	CSVGlobalState(ClientContext &context, const shared_ptr<CSVBufferManager> &buffer_manager_p,
-	               const CSVReaderOptions &options, idx_t system_threads_p, const vector<string> &files,
-	               vector<column_t> column_ids_p, const ReadCSVData &bind_data);
-
-	~CSVGlobalState() override {
-	}
-
-	//! Generates a CSV Scanner, with information regarding the piece of buffer it should be read.
-	//! In case it returns a nullptr it means we are done reading these files.
-	unique_ptr<StringValueScanner> Next();
-
-	void FillRejectsTable();
-
-	void DecrementThread();
-
-	//! Returns Current Progress of this CSV Read
-	double GetProgress(const ReadCSVData &bind_data) const;
-
-	//! Calculates the Max Threads that will be used by this CSV Reader
-	idx_t MaxThreads() const override;
-	//! We hold information on the current scanner boundary
-	CSVIterator current_boundary;
-
-private:
-	//! Reference to the client context that created this scan
-	ClientContext &context;
-
-	vector<shared_ptr<CSVFileScan>> file_scans;
-
-	//! Mutex to lock when getting next batch of bytes (Parallel Only)
-	mutex main_mutex;
-
-	//! Basically max number of threads in DuckDB
-	idx_t system_threads;
-
-	//! Number of threads being used in this scanner
-	idx_t running_threads = 1;
-	//! The column ids to read
-	vector<column_t> column_ids;
-
-	string sniffer_mismatch_error;
-
-	bool finished = false;
-
-	const ReadCSVData &bind_data;
-
-	vector<LogicalType> file_schema;
-
-	bool single_threaded = false;
-
-	atomic<idx_t> scanner_idx;
-
-	atomic<idx_t> last_file_idx;
-	shared_ptr<CSVBufferUsage> current_buffer_in_use;
-};
-
-} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/util/csv_casting.hpp

@@ -1,137 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/util/csv_casting.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/csv_scanner/options/csv_reader_options.hpp"
-#include "duckdb/common/vector_operations/unary_executor.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/operator/decimal_cast_operators.hpp"
-
-namespace duckdb {
-class CSVCast {
-	template <class OP, class T>
-	static bool TemplatedTryCastFloatingVector(const CSVReaderOptions &options, Vector &input_vector,
-	                                           Vector &result_vector, idx_t count, string &error_message,
-	                                           idx_t &line_error) {
-		D_ASSERT(input_vector.GetType().id() == LogicalTypeId::VARCHAR);
-		bool all_converted = true;
-		idx_t row = 0;
-		UnaryExecutor::Execute<string_t, T>(input_vector, result_vector, count, [&](string_t input) {
-			T result;
-			if (!OP::Operation(input, result, &error_message)) {
-				line_error = row;
-				all_converted = false;
-			} else {
-				row++;
-			}
-			return result;
-		});
-		return all_converted;
-	}
-
-	template <class OP, class T>
-	static bool TemplatedTryCastDecimalVector(const CSVReaderOptions &options, Vector &input_vector,
-	                                          Vector &result_vector, idx_t count, string &error_message, uint8_t width,
-	                                          uint8_t scale) {
-		D_ASSERT(input_vector.GetType().id() == LogicalTypeId::VARCHAR);
-		bool all_converted = true;
-		UnaryExecutor::Execute<string_t, T>(input_vector, result_vector, count, [&](string_t input) {
-			T result;
-			if (!OP::Operation(input, result, &error_message, width, scale)) {
-				all_converted = false;
-			}
-			return result;
-		});
-		return all_converted;
-	}
-
-	struct TryCastDateOperator {
-		static bool Operation(const map<LogicalTypeId, CSVOption<StrpTimeFormat>> &options, string_t input,
-		                      date_t &result, string &error_message) {
-			return options.at(LogicalTypeId::DATE).GetValue().TryParseDate(input, result, error_message);
-		}
-	};
-
-	struct TryCastTimestampOperator {
-		static bool Operation(const map<LogicalTypeId, CSVOption<StrpTimeFormat>> &options, string_t input,
-		                      timestamp_t &result, string &error_message) {
-			return options.at(LogicalTypeId::TIMESTAMP).GetValue().TryParseTimestamp(input, result, error_message);
-		}
-	};
-
-	template <class OP, class T>
-	static bool TemplatedTryCastDateVector(const map<LogicalTypeId, CSVOption<StrpTimeFormat>> &options,
-	                                       Vector &input_vector, Vector &result_vector, idx_t count,
-	                                       string &error_message, idx_t &line_error) {
-		D_ASSERT(input_vector.GetType().id() == LogicalTypeId::VARCHAR);
-		bool all_converted = true;
-		idx_t cur_line = 0;
-		UnaryExecutor::Execute<string_t, T>(input_vector, result_vector, count, [&](string_t input) {
-			T result;
-			if (!OP::Operation(options, input, result, error_message)) {
-				line_error = cur_line;
-				all_converted = false;
-			}
-			cur_line++;
-			return result;
-		});
-		return all_converted;
-	}
-
-public:
-	static bool TryCastDateVector(const map<LogicalTypeId, CSVOption<StrpTimeFormat>> &options, Vector &input_vector,
-	                              Vector &result_vector, idx_t count, string &error_message, idx_t &line_error) {
-		return TemplatedTryCastDateVector<TryCastDateOperator, date_t>(options, input_vector, result_vector, count,
-		                                                               error_message, line_error);
-	}
-	static bool TryCastTimestampVector(const map<LogicalTypeId, CSVOption<StrpTimeFormat>> &options,
-	                                   Vector &input_vector, Vector &result_vector, idx_t count,
-	                                   string &error_message) {
-		idx_t line_error;
-		return TemplatedTryCastDateVector<TryCastTimestampOperator, timestamp_t>(options, input_vector, result_vector,
-		                                                                         count, error_message, line_error);
-	}
-	static bool TryCastFloatingVectorCommaSeparated(const CSVReaderOptions &options, Vector &input_vector,
-	                                                Vector &result_vector, idx_t count, string &error_message,
-	                                                const LogicalType &result_type, idx_t &line_error) {
-		switch (result_type.InternalType()) {
-		case PhysicalType::DOUBLE:
-			return TemplatedTryCastFloatingVector<TryCastErrorMessageCommaSeparated, double>(
-			    options, input_vector, result_vector, count, error_message, line_error);
-		case PhysicalType::FLOAT:
-			return TemplatedTryCastFloatingVector<TryCastErrorMessageCommaSeparated, float>(
-			    options, input_vector, result_vector, count, error_message, line_error);
-		default:
-			throw InternalException("Unimplemented physical type for floating");
-		}
-	}
-	static bool TryCastDecimalVectorCommaSeparated(const CSVReaderOptions &options, Vector &input_vector,
-	                                               Vector &result_vector, idx_t count, string &error_message,
-	                                               const LogicalType &result_type) {
-		auto width = DecimalType::GetWidth(result_type);
-		auto scale = DecimalType::GetScale(result_type);
-		switch (result_type.InternalType()) {
-		case PhysicalType::INT16:
-			return TemplatedTryCastDecimalVector<TryCastToDecimalCommaSeparated, int16_t>(
-			    options, input_vector, result_vector, count, error_message, width, scale);
-		case PhysicalType::INT32:
-			return TemplatedTryCastDecimalVector<TryCastToDecimalCommaSeparated, int32_t>(
-			    options, input_vector, result_vector, count, error_message, width, scale);
-		case PhysicalType::INT64:
-			return TemplatedTryCastDecimalVector<TryCastToDecimalCommaSeparated, int64_t>(
-			    options, input_vector, result_vector, count, error_message, width, scale);
-		case PhysicalType::INT128:
-			return TemplatedTryCastDecimalVector<TryCastToDecimalCommaSeparated, hugeint_t>(
-			    options, input_vector, result_vector, count, error_message, width, scale);
-		default:
-			throw InternalException("Unimplemented physical type for decimal");
-		}
-	}
-};
-} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/util/csv_error.hpp

@@ -1,104 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/csv_scanner/util/csv_error.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/typedefs.hpp"
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/types/string_type.hpp"
-#include "duckdb/execution/operator/csv_scanner/options/csv_reader_options.hpp"
-
-namespace duckdb {
-
-//! Object that holds information on how many lines each csv batch read.
-
-class LinesPerBoundary {
-public:
-	LinesPerBoundary();
-	LinesPerBoundary(idx_t boundary_idx, idx_t lines_in_batch);
-
-	idx_t boundary_idx = 0;
-	idx_t lines_in_batch = 0;
-};
-
-enum CSVErrorType : uint8_t {
-	CAST_ERROR = 0,                // If when casting a value from string to the column type fails
-	COLUMN_NAME_TYPE_MISMATCH = 1, // If there is a mismatch between Column Names and Types
-	INCORRECT_COLUMN_AMOUNT = 2,   // If the CSV is missing a column
-	UNTERMINATED_QUOTES = 3,       // If a quote is not terminated
-	SNIFFING = 4,          // If something went wrong during sniffing and was not possible to find suitable candidates
-	MAXIMUM_LINE_SIZE = 5, // Maximum line size was exceeded by a line in the CSV File
-	NULLPADDED_QUOTED_NEW_VALUE = 6, // If the null_padding option is set and we have quoted new values in parallel
-
-};
-
-class CSVError {
-public:
-	CSVError(string error_message, CSVErrorType type, idx_t column_idx, vector<Value> row);
-	CSVError(string error_message, CSVErrorType type);
-	//! Produces error messages for column name -> type mismatch.
-	static CSVError ColumnTypesError(case_insensitive_map_t<idx_t> sql_types_per_column, const vector<string> &names);
-	//! Produces error messages for casting errors
-	static CSVError CastError(const CSVReaderOptions &options, string &column_name, string &cast_error,
-	                          idx_t column_idx, vector<Value> &row);
-	//! Produces error for when the line size exceeds the maximum line size option
-	static CSVError LineSizeError(const CSVReaderOptions &options, idx_t actual_size);
-	//! Produces error for when the sniffer couldn't find viable options
-	static CSVError SniffingError(string &file_path);
-	//! Produces error messages for unterminated quoted values
-	static CSVError UnterminatedQuotesError(const CSVReaderOptions &options, string_t *vector_ptr,
-	                                        idx_t vector_line_start, idx_t current_column);
-	//! Produces error messages for null_padding option is set and we have quoted new values in parallel
-	static CSVError NullPaddingFail(const CSVReaderOptions &options);
-	//! Produces error for incorrect (e.g., smaller and lower than the predefined) number of columns in a CSV Line
-	static CSVError IncorrectColumnAmountError(const CSVReaderOptions &options, string_t *vector_ptr,
-	                                           idx_t vector_line_start, idx_t actual_columns);
-	//! Actual error message
-	string error_message;
-	//! Error Type
-	CSVErrorType type;
-	//! Column Index where error happened
-	idx_t column_idx;
-	//! Values from the row where error happened
-	vector<Value> row;
-};
-
-class CSVErrorHandler {
-public:
-	CSVErrorHandler(bool ignore_errors = false);
-	//! Throws the error
-	void Error(LinesPerBoundary &error_info, CSVError &csv_error, bool force_error = false);
-	//! Throws the error
-	void Error(CSVError &csv_error);
-	//! Inserts a finished error info
-	void Insert(idx_t boundary_idx, idx_t rows);
-	vector<pair<LinesPerBoundary, CSVError>> errors;
-	//! Return the 1-indexed line number
-	idx_t GetLine(LinesPerBoundary &error_info);
-	void NewMaxLineSize(idx_t scan_line_size);
-	idx_t GetMaxLineLength() {
-		return max_line_length;
-	}
-
-private:
-	//! If we should print the line of an error
-	bool PrintLineNumber(CSVError &error);
-	//! CSV Error Handler Mutex
-	mutex main_mutex;
-	//! Map of <file,batch> -> lines
-	unordered_map<idx_t, LinesPerBoundary> lines_per_batch_map;
-	idx_t max_line_length = 0;
-	bool ignore_errors = false;
-
-	bool got_borked = false;
-};
-
-} // namespace duckdb