duckdb 1.1.2-dev6.0 → 1.1.4-dev11.0

package/src/duckdb/src/include/duckdb/execution/operator/scan/csv/csv_reader_options.hpp

@@ -1,210 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/scan/csv/csv_reader_options.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/scan/csv/csv_buffer.hpp"
-#include "duckdb/common/map.hpp"
-#include "duckdb/function/scalar/strftime_format.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/types.hpp"
-#include "duckdb/common/multi_file_reader_options.hpp"
-
-namespace duckdb {
-
-enum class NewLineIdentifier : uint8_t {
-	SINGLE = 1,   // Either \r or \n
-	CARRY_ON = 2, // \r\n
-	MIX = 3,      // Hippie-Land, can't run it multithreaded
-	NOT_SET = 4
-};
-
-enum class ParallelMode { AUTOMATIC = 0, PARALLEL = 1, SINGLE_THREADED = 2 };
-
-//! Struct that holds the configuration of a CSV State Machine
-//! Basically which char, quote and escape were used to generate it.
-struct CSVStateMachineOptions {
-	CSVStateMachineOptions() {};
-	CSVStateMachineOptions(char delimiter_p, char quote_p, char escape_p)
-	    : delimiter(delimiter_p), quote(quote_p), escape(escape_p) {};
-
-	//! Delimiter to separate columns within each line
-	char delimiter = ',';
-	//! Quote used for columns that contain reserved characters, e.g '
-	char quote = '\"';
-	//! Escape character to escape quote character
-	char escape = '\0';
-
-	bool operator==(const CSVStateMachineOptions &other) const {
-		return delimiter == other.delimiter && quote == other.quote && escape == other.escape;
-	}
-};
-
-struct DialectOptions {
-	CSVStateMachineOptions state_machine_options;
-	//! New Line separator
-	NewLineIdentifier new_line = NewLineIdentifier::NOT_SET;
-	//! Expected number of columns
-	idx_t num_cols = 0;
-	//! Whether or not the file has a header line
-	bool header = false;
-	//! The date format to use (if any is specified)
-	map<LogicalTypeId, StrpTimeFormat> date_format = {{LogicalTypeId::DATE, {}}, {LogicalTypeId::TIMESTAMP, {}}};
-	//! Whether or not a type format is specified
-	map<LogicalTypeId, bool> has_format = {{LogicalTypeId::DATE, false}, {LogicalTypeId::TIMESTAMP, false}};
-	//! How many leading rows to skip
-	idx_t skip_rows = 0;
-	//! True start of the first CSV Buffer (After skipping empty lines, headers, notes and so on)
-	idx_t true_start = 0;
-};
-
-struct CSVReaderOptions {
-	//===--------------------------------------------------------------------===//
-	// CommonCSVOptions
-	//===--------------------------------------------------------------------===//
-	//! See struct above.
-	DialectOptions dialect_options;
-	//! Whether or not a delimiter was defined by the user
-	bool has_delimiter = false;
-	//! Whether or not a new_line was defined by the user
-	bool has_newline = false;
-	//! Whether or not a quote was defined by the user
-	bool has_quote = false;
-	//! Whether or not an escape character was defined by the user
-	bool has_escape = false;
-	//! Whether or not a header information was given by the user
-	bool has_header = false;
-	//! Whether or not we should ignore InvalidInput errors
-	bool ignore_errors = false;
-	//! Rejects table name
-	string rejects_table_name;
-	//! Rejects table entry limit (0 = no limit)
-	idx_t rejects_limit = 0;
-	//! Columns to use as recovery key for rejected rows when reading with ignore_errors = true
-	vector<string> rejects_recovery_columns;
-	//! Index of the recovery columns
-	vector<idx_t> rejects_recovery_column_ids;
-	//! Number of samples to buffer
-	idx_t buffer_sample_size = STANDARD_VECTOR_SIZE * 50;
-	//! Specifies the string that represents a null value
-	string null_str;
-	//! Whether file is compressed or not, and if so which compression type
-	//! AUTO_DETECT (default; infer from file extension)
-	FileCompressionType compression = FileCompressionType::AUTO_DETECT;
-	//! Option to convert quoted values to NULL values
-	bool allow_quoted_nulls = true;
-
-	//===--------------------------------------------------------------------===//
-	// CSVAutoOptions
-	//===--------------------------------------------------------------------===//
-	//! SQL Type list mapping of name to SQL type index in sql_type_list
-	case_insensitive_map_t<idx_t> sql_types_per_column;
-	//! User-defined SQL type list
-	vector<LogicalType> sql_type_list;
-	//! User-defined name list
-	vector<string> name_list;
-	//! Types considered as candidates for auto detection ordered by descending specificity (~ from high to low)
-	vector<LogicalType> auto_type_candidates = {LogicalType::VARCHAR, LogicalType::TIMESTAMP, LogicalType::DATE,
-	                                            LogicalType::TIME,    LogicalType::DOUBLE,    LogicalType::BIGINT,
-	                                            LogicalType::BOOLEAN, LogicalType::SQLNULL};
-
-	//===--------------------------------------------------------------------===//
-	// ReadCSVOptions
-	//===--------------------------------------------------------------------===//
-	//! Whether or not the skip_rows is set by the user
-	bool skip_rows_set = false;
-	//! Maximum CSV line size: specified because if we reach this amount, we likely have wrong delimiters (default: 2MB)
-	//! note that this is the guaranteed line length that will succeed, longer lines may be accepted if slightly above
-	idx_t maximum_line_size = 2097152;
-	//! Whether or not header names shall be normalized
-	bool normalize_names = false;
-	//! True, if column with that index must skip null check
-	vector<bool> force_not_null;
-	//! Number of sample chunks used in auto-detection
-	idx_t sample_size_chunks = 20480 / STANDARD_VECTOR_SIZE;
-	//! Consider all columns to be of type varchar
-	bool all_varchar = false;
-	//! Whether or not to automatically detect dialect and datatypes
-	bool auto_detect = false;
-	//! The file path of the CSV file to read
-	string file_path;
-	//! Multi-file reader options
-	MultiFileReaderOptions file_options;
-	//! Buffer Size (Parallel Scan)
-	idx_t buffer_size = CSVBuffer::CSV_BUFFER_SIZE;
-	//! Decimal separator when reading as numeric
-	string decimal_separator = ".";
-	//! Whether or not to pad rows that do not have enough columns with NULL values
-	bool null_padding = false;
-
-	//! If we are running the parallel version of the CSV Reader. In general, the system should always auto-detect
-	//! When it can't execute a parallel run before execution. However, there are (rather specific) situations where
-	//! setting up this manually might be important
-	ParallelMode parallel_mode;
-	//===--------------------------------------------------------------------===//
-	// WriteCSVOptions
-	//===--------------------------------------------------------------------===//
-	//! True, if column with that index must be quoted
-	vector<bool> force_quote;
-	//! Prefix/suffix/custom newline the entire file once (enables writing of files as JSON arrays)
-	string prefix;
-	string suffix;
-	string write_newline;
-
-	//! The date format to use (if any is specified)
-	map<LogicalTypeId, StrpTimeFormat> date_format = {{LogicalTypeId::DATE, {}}, {LogicalTypeId::TIMESTAMP, {}}};
-	//! The date format to use for writing (if any is specified)
-	map<LogicalTypeId, StrfTimeFormat> write_date_format = {{LogicalTypeId::DATE, {}}, {LogicalTypeId::TIMESTAMP, {}}};
-	//! Whether or not a type format is specified
-	map<LogicalTypeId, bool> has_format = {{LogicalTypeId::DATE, false}, {LogicalTypeId::TIMESTAMP, false}};
-
-	void Serialize(Serializer &serializer) const;
-	static CSVReaderOptions Deserialize(Deserializer &deserializer);
-
-	void SetCompression(const string &compression);
-
-	bool GetHeader() const;
-	void SetHeader(bool has_header);
-
-	string GetEscape() const;
-	void SetEscape(const string &escape);
-
-	int64_t GetSkipRows() const;
-	void SetSkipRows(int64_t rows);
-
-	string GetQuote() const;
-	void SetQuote(const string &quote);
-	void SetDelimiter(const string &delimiter);
-	string GetDelimiter() const;
-
-	NewLineIdentifier GetNewline() const;
-	void SetNewline(const string &input);
-	//! Set an option that is supported by both reading and writing functions, called by
-	//! the SetReadOption and SetWriteOption methods
-	bool SetBaseOption(const string &loption, const Value &value);
-
-	//! loption - lowercase string
-	//! set - argument(s) to the option
-	//! expected_names - names expected if the option is "columns"
-	void SetReadOption(const string &loption, const Value &value, vector<string> &expected_names);
-	void SetWriteOption(const string &loption, const Value &value);
-	void SetDateFormat(LogicalTypeId type, const string &format, bool read_format);
-	void ToNamedParameters(named_parameter_map_t &out);
-	void FromNamedParameters(named_parameter_map_t &in, ClientContext &context, vector<LogicalType> &return_types,
-	                         vector<string> &names);
-
-	string ToString() const;
-
-	named_parameter_map_t OutputReadSettings();
-
-public:
-	//! Whether columns were explicitly provided through named parameters
-	bool explicitly_set_columns = false;
-};
-} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/scan/csv/csv_sniffer.hpp

