duckdb 0.4.1-dev1057.0 → 0.4.1-dev1060.0

package/lib/duckdb.js

@@ -6,6 +6,23 @@ module.exports = exports = duckdb;
 var Database = duckdb.Database;
 var Connection = duckdb.Connection;
 var Statement = duckdb.Statement;
+var QueryResult = duckdb.QueryResult;
+
+QueryResult.prototype[Symbol.asyncIterator] = async function*() {
+    let prefetch = this.nextChunk();
+    while (true) {
+        const chunk = await prefetch;
+        // Null chunk indicates end of stream
+        if (!chunk) {
+            return;
+        }
+        // Prefetch the next chunk while we're iterating
+        prefetch = this.nextChunk();
+        for (const row of chunk) {
+            yield row;
+        }
+    }
+}
 
 
 Connection.prototype.run = function(sql) {
@@ -23,6 +40,14 @@ Connection.prototype.each = function(sql) {
     return statement.each.apply(statement, arguments);
 }
 
+Connection.prototype.stream = async function*(sql) {
+    const statement = new Statement(this, sql);
+    const queryResult = await statement.stream.apply(statement, arguments);
+    for await (const result of queryResult) {
+        yield result;
+    }
+}
+
 // this follows the wasm udfs somewhat but is simpler because we can pass data much more cleanly
 Connection.prototype.register = function(name, return_type, fun) {
     // TODO what if this throws an error somewhere? do we need a try/catch?

package/package.json

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

package/src/database.cpp

@@ -141,9 +141,7 @@ static void TaskExecuteCallback(napi_env e, void *data) {
 static void TaskCompleteCallback(napi_env e, napi_status status, void *data) {
 	std::unique_ptr<TaskHolder> holder((TaskHolder *)data);
 	holder->db->TaskComplete(e);
-	if (holder->task->callback.Value().IsFunction()) {
-		holder->task->Callback();
-	}
+	holder->task->DoCallback();
 }
 
 void Database::TaskComplete(Napi::Env env) {

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 "483f9cebd"
-#define DUCKDB_VERSION "v0.4.1-dev1057"
+#define DUCKDB_SOURCE_ID "f2801e48b"
+#define DUCKDB_VERSION "v0.4.1-dev1060"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //

package/src/duckdb_node.cpp

@@ -12,6 +12,7 @@ Napi::Object RegisterModule(Napi::Env env, Napi::Object exports) {
 	node_duckdb::Database::Init(env, exports);
 	node_duckdb::Connection::Init(env, exports);
 	node_duckdb::Statement::Init(env, exports);
+	node_duckdb::QueryResult::Init(env, exports);
 
 	exports.DefineProperties({
 	    DEFINE_CONSTANT_INTEGER(exports, node_duckdb::Database::DUCKDB_NODEJS_ERROR, ERROR) DEFINE_CONSTANT_INTEGER(

package/src/duckdb_node.hpp

@@ -15,8 +15,26 @@ struct Task {
 		}
 		object.Ref();
 	}
+	explicit Task(Napi::Reference<Napi::Object> &object) : object(object) {
+		object.Ref();
+	}
+
+	// Called on a worker thread (i.e., not the main event loop thread)
 	virtual void DoWork() = 0;
 
+	// Called on the event loop thread after the work has been completed. By
+	// default, call the associated callback, if defined. If you're writing
+	// a Task that uses promises, override this method instead of Callback.
+	virtual void DoCallback() {
+		auto env = object.Env();
+		Napi::HandleScope scope(env);
+
+		if (!callback.Value().IsUndefined()) {
+			Callback();
+		}
+	}
+
+	// Called on the event loop thread by DoCallback (see above)
 	virtual void Callback() {
 		auto env = object.Env();
 		Napi::HandleScope scope(env);
@@ -130,8 +148,8 @@ public:
 	Napi::Value All(const Napi::CallbackInfo &info);
 	Napi::Value Each(const Napi::CallbackInfo &info);
 	Napi::Value Run(const Napi::CallbackInfo &info);
-	Napi::Value Bind(const Napi::CallbackInfo &info);
 	Napi::Value Finish(const Napi::CallbackInfo &info);
+	Napi::Value Stream(const Napi::CallbackInfo &info);
 
 public:
 	static Napi::FunctionReference constructor;
@@ -144,6 +162,21 @@ private:
 	std::unique_ptr<StatementParam> HandleArgs(const Napi::CallbackInfo &info);
 };
 
+class QueryResult : public Napi::ObjectWrap<QueryResult> {
+public:
+	explicit QueryResult(const Napi::CallbackInfo &info);
+	~QueryResult() override;
+	static Napi::Object Init(Napi::Env env, Napi::Object exports);
+	std::unique_ptr<duckdb::QueryResult> result;
+
+public:
+	static Napi::FunctionReference constructor;
+	Napi::Value NextChunk(const Napi::CallbackInfo &info);
+
+private:
+	Database *database_ref;
+};
+
 struct TaskHolder {
 	std::unique_ptr<Task> task;
 	napi_async_work request;