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

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp

@@ -0,0 +1,189 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/execution/operator/csv_scanner/state_machine/csv_state_machine.hpp"
+#include "duckdb/common/vector.hpp"
+#include "duckdb/execution/operator/csv_scanner/sniffer/quote_rules.hpp"
+#include "duckdb/execution/operator/csv_scanner/scanner/column_count_scanner.hpp"
+
+namespace duckdb {
+struct DateTimestampSniffing {
+	bool initialized = false;
+	vector<string> format;
+};
+//! 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;
+};
+
+//! This represents the data related to columns that have been set by the user
+//! e.g., from a copy command
+struct SetColumns {
+	SetColumns(const vector<LogicalType> *types_p, const vector<string> *names_p) : types(types_p), names(names_p) {
+		if (!types) {
+			D_ASSERT(!types && !names);
+		} else {
+			D_ASSERT(types->size() == names->size());
+		}
+	}
+	SetColumns() {};
+	//! Return Types that were detected
+	const vector<LogicalType> *types = nullptr;
+	//! Column Names that were detected
+	const vector<string> *names = nullptr;
+	//! If columns are set
+	bool IsSet();
+	//! How many columns
+	idx_t Size();
+	//! Helper function that checks if candidate is acceptable based on the number of columns it produces
+	inline bool IsCandidateUnacceptable(idx_t num_cols, bool null_padding, bool ignore_errors,
+	                                    bool last_value_always_empty) {
+		if (!IsSet() || ignore_errors) {
+			// We can't say its unacceptable if it's not set or if we ignore errors
+			return false;
+		}
+		idx_t size = Size();
+		// If the columns are set and there is a mismatch with the expected number of columns, with null_padding and
+		// ignore_errors not set, we don't have a suitable candidate.
+		// Note that we compare with max_columns_found + 1, because some broken files have the behaviour where two
+		// columns are represented as: | col 1 | col_2 |
+		if (num_cols == size || num_cols == size + last_value_always_empty) {
+			// Good Candidate
+			return false;
+		}
+		// if we detected more columns than we have set, it's all good because we can null-pad them
+		if (null_padding && num_cols > size) {
+			return false;
+		}
+
+		// Unacceptable
+		return true;
+	}
+};
+
+//! 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, SetColumns set_columns = {});
+
+	//! 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(bool force_match = false);
+
+	static NewLineIdentifier DetectNewLineDelimiter(CSVBufferManager &buffer_manager);
+
+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<ColumnCountScanner>> 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;
+	//! Information regarding columns that were set by user/query
+	SetColumns set_columns;
+	shared_ptr<CSVErrorHandler> error_handler;
+	shared_ptr<CSVErrorHandler> detection_error_handler;
+	//! 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<ColumnCountScanner>> &column_count_scanners,
+	                                     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<ColumnCountScanner>, 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(ColumnCountScanner &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);
+
+	//! Function that initialized the necessary variables used for date and timestamp detection
+	void InitializeDateAndTimeStampDetection(CSVStateMachine &candidate, const string &separator,
+	                                         const LogicalType &sql_type);
+	//! Functions that performs detection for date and timestamp formats
+	void DetectDateAndTimeStampFormats(CSVStateMachine &candidate, 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<StringValueScanner> best_candidate;
+	vector<Value> best_header_row;
+	//! Variable used for sniffing date and timestamp
+	map<LogicalTypeId, DateTimestampSniffing> format_candidates;
+
+	//! ------------------------------------------------------//
+	//! ------------------ 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;
+
+	//! ------------------------------------------------------//
+	//! ------------------ Type Replacement ----------------- //
+	//! ------------------------------------------------------//
+	void ReplaceTypes();
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/sniffer/quote_rules.hpp

@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/csv_scanner/sniffer/quote_rules.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/vector.hpp"
+
+namespace duckdb {
+//! Different Rules regarding possible combinations of Quote and Escape Values for CSV Dialects.
+//! Each rule has a comment on the possible combinations.
+enum class QuoteRule : uint8_t {
+	QUOTES_RFC = 0,   //! quote = " escape = (\0 || " || ')
+	QUOTES_OTHER = 1, //! quote = ( " || ' ) escape = '\\'
+	NO_QUOTES = 2     //! quote = \0 escape = \0
+};
+} // namespace duckdb

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

@@ -0,0 +1,30 @@
+//===----------------------------------------------------------------------===//
+//                         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

@@ -0,0 +1,99 @@
+//===----------------------------------------------------------------------===//
+//                         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

@@ -0,0 +1,87 @@
+//===----------------------------------------------------------------------===//
+//                         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

@@ -0,0 +1,70 @@
+//===----------------------------------------------------------------------===//
+//                         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

@@ -0,0 +1,80 @@
+//===----------------------------------------------------------------------===//
+//                         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