duckdb 0.5.2-dev1610.0 → 0.5.2-dev1616.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.5.2-dev1610.0",
+  "version": "0.5.2-dev1616.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -8195,6 +8195,56 @@ void DuckDBAssertInternal(bool condition, const char *condition_name, const char
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/profiler.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+//! The profiler can be used to measure elapsed time
+template <typename T>
+class BaseProfiler {
+public:
+	//! Starts the timer
+	void Start() {
+		finished = false;
+		start = Tick();
+	}
+	//! Finishes timing
+	void End() {
+		end = Tick();
+		finished = true;
+	}
+
+	//! Returns the elapsed time in seconds. If End() has been called, returns
+	//! the total elapsed time. Otherwise returns how far along the timer is
+	//! right now.
+	double Elapsed() const {
+		auto _end = finished ? end : Tick();
+		return std::chrono::duration_cast<std::chrono::duration<double>>(_end - start).count();
+	}
+
+private:
+	time_point<T> Tick() const {
+		return T::now();
+	}
+	time_point<T> start;
+	time_point<T> end;
+	bool finished = false;
+};
+
+using Profiler = BaseProfiler<system_clock>;
+
+} // namespace duckdb
 
 
 
@@ -30079,6 +30129,72 @@ bool PreservedError::operator==(const PreservedError &other) const {
 
 } // namespace duckdb
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/progress_bar.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+
+namespace duckdb {
+
+class ProgressBar {
+public:
+	explicit ProgressBar(Executor &executor, idx_t show_progress_after, bool print_progress);
+
+	//! Starts the thread
+	void Start();
+	//! Updates the progress bar and prints it to the screen
+	void Update(bool final);
+	//! Gets current percentage
+	double GetCurrentPercentage();
+
+private:
+	static constexpr const idx_t PARTIAL_BLOCK_COUNT = 8;
+#ifndef DUCKDB_ASCII_TREE_RENDERER
+	const char *PROGRESS_EMPTY = " ";
+	const char *PROGRESS_PARTIAL[PARTIAL_BLOCK_COUNT] {
+	    " ",           "\xE2\x96\x8F", "\xE2\x96\x8E", "\xE2\x96\x8D", "\xE2\x96\x8C", "\xE2\x96\x8B", "\xE2\x96\x8A",
+	    "\xE2\x96\x89"};
+	const char *PROGRESS_BLOCK = "\xE2\x96\x88";
+	const char *PROGRESS_START = "\xE2\x96\x95";
+	const char *PROGRESS_END = "\xE2\x96\x8F";
+#else
+	const char *PROGRESS_EMPTY = " ";
+	const char *PROGRESS_PARTIAL[PARTIAL_BLOCK_COUNT] {" ", " ", " ", " ", " ", " ", " ", " "};
+	const char *PROGRESS_BLOCK = "=";
+	const char *PROGRESS_START = "[";
+	const char *PROGRESS_END = "]";
+#endif
+	static constexpr const idx_t PROGRESS_BAR_WIDTH = 60;
+
+	void PrintProgressInternal(int percentage);
+	void PrintProgress(int percentage);
+	void FinishProgressBarPrint();
+
+private:
+	//! The executor
+	Executor &executor;
+	//! The profiler used to measure the time since the progress bar was started
+	Profiler profiler;
+	//! The time in ms after which to start displaying the progress bar
+	idx_t show_progress_after;
+	//! The current progress percentage
+	double current_percentage;
+	//! Whether or not we print the progress bar
+	bool print_progress;
+	//! Whether or not profiling is supported for the current query
+	bool supported = true;
+};
+} // namespace duckdb
 
 
 
