Make Statement.get() 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
+/** Gets first row from statement in blocking mode. */
+export declare function statementGetSync(stmt: Statement, params?: unknown | undefined | null): unknown
 /** 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
@@ -159,7 +161,7 @@ export declare class Statement {
    * * `env` - The environment.
    * * `params` - The parameters to bind to the statement.
    */
-  get(params?: unknown | undefined | null): unknown
+  get(params?: unknown | undefined | null): object
   /**
    * Create an iterator over the rows of a statement.
    *

index.js

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

integration-tests/tests/async.test.js

@@ -53,15 +53,15 @@ test.serial("Statement.run() [positional]", async (t) => {
 
   // Verify that the data is inserted
   const stmt2 = await db.prepare("SELECT * FROM users WHERE id = 3");
-  t.is(stmt2.get().name, "Carol");
-  t.is(stmt2.get().email, "carol@example.net");
+  t.is((await stmt2.get()).name, "Carol");
+  t.is((await stmt2.get()).email, "carol@example.net");
 });
 
 test.serial("Statement.get() returns no rows", async (t) => {
   const db = t.context.db;
 
   const stmt = await db.prepare("SELECT * FROM users WHERE id = 0");
-  t.is(stmt.get(), undefined);
+  t.is((await stmt.get()), undefined);
 });
 
 test.serial("Statement.get() [no parameters]", async (t) => {
@@ -70,7 +70,7 @@ test.serial("Statement.get() [no parameters]", async (t) => {
   var stmt = 0;
 
   stmt = await db.prepare("SELECT * FROM users");
-  t.is(stmt.get().name, "Alice");
+  t.is((await stmt.get()).name, "Alice");
   t.deepEqual(await stmt.raw().get(), [1, 'Alice', 'alice@example.org']);
 });
 
@@ -80,15 +80,15 @@ test.serial("Statement.get() [positional]", async (t) => {
   var stmt = 0;
 
   stmt = await db.prepare("SELECT * FROM users WHERE id = ?");
-  t.is(stmt.get(0), undefined);
-  t.is(stmt.get([0]), undefined);
-  t.is(stmt.get(1).name, "Alice");
-  t.is(stmt.get(2).name, "Bob");
+  t.is((await stmt.get(0)), undefined);
+  t.is((await stmt.get([0])), undefined);
+  t.is((await stmt.get(1)).name, "Alice");
+  t.is((await stmt.get(2)).name, "Bob");
 
   stmt = await db.prepare("SELECT * FROM users WHERE id = ?1");
-  t.is(stmt.get({1: 0}), undefined);
-  t.is(stmt.get({1: 1}).name, "Alice");
-  t.is(stmt.get({1: 2}).name, "Bob");
+  t.is((await stmt.get({1: 0})), undefined);
+  t.is((await stmt.get({1: 1})).name, "Alice");
+  t.is((await stmt.get({1: 2})).name, "Bob");
 });
 
 test.serial("Statement.get() [named]", async (t) => {
@@ -97,27 +97,27 @@ test.serial("Statement.get() [named]", async (t) => {
   var stmt = undefined;
 
   stmt = await db.prepare("SELECT * FROM users WHERE id = :id");
-  t.is(stmt.get({ id: 0 }), undefined);
-  t.is(stmt.get({ id: 1 }).name, "Alice");
-  t.is(stmt.get({ id: 2 }).name, "Bob");
+  t.is((await stmt.get({ id: 0 })), undefined);
+  t.is((await stmt.get({ id: 1 })).name, "Alice");
+  t.is((await stmt.get({ id: 2 })).name, "Bob");
 
   stmt = await db.prepare("SELECT * FROM users WHERE id = @id");
-  t.is(stmt.get({ id: 0 }), undefined);
-  t.is(stmt.get({ id: 1 }).name, "Alice");
-  t.is(stmt.get({ id: 2 }).name, "Bob");
+  t.is((await stmt.get({ id: 0 })), undefined);
+  t.is((await stmt.get({ id: 1 })).name, "Alice");
+  t.is((await stmt.get({ id: 2 })).name, "Bob");
 
   stmt = await db.prepare("SELECT * FROM users WHERE id = $id");
-  t.is(stmt.get({ id: 0 }), undefined);
-  t.is(stmt.get({ id: 1 }).name, "Alice");
-  t.is(stmt.get({ id: 2 }).name, "Bob");
+  t.is((await stmt.get({ id: 0 })), undefined);
+  t.is((await stmt.get({ id: 1 })).name, "Alice");
+  t.is((await stmt.get({ id: 2 })).name, "Bob");
 });
 
 
 test.serial("Statement.get() [raw]", async (t) => {
   const db = t.context.db;
 
   const stmt = await db.prepare("SELECT * FROM users WHERE id = ?");
-  t.deepEqual(stmt.raw().get(1), [1, "Alice", "alice@example.org"]);
+  t.deepEqual(await stmt.raw().get(1), [1, "Alice", "alice@example.org"]);
 });
 
 test.serial("Statement.iterate() [empty]", async (t) => {
@@ -267,9 +267,9 @@ test.serial("Database.transaction()", async (t) => {
   t.is(db.inTransaction, false);
 
   const stmt = await db.prepare("SELECT * FROM users WHERE id = ?");
-  t.is(stmt.get(3).name, "Joey");
-  t.is(stmt.get(4).name, "Sally");
-  t.is(stmt.get(5).name, "Junior");
+  t.is((await stmt.get(3)).name, "Joey");
+  t.is((await stmt.get(4)).name, "Sally");
+  t.is((await stmt.get(5)).name, "Junior");
 });
 
 test.serial("Database.transaction().immediate()", async (t) => {

integration-tests/tests/concurrency.test.js

@@ -32,8 +32,8 @@ test("Concurrent reads", async (t) => {
 
     const promises = [];
     for (let i = 0; i < 100; i++) {
-        promises.push(stmt.get(t.context.aliceId));
-        promises.push(stmt.get(t.context.bobId));
+        promises.push(await stmt.get(t.context.aliceId));
+        promises.push(await stmt.get(t.context.bobId));
     }
 
     const results = await Promise.all(promises);

promise.js

@@ -270,9 +270,9 @@ class Statement {
    *
    * @param bindParameters - The bind parameters for executing the statement.
    */
