duckdb 0.4.1-dev1016.0 → 0.4.1-dev1022.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.4.1-dev1016.0",
+  "version": "0.4.1-dev1022.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -79499,18 +79499,21 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalWindow &op
 	types.resize(output_idx);
 
 	// Identify streaming windows
-	vector<idx_t> window_expressions;
-	bool process_streaming = true;
+	vector<idx_t> blocking_windows;
+	vector<idx_t> streaming_windows;
 	for (idx_t expr_idx = 0; expr_idx < op.expressions.size(); expr_idx++) {
-		window_expressions.push_back(expr_idx);
-		if (!IsStreamingWindow(op.expressions[expr_idx])) {
-			process_streaming = false;
+		if (IsStreamingWindow(op.expressions[expr_idx])) {
+			streaming_windows.push_back(expr_idx);
+		} else {
+			blocking_windows.push_back(expr_idx);
 		}
 	}
+
 	// Process the window functions by sharing the partition/order definitions
 	vector<idx_t> evaluation_order;
-	while (!window_expressions.empty()) {
-		auto &remaining = window_expressions;
+	while (!blocking_windows.empty() || !streaming_windows.empty()) {
+		const bool process_streaming = blocking_windows.empty();
+		auto &remaining = process_streaming ? streaming_windows : blocking_windows;
 
 		// Find all functions that share the partitioning of the first remaining expression
 		const auto over_idx = remaining[0];
@@ -79547,7 +79550,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalWindow &op
 		plan = move(window);
 
 		// Remember the projection order if we changed it
-		if (!remaining.empty() || !evaluation_order.empty()) {
+		if (!streaming_windows.empty() || !blocking_windows.empty() || !evaluation_order.empty()) {
 			evaluation_order.insert(evaluation_order.end(), matching.begin(), matching.end());
 		}
 	}
@@ -116654,6 +116657,16 @@ void duckdb_function_set_error(duckdb_function_info info, const char *error) {
 
 using duckdb::DatabaseData;
 
+struct CAPITaskState {
+	CAPITaskState(duckdb::DatabaseInstance &db)
+	    : db(db), marker(duckdb::make_unique<duckdb::atomic<bool>>(true)), execute_count(0) {
+	}
+
+	duckdb::DatabaseInstance &db;
+	duckdb::unique_ptr<duckdb::atomic<bool>> marker;
+	duckdb::atomic<idx_t> execute_count;
+};
+
 void duckdb_execute_tasks(duckdb_database database, idx_t max_tasks) {
 	if (!database) {
 		return;
@@ -116663,6 +116676,46 @@ void duckdb_execute_tasks(duckdb_database database, idx_t max_tasks) {
 	scheduler.ExecuteTasks(max_tasks);
 }
 
+duckdb_task_state duckdb_create_task_state(duckdb_database database) {
+	if (!database) {
+		return nullptr;
+	}
+	auto wrapper = (DatabaseData *)database;
+	auto state = new CAPITaskState(*wrapper->database->instance);
+	return state;
+}
+
+void duckdb_execute_tasks_state(duckdb_task_state state_p) {
+	if (!state_p) {
+		return;
+	}
+	auto state = (CAPITaskState *)state_p;
+	auto &scheduler = duckdb::TaskScheduler::GetScheduler(state->db);
+	state->execute_count++;
+	scheduler.ExecuteForever(state->marker.get());
+}
+
+void duckdb_finish_execution(duckdb_task_state state_p) {
+	if (!state_p) {
+		return;
+	}
+	auto state = (CAPITaskState *)state_p;
+	*state->marker = false;
+	if (state->execute_count > 0) {
+		// signal to the threads to wake up
+		auto &scheduler = duckdb::TaskScheduler::GetScheduler(state->db);
+		scheduler.Signal(state->execute_count);
+	}
+}
+
+void duckdb_destroy_task_state(duckdb_task_state state_p) {
+	if (!state_p) {
+		return;
+	}
+	auto state = (CAPITaskState *)state_p;
+	delete state;
+}
+
 
 
 
@@ -149324,7 +149377,7 @@ void TaskScheduler::ExecuteForever(atomic<bool> *marker) {
 	unique_ptr<Task> task;
 	// loop until the marker is set to false
 	while (*marker) {
-		// wait for a signal with a timeout; the timeout allows us to periodically check
+		// wait for a signal with a timeout
 		queue->semaphore.wait();
 		if (queue->q.try_dequeue(task)) {
 			task->Execute(TaskExecutionMode::PROCESS_ALL);
@@ -149380,6 +149433,12 @@ void TaskScheduler::SetThreads(int32_t n) {
 #endif
 }
 
+void TaskScheduler::Signal(idx_t n) {
+#ifndef DUCKDB_NO_THREADS
+	queue->semaphore.signal(n);
+#endif
+}
+
 void TaskScheduler::SetThreadsInternal(int32_t n) {
 #ifndef DUCKDB_NO_THREADS
 	if (threads.size() == idx_t(n - 1)) {
@@ -149391,7 +149450,7 @@ void TaskScheduler::SetThreadsInternal(int32_t n) {
 		for (idx_t i = 0; i < threads.size(); i++) {
 			*markers[i] = false;
 		}
-		queue->semaphore.signal(threads.size());
+		Signal(threads.size());
 		// now join the threads to ensure they are fully stopped before erasing them
 		for (idx_t i = 0; i < threads.size(); i++) {
 			threads[i]->internal_thread->join();

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "6937493e4"
-#define DUCKDB_VERSION "v0.4.1-dev1016"
+#define DUCKDB_SOURCE_ID "4aa7d9569"
+#define DUCKDB_VERSION "v0.4.1-dev1022"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -11189,6 +11189,9 @@ public:
 	//! Returns the number of threads
 	int32_t NumberOfThreads();
 
+	//! Send signals to n threads, signalling for them to wake up and attempt to execute a task
+	void Signal(idx_t n);
+
 private:
 	void SetThreadsInternal(int32_t n);
 
@@ -17761,6 +17764,8 @@ DUCKDB_API void duckdb_destroy_arrow(duckdb_arrow *result);
 //===--------------------------------------------------------------------===//
 // Threading Information
 //===--------------------------------------------------------------------===//
+typedef void *duckdb_task_state;
+
 /*!
 Execute DuckDB tasks on this thread.
 
@@ -17771,6 +17776,44 @@ Will return after `max_tasks` have been executed, or if there are no more tasks
 */
 DUCKDB_API void duckdb_execute_tasks(duckdb_database database, idx_t max_tasks);
 
+/*!
+Creates a task state that can be used with duckdb_execute_tasks_state to execute tasks until
+ duckdb_finish_execution is called on the state.
+
+duckdb_destroy_state should be called on the result in order to free memory.
+
+* database: The database object to create the task state for
+* returns: The task state that can be used with duckdb_execute_tasks_state.
+*/
+DUCKDB_API duckdb_task_state duckdb_create_task_state(duckdb_database database);
+
+/*!
+Execute DuckDB tasks on this thread.
+
+The thread will keep on executing tasks forever, until duckdb_finish_execution is called on the state.
+Multiple threads can share the same duckdb_task_state.
+
+* state: The task state of the executor
+*/
+DUCKDB_API void duckdb_execute_tasks_state(duckdb_task_state state);
+
+/*!
+Finish execution on a specific task.
+
+* state: The task state to finish execution
+*/
+DUCKDB_API void duckdb_finish_execution(duckdb_task_state state);
+
+/*!
+Destroys the task state returned from duckdb_create_task_state.
+
+Note that this should not be called while there is an active duckdb_execute_tasks_state running
+on the task state.
+
+* state: The task state to clean up
+*/
+DUCKDB_API void duckdb_destroy_task_state(duckdb_task_state state);
+
 #ifdef __cplusplus
 }
 #endif