duckdb 0.10.1-dev9.0 → 0.10.2-dev0.0

package/src/duckdb/src/include/duckdb/execution/executor.hpp

@@ -99,6 +99,13 @@ public:
 	//! Returns true if all pipelines have been completed
 	bool ExecutionIsFinished();
 
+	void RegisterTask() {
+		executor_tasks++;
+	}
+	void UnregisterTask() {
+		executor_tasks--;
+	}
+
 private:
 	bool ResultCollectorIsBlocked();
 	void InitializeInternal(PhysicalOperator &physical_plan);
@@ -157,5 +164,8 @@ private:
 
 	//! Task that have been descheduled
 	unordered_map<Task *, shared_ptr<Task>> to_be_rescheduled_tasks;
+
+	//! Currently alive executor tasks
+	atomic<idx_t> executor_tasks;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/expression_executor_state.hpp

@@ -43,7 +43,7 @@ public:
 public:
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>

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

@@ -0,0 +1,262 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/csv_scanner/base_scanner.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp"
+#include "duckdb/execution/operator/csv_scanner/scanner_boundary.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_state_machine.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_error.hpp"
+#include "duckdb/common/helper.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, bool sniffing = false,
+	                     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;
+
+	bool ever_quoted = false;
+
+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();
+
+	inline bool ContainsZeroByte(uint64_t v) {
+		return (v - UINT64_C(0x0101010101010101)) & ~(v)&UINT64_C(0x8080808080808080);
+	}
+
+	//! 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) {
+					if (T::EmptyLine(result, iterator.pos.buffer_pos)) {
+						iterator.pos.buffer_pos++;
+						bytes_read = iterator.pos.buffer_pos - start_pos;
+						lines_read++;
+						return;
+					}
+					lines_read++;
+
+				} 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;
+						lines_read++;
+						return;
+					}
+					lines_read++;
+				}
+				iterator.pos.buffer_pos++;
+				break;
+			case CSVState::CARRIAGE_RETURN:
+				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;
+						lines_read++;
+						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;
+						lines_read++;
+						return;
+					}
+				}
+				iterator.pos.buffer_pos++;
+				lines_read++;
+				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);
+				}
+				ever_quoted = true;
+				T::SetQuoted(result, iterator.pos.buffer_pos);
+				iterator.pos.buffer_pos++;
+				while (iterator.pos.buffer_pos + 8 < to_pos) {
+					uint64_t value =
+					    Load<uint64_t>(reinterpret_cast<const_data_ptr_t>(&buffer_handle_ptr[iterator.pos.buffer_pos]));
+					if (ContainsZeroByte((value ^ state_machine->transition_array.quote) &
+					                     (value ^ state_machine->transition_array.escape))) {
+						break;
+					}
+					iterator.pos.buffer_pos += 8;
+				}
+
+				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 (iterator.pos.buffer_pos + 8 < to_pos) {
+					uint64_t value =
+					    Load<uint64_t>(reinterpret_cast<const_data_ptr_t>(&buffer_handle_ptr[iterator.pos.buffer_pos]));
+					if (ContainsZeroByte((value ^ state_machine->transition_array.delimiter) &
+					                     (value ^ state_machine->transition_array.new_line) &
+					                     (value ^ state_machine->transition_array.carriage_return))) {
+						break;
+					}
+					iterator.pos.buffer_pos += 8;
+				}
+				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/column_count_scanner.hpp

@@ -0,0 +1,70 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/csv_scanner/column_count_scanner.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_state_machine.hpp"
+#include "duckdb/execution/operator/csv_scanner/scanner_boundary.hpp"
+#include "duckdb/execution/operator/csv_scanner/string_value_scanner.hpp"
+#include "duckdb/execution/operator/csv_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/csv_buffer.hpp

