wip

Author: geeksilva97

src/node_sqlite.cc

@@ -2342,7 +2342,7 @@ void Statement::Run(const FunctionCallbackInfo<Value>& args) {
     if (sqlite_status != SQLITE_OK) {
       Isolate* isolate = env->isolate();
       Local<Object> e;
-      if (!CreateSQLiteError(isolate, sqlite_status).ToLocal(&e)) {
+      if (!CreateSQLiteError(isolate, stmt->db_->Connection()).ToLocal(&e)) {
         return;
       }
       resolver->Reject(env->context(), e);
@@ -2890,6 +2890,7 @@ void DefineAsyncInterface(Isolate* isolate,
       Database::kInternalFieldCount);
 
   SetProtoMethod(isolate, db_async_tmpl, "close", Database::Close);
+  SetProtoMethod(isolate, db_async_tmpl, "prepare", Database::Prepare);
   SetProtoMethod(isolate, db_async_tmpl, "exec", Database::Exec);
   SetConstructorFunction(context, target, "Database", db_async_tmpl);
 }

test/parallel/test-sqlite-statement-async.js

@@ -24,3 +24,72 @@ suite('Statement() constructor', () => {
     });
   });
 });
+
+suite('Statement.prototype.run()', () => {
+  test('executes a query and returns change metadata', async (t) => {
+    const db = new Database(nextDb());
+    t.after(() => { db.close(); });
+    const setup = await db.exec(`
+      CREATE TABLE storage(key TEXT, val TEXT);
+      INSERT INTO storage (key, val) VALUES ('foo', 'bar');
+    `);
+    t.assert.strictEqual(setup, undefined);
+    const stmt = db.prepare('SELECT * FROM storage');
+    const r = await stmt.run();
+    t.assert.deepStrictEqual(r, { changes: 1, lastInsertRowid: 1 });
+  });
+
+  test('SQLite throws when trying to bind too many parameters', async (t) => {
+    const db = new Database(nextDb());
+    t.after(() => { db.close(); });
+    const setup = await db.exec(
+      'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
+    );
+    t.assert.strictEqual(setup, undefined);
+    const stmt = db.prepare('INSERT INTO data (key, val) VALUES (?, ?)');
+    t.assert.rejects(async () => {
+      await stmt.run(1, 2, 3);
+    }, {
+      code: 'ERR_SQLITE_ERROR',
+      message: 'column index out of range',
+      errcode: 25,
+      errstr: 'column index out of range',
+    });
+  });
+
+  test('SQLite defaults to NULL for unbound parameters', async (t) => {
+    const db = new Database(nextDb());
+    t.after(() => { db.close(); });
+    const setup = await db.exec(
+      'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER NOT NULL) STRICT;'
+    );
+    t.assert.strictEqual(setup, undefined);
+    const stmt = db.prepare('INSERT INTO data (key, val) VALUES (?, ?)');
+    await t.assert.rejects(async () => {
+      await stmt.run(1);
+    }, {
+      code: 'ERR_SQLITE_ERROR',
+      message: 'NOT NULL constraint failed: data.val',
+      errcode: 1299,
+      errstr: 'constraint failed',
+    });
+  });
+
+  test('returns correct metadata when using RETURNING', async (t) => {
+    const db = new Database(':memory:');
+    const setup = await db.exec(
+      'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER NOT NULL) STRICT;'
+    );
+    t.assert.strictEqual(setup, undefined);
+    const sql = 'INSERT INTO data (key, val) VALUES ($k, $v) RETURNING key';
+    const stmt = db.prepare(sql);
+    let r = await stmt.run({ k: 1, v: 10 });
+    t.assert.deepStrictEqual(r, { changes: 1, lastInsertRowid: 1 });
+
+    r = await stmt.run({ k: 2, v: 20 });
+    t.assert.deepStrictEqual(r, { changes: 1, lastInsertRowid: 2 });
+
+    r = await stmt.run({ k: 3, v: 30 });
+    t.assert.deepStrictEqual(r, { changes: 1, lastInsertRowid: 3 });
+  });
+});