Make Statement.run() async

Author: penberg

index.d.ts

@@ -27,6 +27,8 @@ export declare function databasePrepareSync(db: Database, sql: string): Statemen
 export declare function databaseSyncSync(db: Database): SyncResult
 /** Executes SQL in blocking mode. */
 export declare function databaseExecSync(db: Database, sql: string): void
+/** Runs a statement in blocking mode. */
+export declare function statementRunSync(stmt: Statement, params?: unknown | undefined | null): RunResult
 export declare function statementIterateSync(stmt: Statement, params?: unknown | undefined | null): RowsIterator
 /** SQLite `run()` result object */
 export interface RunResult {
@@ -148,7 +150,7 @@ export declare class Statement {
    *
    * * `params` - The parameters to bind to the statement.
    */
-  run(params?: unknown | undefined | null): RunResult
+  run(params?: unknown | undefined | null): object
   /**
    * Executes a SQL statement and returns the first row.
    *

index.js

@@ -310,13 +310,14 @@ if (!nativeBinding) {
   throw new Error(`Failed to load native binding`)
 }
 
-const { Database, databasePrepareSync, databaseSyncSync, databaseExecSync, Statement, statementIterateSync, RowsIterator, iteratorNextSync, Record } = nativeBinding
+const { Database, databasePrepareSync, databaseSyncSync, databaseExecSync, Statement, statementRunSync, statementIterateSync, RowsIterator, iteratorNextSync, Record } = nativeBinding
 
 module.exports.Database = Database
 module.exports.databasePrepareSync = databasePrepareSync
 module.exports.databaseSyncSync = databaseSyncSync
 module.exports.databaseExecSync = databaseExecSync
 module.exports.Statement = Statement
+module.exports.statementRunSync = statementRunSync
 module.exports.statementIterateSync = statementIterateSync
 module.exports.RowsIterator = RowsIterator
 module.exports.iteratorNextSync = iteratorNextSync

integration-tests/tests/async.test.js

@@ -47,7 +47,7 @@ test.serial("Statement.run() [positional]", async (t) => {
   const db = t.context.db;
 
   const stmt = await db.prepare("INSERT INTO users(name, email) VALUES (?, ?)");
-  const info = stmt.run(["Carol", "carol@example.net"]);
+  const info = await stmt.run(["Carol", "carol@example.net"]);
   t.is(info.changes, 1);
   t.is(info.lastInsertRowid, 3);
 
@@ -253,9 +253,9 @@ test.serial("Database.transaction()", async (t) => {
     "INSERT INTO users(name, email) VALUES (:name, :email)"
   );
 
-  const insertMany = db.transaction((users) => {
+  const insertMany = db.transaction(async (users) => {
     t.is(db.inTransaction, true);
-    for (const user of users) insert.run(user);
+    for (const user of users) await insert.run(user);
   });
 
   t.is(db.inTransaction, false);
@@ -277,9 +277,9 @@ test.serial("Database.transaction().immediate()", async (t) => {
   const insert = await db.prepare(
     "INSERT INTO users(name, email) VALUES (:name, :email)"
   );
-  const insertMany = db.transaction((users) => {
+  const insertMany = db.transaction(async (users) => {
     t.is(db.inTransaction, true);
-    for (const user of users) insert.run(user);
+    for (const user of users) await insert.run(user);
   });
   t.is(db.inTransaction, false);
   await insertMany.immediate([

integration-tests/tests/concurrency.test.js

@@ -63,7 +63,7 @@ test("Concurrent writes", async (t) => {
 
     const promises = [];
     for (let i = 0; i < 50; i++) {
-        promises.push(stmt.run({
+        promises.push(await stmt.run({
             id: generateUUID(),
             name: `User${i}`,
             email: `user${i}@example.com`
@@ -103,7 +103,7 @@ test("Concurrent reads and writes", async (t) => {
     const promises = [];
     for (let i = 0; i < 20; i++) {
         promises.push(readStmt.get(aliceId));
-        writeStmt.run({
+        await writeStmt.run({
             id: generateUUID(),
             name: `User${i}`,
             email: `user${i}@example.com`

promise.js

@@ -257,9 +257,9 @@ class Statement {
   /**
    * Executes the SQL statement and returns an info object.
    */
-  run(...bindParameters) {
+  async run(...bindParameters) {
     try {
-      return this.stmt.run(...bindParameters);
+      return await this.stmt.run(...bindParameters);
     } catch (err) {
       throw convertError(err);
     }

src/lib.rs

@@ -653,27 +653,32 @@ impl Statement {
     ///
     /// * `params` - The parameters to bind to the statement.
     #[napi]
-    pub fn run(&self, params: Option<napi::JsUnknown>) -> Result<RunResult> {
-        let rt = runtime()?;
-        rt.block_on(async move {
-            let total_changes_before = self.conn.total_changes();
-            let start = std::time::Instant::now();
-
-            let params = map_params(&self.stmt, params)?;
-            self.stmt.run(params).await.map_err(Error::from)?;
-            let changes = if self.conn.total_changes() == total_changes_before {
+    pub fn run(&self, env: Env, params: Option<napi::JsUnknown>) -> Result<napi::JsObject> {
+        self.stmt.reset();
+        let params = map_params(&self.stmt, params)?;
+        let total_changes_before = self.conn.total_changes();
+        let start = std::time::Instant::now();
+        let stmt = self.stmt.clone();
+        let conn = self.conn.clone();
+        
+        let future = async move {
+            stmt.run(params).await.map_err(Error::from)?;
+            let changes = if conn.total_changes() == total_changes_before {
                 0
             } else {
-                self.conn.changes()
+                conn.changes()
             };
-            let last_insert_row_id = self.conn.last_insert_rowid();
+            let last_insert_row_id = conn.last_insert_rowid();
             let duration = start.elapsed().as_secs_f64();
-            self.stmt.reset();
             Ok(RunResult {
                 changes: changes as f64,
                 duration,
                 lastInsertRowid: last_insert_row_id,
             })
+        };
+        
+        env.execute_tokio_future(future, move |&mut _env, result| {
+            Ok(result)
         })
     }
 
@@ -866,6 +871,32 @@ impl Statement {
     }
 }
 
+/// Runs a statement in blocking mode.
+#[napi]
+pub fn statement_run_sync(stmt: &Statement, params: Option<napi::JsUnknown>) -> Result<RunResult> {
+    stmt.stmt.reset();
+    let rt = runtime()?;
+    rt.block_on(async move {
+        let params = map_params(&stmt.stmt, params)?;
+        let total_changes_before = stmt.conn.total_changes();
+        let start = std::time::Instant::now();
+
+        stmt.stmt.run(params).await.map_err(Error::from)?;
+        let changes = if stmt.conn.total_changes() == total_changes_before {
+            0
+        } else {
+            stmt.conn.changes()
+        };
+        let last_insert_row_id = stmt.conn.last_insert_rowid();
+        let duration = start.elapsed().as_secs_f64();
+        Ok(RunResult {
+            changes: changes as f64,
+            duration,
+            lastInsertRowid: last_insert_row_id,
+        })
+    })
+}
+
 #[napi]
 pub fn statement_iterate_sync(
     stmt: &Statement,

wrapper.js

@@ -1,6 +1,6 @@
 "use strict";
 
-const { Database: NativeDb, databasePrepareSync, databaseSyncSync, databaseExecSync, statementIterateSync, iteratorNextSync } = require("./index.js");
+const { Database: NativeDb, databasePrepareSync, databaseSyncSync, databaseExecSync, statementRunSync, statementIterateSync, iteratorNextSync } = require("./index.js");
 const SqliteError = require("./sqlite-error.js");
 const Authorization = require("./auth");
 
@@ -263,7 +263,7 @@ class Statement {
    */
   run(...bindParameters) {
     try {
-      return this.stmt.run(...bindParameters);
+      return statementRunSync(this.stmt, ...bindParameters);
     } catch (err) {
       throw convertError(err);
     }