@@ -1,131 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/scan/csv/csv_sniffer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/scan/csv/csv_state_machine.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/execution/operator/scan/csv/quote_rules.hpp"
-
-namespace duckdb {
-//! Struct to store the result of the Sniffer
-struct SnifferResult {
-	SnifferResult(vector<LogicalType> return_types_p, vector<string> names_p)
-	    : return_types(std::move(return_types_p)), names(std::move(names_p)) {
-	}
-	//! Return Types that were detected
-	vector<LogicalType> return_types;
-	//! Column Names that were detected
-	vector<string> names;
-};
-
-//! Sniffer that detects Header, Dialect and Types of CSV Files
-class CSVSniffer {
-public:
-	explicit CSVSniffer(CSVReaderOptions &options_p, shared_ptr<CSVBufferManager> buffer_manager_p,
-	                    CSVStateMachineCache &state_machine_cache, bool explicit_set_columns = false);
-
-	//! Main method that sniffs the CSV file, returns the types, names and options as a result
-	//! CSV Sniffing consists of five steps:
-	//! 1. Dialect Detection: Generate the CSV Options (delimiter, quote, escape, etc.)
-	//! 2. Type Detection: Figures out the types of the columns (For one chunk)
-	//! 3. Type Refinement: Refines the types of the columns for the remaining chunks
-	//! 4. Header Detection: Figures out if  the CSV file has a header and produces the names of the columns
-	//! 5. Type Replacement: Replaces the types of the columns if the user specified them
-	SnifferResult SniffCSV();
-
-private:
-	//! CSV State Machine Cache
-	CSVStateMachineCache &state_machine_cache;
-	//! Highest number of columns found
-	idx_t max_columns_found = 0;
-	//! Current Candidates being considered
-	vector<unique_ptr<CSVStateMachine>> candidates;
-	//! Reference to original CSV Options, it will be modified as a result of the sniffer.
-	CSVReaderOptions &options;
-	//! Buffer being used on sniffer
-	shared_ptr<CSVBufferManager> buffer_manager;
-	//! Sets the result options
-	void SetResultOptions();
-
-	//! ------------------------------------------------------//
-	//! ----------------- Dialect Detection ----------------- //
-	//! ------------------------------------------------------//
-	//! First phase of auto detection: detect CSV dialect (i.e. delimiter, quote rules, etc)
-	void DetectDialect();
-	//! Functions called in the main DetectDialect(); function
-	//! 1. Generates the search space candidates for the dialect
-	void GenerateCandidateDetectionSearchSpace(vector<char> &delim_candidates, vector<QuoteRule> &quoterule_candidates,
-	                                           unordered_map<uint8_t, vector<char>> &quote_candidates_map,
-	                                           unordered_map<uint8_t, vector<char>> &escape_candidates_map);
-	//! 2. Generates the search space candidates for the state machines
-	void GenerateStateMachineSearchSpace(vector<unique_ptr<CSVStateMachine>> &csv_state_machines,
-	                                     const vector<char> &delimiter_candidates,
-	                                     const vector<QuoteRule> &quoterule_candidates,
-	                                     const unordered_map<uint8_t, vector<char>> &quote_candidates_map,
-	                                     const unordered_map<uint8_t, vector<char>> &escape_candidates_map);
-	//! 3. Analyzes if dialect candidate is a good candidate to be considered, if so, it adds it to the candidates
-	void AnalyzeDialectCandidate(unique_ptr<CSVStateMachine>, idx_t &rows_read, idx_t &best_consistent_rows,
-	                             idx_t &prev_padding_count);
-	//! 4. Refine Candidates over remaining chunks
-	void RefineCandidates();
-	//! Checks if candidate still produces good values for the next chunk
-	bool RefineCandidateNextChunk(CSVStateMachine &candidate);
-
-	//! ------------------------------------------------------//
-	//! ------------------- Type Detection ------------------ //
-	//! ------------------------------------------------------//
-	//! Second phase of auto detection: detect types, format template candidates
-	//! ordered by descending specificity (~ from high to low)
-	void DetectTypes();
-	//! Change the date format for the type to the string
-	//! Try to cast a string value to the specified sql type
-	bool TryCastValue(CSVStateMachine &candidate, const Value &value, const LogicalType &sql_type);
-	void SetDateFormat(CSVStateMachine &candidate, const string &format_specifier, const LogicalTypeId &sql_type);
-	//! Functions that performs detection for date and timestamp formats
-	void DetectDateAndTimeStampFormats(CSVStateMachine &candidate, map<LogicalTypeId, bool> &has_format_candidates,
-	                                   map<LogicalTypeId, vector<string>> &format_candidates,
-	                                   const LogicalType &sql_type, const string &separator, Value &dummy_val);
-
-	//! Variables for Type Detection
-	//! Format Candidates for Date and Timestamp Types
-	const map<LogicalTypeId, vector<const char *>> format_template_candidates = {
-	    {LogicalTypeId::DATE, {"%m-%d-%Y", "%m-%d-%y", "%d-%m-%Y", "%d-%m-%y", "%Y-%m-%d", "%y-%m-%d"}},
-	    {LogicalTypeId::TIMESTAMP,
-	     {"%Y-%m-%d %H:%M:%S.%f", "%m-%d-%Y %I:%M:%S %p", "%m-%d-%y %I:%M:%S %p", "%d-%m-%Y %H:%M:%S",
-	      "%d-%m-%y %H:%M:%S", "%Y-%m-%d %H:%M:%S", "%y-%m-%d %H:%M:%S"}},
-	};
-	unordered_map<idx_t, vector<LogicalType>> best_sql_types_candidates_per_column_idx;
-	map<LogicalTypeId, vector<string>> best_format_candidates;
-	unique_ptr<CSVStateMachine> best_candidate;
-	idx_t best_start_with_header = 0;
-	idx_t best_start_without_header = 0;
-	vector<Value> best_header_row;
-
-	//! ------------------------------------------------------//
-	//! ------------------ Type Refinement ------------------ //
-	//! ------------------------------------------------------//
-	void RefineTypes();
-	bool TryCastVector(Vector &parse_chunk_col, idx_t size, const LogicalType &sql_type);
-	vector<LogicalType> detected_types;
-
-	//! ------------------------------------------------------//
-	//! ------------------ Header Detection ----------------- //
-	//! ------------------------------------------------------//
-	void DetectHeader();
-	vector<string> names;
-	//! If Column Names and Types have been explicitly set
-	const bool explicit_set_columns;
-
-	//! ------------------------------------------------------//
-	//! ------------------ Type Replacement ----------------- //
-	//! ------------------------------------------------------//
-	void ReplaceTypes();
-};
-
-} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/scan/csv/csv_state.hpp