@@ -30096,40 +30212,33 @@ bool PreservedError::operator==(const PreservedError &other) const {
 
 namespace duckdb {
 
-// LCOV_EXCL_START
-void Printer::Print(OutputStream stream, const string &str) {
+void Printer::RawPrint(OutputStream stream, const string &str) {
 #ifndef DUCKDB_DISABLE_PRINT
 #ifdef DUCKDB_WINDOWS
 	if (IsTerminal(stream)) {
 		// print utf8 to terminal
 		auto unicode = WindowsUtil::UTF8ToMBCS(str.c_str());
-		fprintf(stream == OutputStream::STREAM_STDERR ? stderr : stdout, "%s\n", unicode.c_str());
+		fprintf(stream == OutputStream::STREAM_STDERR ? stderr : stdout, "%s", unicode.c_str());
 		return;
 	}
 #endif
-	fprintf(stream == OutputStream::STREAM_STDERR ? stderr : stdout, "%s\n", str.c_str());
+	fprintf(stream == OutputStream::STREAM_STDERR ? stderr : stdout, "%s", str.c_str());
 #endif
 }
 
-void Printer::Print(const string &str) {
-	Printer::Print(OutputStream::STREAM_STDERR, str);
+// LCOV_EXCL_START
+void Printer::Print(OutputStream stream, const string &str) {
+	Printer::RawPrint(stream, str);
+	Printer::RawPrint(stream, "\n");
 }
-
-void Printer::PrintProgress(int percentage, const char *pbstr, int pbwidth) {
+void Printer::Flush(OutputStream stream) {
 #ifndef DUCKDB_DISABLE_PRINT
-	int lpad = (int)(percentage / 100.0 * pbwidth);
-	int rpad = pbwidth - lpad;
-	fprintf(stdout, "\r%3d%% [%.*s%*s]", percentage, lpad, pbstr, rpad, "");
-	fflush(stdout);
+	fflush(stream == OutputStream::STREAM_STDERR ? stderr : stdout);
 #endif
 }
 
-void Printer::FinishProgressBarPrint(const char *pbstr, int pbwidth) {
-#ifndef DUCKDB_DISABLE_PRINT
-	PrintProgress(100, pbstr, pbwidth);
-	fprintf(stdout, " \n");
-	fflush(stdout);
-#endif
+void Printer::Print(const string &str) {
+	Printer::Print(OutputStream::STREAM_STDERR, str);
 }
 
 bool Printer::IsTerminal(OutputStream stream) {
@@ -30201,12 +30310,72 @@ void ProgressBar::Update(bool final) {
 		current_percentage = new_percentage;
 	}
 	if (supported && print_progress && sufficient_time_elapsed && current_percentage > -1 && print_progress) {
+#ifndef DUCKDB_DISABLE_PRINT
 		if (final) {
-			Printer::FinishProgressBarPrint(PROGRESS_BAR_STRING.c_str(), PROGRESS_BAR_WIDTH);
+			FinishProgressBarPrint();
 		} else {
-			Printer::PrintProgress(current_percentage, PROGRESS_BAR_STRING.c_str(), PROGRESS_BAR_WIDTH);
+			PrintProgress(current_percentage);
+		}
+#endif
+	}
+}
+
+void ProgressBar::PrintProgressInternal(int percentage) {
+	if (percentage > 100) {
+		percentage = 100;
+	}
+	if (percentage < 0) {
+		percentage = 0;
+	}
+	string result;
+	// we divide the number of blocks by the percentage
+	// 0%   = 0
+	// 100% = PROGRESS_BAR_WIDTH
+	// the percentage determines how many blocks we need to draw
+	double blocks_to_draw = PROGRESS_BAR_WIDTH * (percentage / 100.0);
+	// because of the power of unicode, we can also draw partial blocks
+
+	// render the percentage with some padding to ensure everything stays nicely aligned
+	result = "\r";
+	if (percentage < 100) {
+		result += " ";
+	}
+	if (percentage < 10) {
+		result += " ";
+	}
+	result += to_string(percentage) + "%";
+	result += " ";
+	result += PROGRESS_START;
+	idx_t i;
+	for (i = 0; i < idx_t(blocks_to_draw); i++) {
+		result += PROGRESS_BLOCK;
+	}
+	if (i < PROGRESS_BAR_WIDTH) {
+		// print a partial block based on the percentage of the progress bar remaining
+		idx_t index = idx_t((blocks_to_draw - idx_t(blocks_to_draw)) * PARTIAL_BLOCK_COUNT);
+		if (index >= PARTIAL_BLOCK_COUNT) {
+			index = PARTIAL_BLOCK_COUNT - 1;
 		}
+		result += PROGRESS_PARTIAL[index];
+		i++;
+	}
+	for (; i < PROGRESS_BAR_WIDTH; i++) {
+		result += PROGRESS_EMPTY;
 	}
+	result += PROGRESS_END;
+	result += " ";
+
+	Printer::RawPrint(OutputStream::STREAM_STDOUT, result);
+}
+void ProgressBar::PrintProgress(int percentage) {
+	PrintProgressInternal(percentage);
+	Printer::Flush(OutputStream::STREAM_STDOUT);
+}
+
+void ProgressBar::FinishProgressBarPrint() {
+	PrintProgressInternal(100);
+	Printer::RawPrint(OutputStream::STREAM_STDOUT, "\n");
+	Printer::Flush(OutputStream::STREAM_STDOUT);
 }
 
 } // namespace duckdb
@@ -123409,6 +123578,7 @@ static void WriteCSVSink(ExecutionContext &context, FunctionData &bind_data, Glo
 
 	// first cast the columns of the chunk to varchar
 	auto &cast_chunk = local_data.cast_chunk;
+	cast_chunk.Reset();
 	cast_chunk.SetCardinality(input);
 	for (idx_t col_idx = 0; col_idx < input.ColumnCount(); col_idx++) {
 		if (csv_data.sql_types[col_idx].id() == LogicalTypeId::VARCHAR) {
@@ -133384,6 +133554,7 @@ public:
 
 
 
+
 namespace duckdb {
 
 struct ActiveQueryContext {