-  get(...bindParameters) {
+  async get(...bindParameters) {
     try {
-      return this.stmt.get(...bindParameters);
+      return await this.stmt.get(...bindParameters);
     } catch (err) {
       throw convertError(err);
     }

src/lib.rs

@@ -660,7 +660,7 @@ impl Statement {
         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 {
@@ -676,10 +676,8 @@ impl Statement {
                 lastInsertRowid: last_insert_row_id,
             })
         };
-        
-        env.execute_tokio_future(future, move |&mut _env, result| {
-            Ok(result)
-        })
+
+        env.execute_tokio_future(future, move |&mut _env, result| Ok(result))
     }
 
     /// Executes a SQL statement and returns the first row.
@@ -689,35 +687,35 @@ impl Statement {
     /// * `env` - The environment.
     /// * `params` - The parameters to bind to the statement.
     #[napi]
-    pub fn get(&self, env: Env, params: Option<napi::JsUnknown>) -> Result<napi::JsUnknown> {
-        let rt = runtime()?;
-
+    pub fn get(&self, env: Env, params: Option<napi::JsUnknown>) -> Result<napi::JsObject> {
         let safe_ints = self.mode.safe_ints.load(Ordering::SeqCst);
         let raw = self.mode.raw.load(Ordering::SeqCst);
         let pluck = self.mode.pluck.load(Ordering::SeqCst);
         let timed = self.mode.timing.load(Ordering::SeqCst);
 
+        let params = map_params(&self.stmt, params)?;
+        let stmt = self.stmt.clone();
+        let column_names = self.column_names.clone();
+
         let start = if timed {
             Some(std::time::Instant::now())
         } else {
             None
         };
-        rt.block_on(async move {
-            let params = map_params(&self.stmt, params)?;
-            let mut rows = self.stmt.query(params).await.map_err(Error::from)?;
+
+        let stmt_fut = stmt.clone();
+        let future = async move {
+            let mut rows = stmt_fut.query(params).await.map_err(Error::from)?;
             let row = rows.next().await.map_err(Error::from)?;
             let duration: Option<f64> = start.map(|start| start.elapsed().as_secs_f64());
-            let result = Self::get_internal(
-                &env,
-                &row,
-                &self.column_names,
-                safe_ints,
-                raw,
-                pluck,
-                duration,
-            );
-            self.stmt.reset();
-            result
+            Ok((row, duration))
+        };
+
+        env.execute_tokio_future(future, move |&mut env, (row, duration)| {
+            let result =
+                Self::get_internal(&env, &row, &column_names, safe_ints, raw, pluck, duration);
+            stmt.reset();
+            Ok(result)
         })
     }
 
@@ -871,6 +869,44 @@ impl Statement {
     }
 }
 
+/// Gets first row from statement in blocking mode.
+#[napi]
+pub fn statement_get_sync(
+    stmt: &Statement,
+    env: Env,
+    params: Option<napi::JsUnknown>,
+) -> Result<napi::JsUnknown> {
+    let safe_ints = stmt.mode.safe_ints.load(Ordering::SeqCst);
+    let raw = stmt.mode.raw.load(Ordering::SeqCst);
+    let pluck = stmt.mode.pluck.load(Ordering::SeqCst);
+    let timed = stmt.mode.timing.load(Ordering::SeqCst);
+
+    let start = if timed {
+        Some(std::time::Instant::now())
+    } else {
+        None
+    };
+
+    let rt = runtime()?;
+    rt.block_on(async move {
+        let params = map_params(&stmt.stmt, params)?;
+        let mut rows = stmt.stmt.query(params).await.map_err(Error::from)?;
+        let row = rows.next().await.map_err(Error::from)?;
+        let duration: Option<f64> = start.map(|start| start.elapsed().as_secs_f64());
+        let result = Statement::get_internal(
+            &env,
+            &row,
+            &stmt.column_names,
+            safe_ints,
+            raw,
+            pluck,
+            duration,
+        );
+        stmt.stmt.reset();
+        result
+    })
+}
+
 /// Runs a statement in blocking mode.
 #[napi]
 pub fn statement_run_sync(stmt: &Statement, params: Option<napi::JsUnknown>) -> Result<RunResult> {

wrapper.js

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