@@ -1,28 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/scan/csv/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., \)
-	EMPTY_LINE = 7,       //! State when encountering an empty line (i.e., \r\r \n\n, \n\r)
-	INVALID = 8           //! Got to an Invalid State, this should error.
-};
-
-} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/scan/csv/csv_state_machine.hpp

@@ -1,70 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/scan/csv/csv_state_machine.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/scan/csv/csv_reader_options.hpp"
-#include "duckdb/execution/operator/scan/csv/csv_buffer_manager.hpp"
-#include "duckdb/execution/operator/scan/csv/csv_state_machine_cache.hpp"
-
-namespace duckdb {
-
-//! 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,
-	                         shared_ptr<CSVBufferManager> buffer_manager_p,
-	                         CSVStateMachineCache &csv_state_machine_cache_p);
-
-	//! Transition all states to next state, that depends on the current char
-	inline void Transition(char current_char) {
-		pre_previous_state = previous_state;
-		previous_state = state;
-		state = transition_array[state][static_cast<uint8_t>(current_char)];
-	}
-
-	//! Resets the state machine, so it can be used again
-	void Reset();
-
-	//! Aux Function for string UTF8 Verification
-	void VerifyUTF8();
-
-	CSVStateMachineCache &csv_state_machine_cache;
-
-	const CSVReaderOptions &options;
-	CSVBufferIterator csv_buffer_iterator;
-	//! Stores identified start row for this file (e.g., a file can start with garbage like notes, before the header)
-	idx_t start_row = 0;
-	//! 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;
-
-	//! Both these variables are used for new line identifier detection
-	bool single_record_separator = false;
-	bool carry_on_separator = false;
-
-	//! Variables Used for Sniffing
-	CSVState state;
-	CSVState previous_state;
-	CSVState pre_previous_state;
-	idx_t cur_rows;
-	idx_t column_count;
-	string value;
-	idx_t rows_read;
-	idx_t line_start_pos = 0;
-
-	//! Dialect options resulting from sniffing
-	DialectOptions dialect_options;
-};
-
-} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/scan/csv/csv_state_machine_cache.hpp

