duckdb 0.4.1-dev1019.0 → 0.4.1-dev1025.0

package/package.json

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

package/src/duckdb.cpp

@@ -116657,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;
@@ -116666,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;
+}
+
 
 
 
@@ -149327,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);
@@ -149383,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)) {
@@ -149394,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();
@@ -162817,6 +162873,7 @@ unique_ptr<AlterStatement> Transformer::TransformAlterSequence(duckdb_libpgquery
 			throw NotImplementedException("ALTER SEQUENCE option not supported yet!");
 		}
 	}
+	result->info->if_exists = stmt->missing_ok;
 	return result;
 }
 } // namespace duckdb

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 "dd29735fe"
-#define DUCKDB_VERSION "v0.4.1-dev1019"
+#define DUCKDB_SOURCE_ID "f614f426a"
+#define DUCKDB_VERSION "v0.4.1-dev1025"
 //===----------------------------------------------------------------------===//
 //                         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