@@ -0,0 +1,103 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/csv_scanner/csv_buffer.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/constants.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_file_handle.hpp"
+#include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/storage/block_manager.hpp"
+#include "duckdb/storage/buffer/block_handle.hpp"
+
+namespace duckdb {
+
+class CSVBufferHandle {
+public:
+	CSVBufferHandle(BufferHandle handle_p, idx_t actual_size_p, const bool is_final_buffer_p, idx_t file_idx_p,
+	                idx_t buffer_index_p)
+	    : handle(std::move(handle_p)), actual_size(actual_size_p), is_last_buffer(is_final_buffer_p),
+	      file_idx(file_idx_p), buffer_idx(buffer_index_p) {};
+	CSVBufferHandle() : actual_size(0), is_last_buffer(false), file_idx(0), buffer_idx(0) {};
+	~CSVBufferHandle() {
+	}
+	//! Handle created during allocation
+	BufferHandle handle;
+	const idx_t actual_size;
+	const bool is_last_buffer;
+	const idx_t file_idx;
+	const idx_t buffer_idx;
+	inline char *Ptr() {
+		return char_ptr_cast(handle.Ptr());
+	}
+};
+
+//! CSV Buffers are parts of a decompressed CSV File.
+//! For a decompressed file of 100Mb. With our Buffer size set to 32Mb, we would generate 4 buffers.
+//! One for the first 32Mb, second and third for the other 32Mb, and the last one with 4 Mb
+//! These buffers are actually used for sniffing and parsing!
+class CSVBuffer {
+public:
+	//! Constructor for Initial Buffer
+	CSVBuffer(ClientContext &context, idx_t buffer_size_p, CSVFileHandle &file_handle,
+	          idx_t &global_csv_current_position, idx_t file_number);
+
+	//! Constructor for `Next()` Buffers
+	CSVBuffer(CSVFileHandle &file_handle, ClientContext &context, idx_t buffer_size, idx_t global_csv_current_position,
+	          idx_t file_number_p, idx_t buffer_idx);
+
+	//! Creates a new buffer with the next part of the CSV File
+	shared_ptr<CSVBuffer> Next(CSVFileHandle &file_handle, idx_t buffer_size, idx_t file_number, bool &has_seaked);
+
+	//! Gets the buffer actual size
+	idx_t GetBufferSize();
+
+	//! If this buffer is the last buffer of the CSV File
+	bool IsCSVFileLastBuffer();
+
+	//! Allocates internal buffer, sets 'block' and 'handle' variables.
+	void AllocateBuffer(idx_t buffer_size);
+
+	void Reload(CSVFileHandle &file_handle);
+	//! Wrapper for the Pin Function, if it can seek, it means that the buffer might have been destroyed, hence we must
+	//! Scan it from the disk file again.
+	shared_ptr<CSVBufferHandle> Pin(CSVFileHandle &file_handle, bool &has_seeked);
+	//! Wrapper for the unpin
+	void Unpin();
+	char *Ptr() {
+		return char_ptr_cast(handle.Ptr());
+	}
+
+	//! By default, we use CSV_BUFFER_SIZE to allocate each buffer
+	//! TODO: Should benchmarks other values
+	static constexpr idx_t CSV_BUFFER_SIZE = 32000000; // 32MB
+	//! In case the file has a size < 32MB, we will use this size instead
+	//! This is to avoid mallocing a lot of memory for a small file
+	//! And if it's a compressed file we can't use the actual size of the file
+	static constexpr idx_t CSV_MINIMUM_BUFFER_SIZE = 8000000; // 8MB
+	//! If this is the last buffer of the CSV File
+	bool last_buffer = false;
+
+private:
+	ClientContext &context;
+	//! Actual size can be smaller than the buffer size in case we allocate it too optimistically.
+	idx_t actual_buffer_size;
+	//! Global position from the CSV File where this buffer starts
+	idx_t global_csv_start = 0;
+	//! Number of the file that is in this buffer
+	idx_t file_number = 0;
+	//! If we can seek in the file or not.
+	//! If we can't seek, this means we can't destroy the buffers
+	bool can_seek;
+	//! Buffer Index, used as a batch index for insertion-order preservation
+	idx_t buffer_idx = 0;
+	//! -------- Allocated Block ---------//
+	//! Block created in allocation
+	shared_ptr<BlockHandle> block;
+	BufferHandle handle;
+};
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp

@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_file_handle.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_reader_options.hpp"
+
+namespace duckdb {
+class CSVBuffer;
+class CSVStateMachine;
+
+//! This class is used to manage the CSV buffers.  Buffers are cached when used for auto detection.
+//! When parsing, buffer are not cached and just returned.
+//! A CSV Buffer Manager is created for each separate CSV File.
+class CSVBufferManager {
+public:
+	CSVBufferManager(ClientContext &context, const CSVReaderOptions &options, const string &file_path,
+	                 const idx_t file_idx);
+	//! Returns a buffer from a buffer id (starting from 0). If it's in the auto-detection then we cache new buffers
+	//! Otherwise we remove them from the cache if they are already there, or just return them bypassing the cache.
+	shared_ptr<CSVBufferHandle> GetBuffer(const idx_t buffer_idx);
+
+	void ResetBuffer(const idx_t buffer_idx);
+	//! unique_ptr to the file handle, gets stolen after sniffing
+	unique_ptr<CSVFileHandle> file_handle;
+	//! Initializes the buffer manager, during it's construction/reset
+	void Initialize();
+
+	void UnpinBuffer(const idx_t cache_idx);
+	//! Returns the buffer size set for this CSV buffer manager
+	idx_t GetBufferSize();
+	//! Returns the number of buffers in the cached_buffers cache
+	idx_t BufferCount();
+	//! If this buffer manager is done. In the context of a buffer manager it means that it read all buffers at least
+	//! once.
+	bool Done();
+
+	string GetFilePath();
+
+	ClientContext &context;
+	idx_t skip_rows = 0;
+
+private:
+	//! Reads next buffer in reference to cached_buffers.front()
+	bool ReadNextAndCacheIt();
+	//! The file index this Buffer Manager refers to
+	const idx_t file_idx;
+	//! The file path this Buffer Manager refers to
+	const string file_path;
+	//! The cached buffers
+	vector<shared_ptr<CSVBuffer>> cached_buffers;
+	//! The last buffer it was accessed
+	shared_ptr<CSVBuffer> last_buffer;
+	idx_t global_csv_pos = 0;
+	//! The size of the buffer, if the csv file has a smaller size than this, we will use that instead to malloc less
+	idx_t buffer_size;
+	//! If this buffer manager is done (i.e., no more buffers to read beyond the ones that were cached
+	bool done = false;
+	idx_t bytes_read = 0;
+	//! Because the buffer manager can be accessed in Parallel we need a mutex.
+	mutex main_mutex;
+	//! If the file_handle used seek
+	bool has_seeked = false;
+	unordered_set<idx_t> reset_when_possible;
+};
+
+} // namespace duckdb