@@ -1,65 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/scan/csv/csv_state_machine_cache.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/scan/csv/csv_state.hpp"
-#include "duckdb/execution/operator/scan/csv/csv_buffer_manager.hpp"
-#include "duckdb/execution/operator/scan/csv/csv_reader_options.hpp"
-#include "duckdb/execution/operator/scan/csv/quote_rules.hpp"
-
-namespace duckdb {
-
-//! Class to wrap the state machine matrix
-class StateMachine {
-public:
-	static constexpr uint32_t NUM_STATES = 9;
-	static constexpr uint32_t NUM_TRANSITIONS = 256;
-	CSVState state_machine[NUM_STATES][NUM_TRANSITIONS];
-
-	const CSVState *operator[](CSVState state) const {
-		return state_machine[static_cast<uint8_t>(state)];
-	}
-
-	CSVState *operator[](CSVState state) {
-		return state_machine[static_cast<uint8_t>(state)];
-	}
-};
-
-//! 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);
-		auto h_quote = Hash(config.quote);
-		auto h_escape = Hash(config.escape);
-		return CombineHash(h_delimiter, CombineHash(h_quote, h_escape));
-	}
-};
-
-//! 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:
-	CSVStateMachineCache();
-	~CSVStateMachineCache() {};
-	//! 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);
-
-private:
-	void Insert(const CSVStateMachineOptions &state_machine_options);
-	//! Cache on delimiter|quote|escape
-	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'}};
-};
-} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/scan/csv/parallel_csv_reader.hpp

@@ -1,167 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/scan/csv/parallel_csv_reader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/scan/csv/base_csv_reader.hpp"
-#include "duckdb/execution/operator/scan/csv/csv_reader_options.hpp"
-#include "duckdb/execution/operator/scan/csv/csv_file_handle.hpp"
-#include "duckdb/execution/operator/scan/csv/csv_buffer.hpp"
-#include "duckdb/execution/operator/scan/csv/csv_line_info.hpp"
-
-#include <sstream>
-#include <utility>
-
-namespace duckdb {
-
-struct CSVBufferRead {
-	CSVBufferRead(unique_ptr<CSVBufferHandle> buffer_p, idx_t buffer_start_p, idx_t buffer_end_p, idx_t batch_index,
-	              idx_t local_batch_index_p, optional_ptr<LineInfo> line_info_p)
-	    : buffer(std::move(buffer_p)), line_info(line_info_p), buffer_start(buffer_start_p), buffer_end(buffer_end_p),
-	      batch_index(batch_index), local_batch_index(local_batch_index_p) {
-		D_ASSERT(buffer);
-		if (buffer_end > buffer->actual_size) {
-			buffer_end = buffer->actual_size;
-		}
-	}
-
-	CSVBufferRead(unique_ptr<CSVBufferHandle> buffer_p, unique_ptr<CSVBufferHandle> nxt_buffer_p, idx_t buffer_start_p,
-	              idx_t buffer_end_p, idx_t batch_index, idx_t local_batch_index, optional_ptr<LineInfo> line_info_p)
-	    : CSVBufferRead(std::move(buffer_p), buffer_start_p, buffer_end_p, batch_index, local_batch_index,
-	                    line_info_p) {
-		next_buffer = std::move(nxt_buffer_p);
-	}
-
-	CSVBufferRead() : buffer_start(0), buffer_end(NumericLimits<idx_t>::Maximum()) {};
-
-	const char &operator[](size_t i) const {
-		if (i < buffer->actual_size) {
-			auto buffer_ptr = buffer->Ptr();
-			return buffer_ptr[i];
-		}
-		auto next_ptr = next_buffer->Ptr();
-		return next_ptr[i - buffer->actual_size];
-	}
-
-	string_t GetValue(idx_t start_buffer, idx_t position_buffer, idx_t offset) {
-		idx_t length = position_buffer - start_buffer - offset;
-		// 1) It's all in the current buffer
-		if (start_buffer + length <= buffer->actual_size) {
-			auto buffer_ptr = buffer->Ptr();
-			return string_t(buffer_ptr + start_buffer, length);
-		} else if (start_buffer >= buffer->actual_size) {
-			// 2) It's all in the next buffer
-			D_ASSERT(next_buffer);
-			D_ASSERT(next_buffer->actual_size >= length + (start_buffer - buffer->actual_size));
-			auto buffer_ptr = next_buffer->Ptr();
-			return string_t(buffer_ptr + (start_buffer - buffer->actual_size), length);
-		} else {
-			// 3) It starts in the current buffer and ends in the next buffer
-			D_ASSERT(next_buffer);
-			auto intersection = make_unsafe_uniq_array<char>(length);
-			idx_t cur_pos = 0;
-			auto buffer_ptr = buffer->Ptr();
-			for (idx_t i = start_buffer; i < buffer->actual_size; i++) {
-				intersection[cur_pos++] = buffer_ptr[i];
-			}
-			idx_t nxt_buffer_pos = 0;
-			auto next_buffer_ptr = next_buffer->Ptr();
-			for (; cur_pos < length; cur_pos++) {
-				intersection[cur_pos] = next_buffer_ptr[nxt_buffer_pos++];
-			}
-			intersections.emplace_back(std::move(intersection));
-			return string_t(intersections.back().get(), length);
-		}
-	}
-
-	unique_ptr<CSVBufferHandle> buffer;
-	unique_ptr<CSVBufferHandle> next_buffer;
-	vector<unsafe_unique_array<char>> intersections;
-	optional_ptr<LineInfo> line_info;
-
-	idx_t buffer_start;
-	idx_t buffer_end;
-	idx_t batch_index;
-	idx_t local_batch_index;
-	idx_t lines_read = 0;
-};
-
-struct VerificationPositions {
-	idx_t beginning_of_first_line = 0;
-	idx_t end_of_last_line = 0;
-};
-
-//! CSV Reader for Parallel Reading
-class ParallelCSVReader : public BaseCSVReader {
-public:
-	ParallelCSVReader(ClientContext &context, CSVReaderOptions options, unique_ptr<CSVBufferRead> buffer,
-	                  idx_t first_pos_first_buffer, const vector<LogicalType> &requested_types, idx_t file_idx_p);
-	virtual ~ParallelCSVReader() {
-	}
-
-	//! Current Position (Relative to the Buffer)
-	idx_t position_buffer = 0;
-
-	//! Start of the piece of the buffer this thread should read
-	idx_t start_buffer = 0;
-	//! End of the piece of this buffer this thread should read
-	idx_t end_buffer = NumericLimits<idx_t>::Maximum();
-	//! The actual buffer size
-	idx_t buffer_size = 0;
-
-	//! If this flag is set, it means we are about to try to read our last row.
-	bool reached_remainder_state = false;
-
-	bool finished = false;
-
-	unique_ptr<CSVBufferRead> buffer;
-
-	idx_t file_idx;
-
-	VerificationPositions GetVerificationPositions();
-
-	//! Position of the first read line and last read line for verification purposes
-	VerificationPositions verification_positions;
-
-public:
-	void SetBufferRead(unique_ptr<CSVBufferRead> buffer);
-	//! Extract a single DataChunk from the CSV file and stores it in insert_chunk
-	void ParseCSV(DataChunk &insert_chunk);
-
-	idx_t GetLineError(idx_t line_error, idx_t buffer_idx, bool stop_at_first = true) override;
-	void Increment(idx_t buffer_idx) override;
-
-private:
-	//! Initialize Parser
-	void Initialize(const vector<LogicalType> &requested_types);
-	//! Try to parse a single datachunk from the file. Throws an exception if anything goes wrong.
-	void ParseCSV(ParserMode mode);
-	//! Try to parse a single datachunk from the file. Returns whether or not the parsing is successful
-	bool TryParseCSV(ParserMode mode);
-	//! Extract a single DataChunk from the CSV file and stores it in insert_chunk
-	bool TryParseCSV(ParserMode mode, DataChunk &insert_chunk, string &error_message);
-	//! Sets Position depending on the byte_start of this thread
-	bool SetPosition();
-	//! Called when scanning the 1st buffer, skips empty lines
-	bool SkipEmptyLines();
-	//! When a buffer finishes reading its piece, it still can try to scan up to the real end of the buffer
-	//! Up to finding a new line. This function sets the buffer_end and marks a boolean variable
-	//! when changing the buffer end the first time.
-	//! It returns FALSE if the parser should jump to the final state of parsing or not
-	bool BufferRemainder();
-
-	bool NewLineDelimiter(bool carry, bool carry_followed_by_nl, bool first_char);
-
-	//! Parses a CSV file with a one-byte delimiter, escape and quote character
-	bool TryParseSimpleCSV(DataChunk &insert_chunk, string &error_message, bool try_add_line = false);
-
-	//! First Position of First Buffer
-	idx_t first_pos_first_buffer = 0;
-};
-
-} // namespace duckdb