diff --git a/.eslintrc.js b/.eslintrc.js index 2303c3d4..13e5647e 100644 --- a/.eslintrc.js +++ b/.eslintrc.js @@ -1,10 +1,12 @@ module.exports = { "extends": "eslint:recommended", "env": { - "es2017": true, + "es2018": true, "node": true }, "rules": { + "no-var": "error", + "prefer-const": "error", "indent": ["error", 4], "linebreak-style": ["error", "unix"], "semi": ["error", "always"], diff --git a/.gitignore b/.gitignore index 108a59ae..2a0aa3c1 100644 --- a/.gitignore +++ b/.gitignore @@ -30,3 +30,4 @@ setup.sh package-lock.json yarn.lock prebuilds +somefile diff --git a/lib/sqlite3.d.ts b/lib/sqlite3.d.ts index 6381872e..22af82ff 100644 --- a/lib/sqlite3.d.ts +++ b/lib/sqlite3.d.ts @@ -70,8 +70,9 @@ export interface RunResult extends Statement { } export class Statement extends events.EventEmitter { - lastID: number; - changes: number; + readonly lastID: number; + readonly changes: number; + readonly sql: string; static create(database: Database, sql: string): Promise; bind(): Promise; bind(...params: any[]): Promise; @@ -112,6 +113,8 @@ export class Database extends events.EventEmitter { serialize(callback?: () => Promise): Promise; parallelize(callback?: () => Promise): Promise; + map(sql: string, ...params: any[]): Promise>; + on(event: "trace", listener: (sql: string) => void): this; on(event: "profile", listener: (sql: string, time: number) => void): this; on(event: "change", listener: (type: string, database: string, table: string, rowid: number) => void): this; diff --git a/lib/sqlite3.js b/lib/sqlite3.js index 5f751b97..0e94c911 100644 --- a/lib/sqlite3.js +++ b/lib/sqlite3.js @@ -84,15 +84,23 @@ Database.prototype.all = normalizeMethod(function(statement, params) { }); // Database#each(sql, [bind1, bind2, ...], [complete]) -Database.prototype.each = normalizeMethod(function(statement, params) { +Database.prototype.each = normalizeMethod(async function*(statement, params) { // return statement.each.apply(statement, params).then(() => statement.finalize()); // TODO: maybe need to figure out how to finalize this statement at the end? - const r = statement.each(...params); - return r; + try { + for await (const row of statement.each(...params)) { + yield row; + } + } finally { + await statement.finalize(); + } + }); Database.prototype.map = normalizeMethod(function(statement, params) { - return statement.map.apply(statement, params).then(() => statement.finalize()); + return statement.map(...params) + .then((result) => statement.finalize() + .then(() => result)); }); Backup.create = async function(...args) { @@ -122,31 +130,27 @@ Statement.create = async function(database, sql) { return statement.prepare(); }; -Statement.prototype.map = function() { - const params = Array.prototype.slice.call(arguments); - const callback = params.pop(); - params.push(function(err, rows) { - if (err) return callback(err); - const result = {}; - if (rows.length) { - const keys = Object.keys(rows[0]); - const key = keys[0]; - if (keys.length > 2) { - // Value is an object - for (let i = 0; i < rows.length; i++) { - result[rows[i][key]] = rows[i]; - } - } else { - const value = keys[1]; - // Value is a plain value - for (let i = 0; i < rows.length; i++) { - result[rows[i][key]] = rows[i][value]; - } +Statement.prototype.map = async function(...args) { + const rows = await this.all(...args); + const result = {}; + if (rows.length) { + const keys = Object.keys(rows[0]); + const key = keys[0]; + if (keys.length > 2) { + // Value is an object + for (let i = 0; i < rows.length; i++) { + result[rows[i][key]] = rows[i]; + } + } else { + const value = keys[1]; + // Value is a plain value + for (let i = 0; i < rows.length; i++) { + result[rows[i][key]] = rows[i][value]; } } - callback(err, result); - }); - return this.all.apply(this, params); + } + + return result; }; let isVerbose = false; diff --git a/lib/trace.js b/lib/trace.js index 1d84cb01..b6895dc2 100644 --- a/lib/trace.js +++ b/lib/trace.js @@ -1,31 +1,23 @@ // Inspired by https://github.com/tlrobinson/long-stack-traces const util = require('util'); -function extendTrace(object, property, pos) { +function extendTrace(object, property) { const old = object[property]; - object[property] = function() { - const error = new Error(); - const name = object.constructor.name + '#' + property + '(' + - Array.prototype.slice.call(arguments).map(function(el) { - return util.inspect(el, false, 0); - }).join(', ') + ')'; - - if (typeof pos === 'undefined') pos = -1; - if (pos < 0) pos += arguments.length; - const cb = arguments[pos]; - if (typeof arguments[pos] === 'function') { - arguments[pos] = function replacement() { - const err = arguments[0]; - if (err && err.stack && !err.__augmented) { - err.stack = filter(err).join('\n'); - err.stack += '\n--> in ' + name; - err.stack += '\n' + filter(error).slice(1).join('\n'); - err.__augmented = true; - } - return cb.apply(this, arguments); - }; - } - return old.apply(this, arguments); + object[property] = function(...args) { + return old.apply(this, args).catch((err) => { + const error = new Error(); + const name = object.constructor.name + '#' + property + '(' + + Array.prototype.slice.call(arguments).map(function(el) { + return util.inspect(el, false, 0); + }).join(', ') + ')'; + if (err && err.stack && !err.__augmented) { + err.stack = filter(err).join('\n'); + err.stack += '\n--> in ' + name; + err.stack += '\n' + filter(error).slice(1).join('\n'); + err.__augmented = true; + } + throw err; + }); }; } exports.extendTrace = extendTrace; diff --git a/src/database.cc b/src/database.cc index d4cde921..a42d6bb4 100644 --- a/src/database.cc +++ b/src/database.cc @@ -86,7 +86,7 @@ void Database::Schedule(Work_Callback callback, Baton* baton, bool exclusive) { auto deferred = baton->deferred; // We don't call the actual callback, so we have to make sure that // the baton gets destroyed. - delete baton; + // delete baton; deferred.Reject(exception); return; } @@ -273,15 +273,26 @@ Napi::Value Database::Serialize(const Napi::CallbackInfo& info) { } auto promise = result.As(); - auto then = promise.Get("then").As(); - auto join_promise = [db, deferred, before](const Napi::CallbackInfo& info) { + auto thenFn = promise.Get("then").As(); + auto catchFn = promise.Get("catch").As(); + auto joinPromise = [db, deferred, before](const Napi::CallbackInfo& info) { auto result = info[0]; db->serialize = before; db->Process(); deferred.Resolve(result); }; - auto callback = Napi::Function::New(env, join_promise, "native_joinPromise"); - then.Call(promise, {callback}); + auto joinPromiseCatch = [db, deferred, before](const Napi::CallbackInfo& info) { + auto error = info[0]; + db->serialize = before; + db->Process(); + deferred.Reject(error); + }; + auto thenCallback = Napi::Function::New(env, joinPromise, "native_joinPromise"); + auto catchCallback = Napi::Function::New(env, joinPromiseCatch, "native_joinPromiseCatche"); + thenFn.Call(promise, {thenCallback}); + catchFn.Call(promise, {catchCallback}); + } else { + deferred.Resolve(env.Undefined()); } return deferred.Promise(); @@ -304,15 +315,26 @@ Napi::Value Database::Parallelize(const Napi::CallbackInfo& info) { } auto promise = result.As(); - auto then = promise.Get("then").As(); - auto join_promise = [db, deferred, before](const Napi::CallbackInfo& info) { + auto thenFn = promise.Get("then").As(); + auto catchFn = promise.Get("catch").As(); + auto joinPromise = [db, deferred, before](const Napi::CallbackInfo& info) { auto result = info[0]; db->serialize = before; db->Process(); deferred.Resolve(result); }; - auto callback = Napi::Function::New(env, join_promise, "native_joinPromise"); - then.Call(promise, {callback}); + auto joinPromiseCatch = [db, deferred, before](const Napi::CallbackInfo& info) { + auto error = info[0]; + db->serialize = before; + db->Process(); + deferred.Reject(error); + }; + auto thenCallback = Napi::Function::New(env, joinPromise, "native_joinPromise"); + auto catchCallback = Napi::Function::New(env, joinPromiseCatch, "native_joinPromiseCatche"); + thenFn.Call(promise, {thenCallback}); + catchFn.Call(promise, {catchCallback}); + } else { + deferred.Resolve(env.Undefined()); } return deferred.Promise(); diff --git a/src/statement.cc b/src/statement.cc index c3ecb3e9..136a9c03 100644 --- a/src/statement.cc +++ b/src/statement.cc @@ -79,7 +79,6 @@ template void Statement::Error(T* baton) { EXCEPTION(Napi::String::New(env, stmt->message.c_str()), stmt->status, exception); baton->deferred.Reject(exception); - return; } // { Database db, String sql, Array params, Function callback } @@ -436,7 +435,7 @@ void Statement::Work_AfterGet(napi_env e, napi_status status, void* data) { Napi::Value result = RowToJS(env, &baton->row); deferred.Resolve(result); } else { - deferred.Resolve(stmt->Value()); + deferred.Resolve(env.Undefined()); } } @@ -604,9 +603,14 @@ Napi::Value Statement::InitEachIterator(EachBaton* eachBaton) { result["value"] = RowToJS(env, row.get()); deferred.get()->Resolve(result); } else if (eachBaton->async->completed) { - auto result = Napi::Object::New(env); - result["done"] = Napi::Boolean::New(env, true); - deferred.get()->Resolve(result); + if (stmt->status != SQLITE_DONE) { + EXCEPTION(Napi::String::New(env, stmt->message.c_str()), stmt->status, exception); + deferred.get()->Reject(exception); + } else { + auto result = Napi::Object::New(env); + result["done"] = Napi::Boolean::New(env, true); + deferred.get()->Resolve(result); + } } else { eachBaton->async->deferreds.emplace_back(deferred); } @@ -656,7 +660,8 @@ void Statement::Work_Each(napi_env e, void* data) { sqlite3_reset(stmt->_handle); } - if (stmt->Bind(baton->parameters)) { + auto bound = stmt->Bind(baton->parameters); + if (bound) { while (true) { sqlite3_mutex_enter(mtx); stmt->status = sqlite3_step(stmt->_handle); @@ -712,9 +717,14 @@ void Statement::AsyncEach(uv_async_t* handle) { if (!async->deferreds.empty()) { auto deferred = std::move(async->deferreds.front()); async->deferreds.pop_front(); - auto result = Napi::Object::New(env); - result["done"] = Napi::Boolean::New(env, true); - deferred.get()->Resolve(result); + if (async->stmt->status != SQLITE_DONE) { + EXCEPTION(Napi::String::New(env, async->stmt->message.c_str()), async->stmt->status, exception); + deferred.get()->Reject(exception); + } else { + auto result = Napi::Object::New(env); + result["done"] = Napi::Boolean::New(env, true); + deferred.get()->Resolve(result); + } } uv_close(reinterpret_cast(handle), CloseCallback); } diff --git a/test/affected.test.js b/test/affected.test.js index bc65981e..8f40c6ee 100644 --- a/test/affected.test.js +++ b/test/affected.test.js @@ -5,12 +5,8 @@ describe('query properties', function() { /** @type {sqlite3.Database} */ let db; before(async function() { - console.log('before create'); db = await sqlite3.Database.create(':memory:'); - console.log('after create'); - console.log('before run'); await db.run("CREATE TABLE foo (id INT, txt TEXT)"); - console.log('after run'); }); it('should return the correct lastID', async function() { @@ -18,9 +14,7 @@ describe('query properties', function() { let j = 1; const promises = []; for (let i = 0; i < 5000; i++) { - console.log('enqueuing insert', i); promises.push(stmt.run(i, "demo").then((result) => { - console.log('insert', i, 'successful'); // Relies on SQLite's row numbering to be gapless and starting // from 1. assert.equal(j++, result.lastID); @@ -33,8 +27,7 @@ describe('query properties', function() { it('should return the correct changes count', async function() { const statement = await db.run("UPDATE foo SET id = id + 1 WHERE id % 2 = 0"); - const r = await db.all("SELECT * FROM foo"); - console.log(r); + await db.all("SELECT * FROM foo"); assert.equal(2500, statement.changes); }); }); diff --git a/test/async_calls.test.js b/test/async_calls.test.js index 41ece9c5..41eb75b7 100644 --- a/test/async_calls.test.js +++ b/test/async_calls.test.js @@ -1,6 +1,6 @@ "use strict"; -var sqlite3 = require('..'); +const sqlite3 = require('..'); const assert = require("assert"); const { createHook, executionAsyncId } = require("async_hooks"); diff --git a/test/blob.test.js b/test/blob.test.js index 26564c6f..8e1e3112 100644 --- a/test/blob.test.js +++ b/test/blob.test.js @@ -1,10 +1,10 @@ -var sqlite3 = require('..'), +const sqlite3 = require('..'), fs = require('fs'), assert = require('assert'), Buffer = require('buffer').Buffer; // lots of elmo -var elmo = fs.readFileSync(__dirname + '/support/elmo.png'); +const elmo = fs.readFileSync(__dirname + '/support/elmo.png'); describe('blob', function() { /** @type {sqlite3.Database} */ @@ -39,7 +39,7 @@ describe('blob', function() { assert.ok(Buffer.isBuffer(rows[i].image)); assert.ok(elmo.length, rows[i].image); - for (var j = 0; j < elmo.length; j++) { + for (let j = 0; j < elmo.length; j++) { if (elmo[j] !== rows[i].image[j]) { assert.ok(false, "Wrong byte"); } diff --git a/test/cache.test.js b/test/cache.test.js index 0af93043..4e1e358c 100644 --- a/test/cache.test.js +++ b/test/cache.test.js @@ -1,6 +1,6 @@ -var sqlite3 = require('..'); -var assert = require('assert'); -var helper = require('./support/helper'); +const sqlite3 = require('..'); +const assert = require('assert'); +const helper = require('./support/helper'); describe('cache', function() { before(function() { @@ -17,7 +17,7 @@ describe('cache', function() { // TODO: Does this still make sense? Is this correctly implemented now? it('should cache Database objects after they are open', function(done) { - var filename = 'test/tmp/test_cache2.db'; + const filename = 'test/tmp/test_cache2.db'; helper.deleteFile(filename); sqlite3.cached.Database.create(filename).then((db1) => { process.nextTick(function() { diff --git a/test/constants.test.js b/test/constants.test.js index 7e1affdd..c56782e6 100644 --- a/test/constants.test.js +++ b/test/constants.test.js @@ -1,5 +1,5 @@ -var sqlite3 = require('..'); -var assert = require('assert'); +const sqlite3 = require('..'); +const assert = require('assert'); describe('constants', function() { it('should have the right OPEN_* flags', function() { diff --git a/test/database_fail.test.js b/test/database_fail.test.js index 83a0d5b9..084f153e 100644 --- a/test/database_fail.test.js +++ b/test/database_fail.test.js @@ -1,5 +1,5 @@ -var sqlite3 = require('..'); -var assert = require('assert'); +const sqlite3 = require('..'); +const assert = require('assert'); describe('error handling', function() { /** @type {sqlite3.Database} */ @@ -10,10 +10,12 @@ describe('error handling', function() { it('throw when calling Database() without new', function() { assert.throws(function() { + // @ts-expect-error Calling private constructor for test sqlite3.Database(':memory:'); }, (/Class constructors cannot be invoked without 'new'/)); assert.throws(function() { + // @ts-expect-error Calling private constructor for test sqlite3.Statement(); }, (/Class constructors cannot be invoked without 'new'/)); }); @@ -52,32 +54,21 @@ describe('error handling', function() { new Error('Completed query without error, but expected error'); }); - // TODO: DB.each - it.skip('Database#each prepare fail', function() { - db.each('SELECT id, txt FROM foo', function(err, row) { - assert.ok(false, "this should not be called"); - }, function(err, num) { - if (err) { - assert.equal(err.message, 'SQLITE_ERROR: no such table: foo'); - assert.equal(err.errno, sqlite3.ERROR); - assert.equal(err.code, 'SQLITE_ERROR'); - done(); - } else { - done(new Error('Completed query without error, but expected error')); - } + it('Database#each prepare fail', async function() { + await assert.rejects(db.each('SELECT id, text FROM foo'), (err) => { + assert.equal(err.message, 'SQLITE_ERROR: no such table: foo'); + assert.equal(err.errno, sqlite3.ERROR); + assert.equal(err.code, 'SQLITE_ERROR'); + return true; }); }); - it.skip('Database#each prepare fail without completion handler', function() { - db.each('SELECT id, txt FROM foo', function(err, row) { - if (err) { - assert.equal(err.message, 'SQLITE_ERROR: no such table: foo'); - assert.equal(err.errno, sqlite3.ERROR); - assert.equal(err.code, 'SQLITE_ERROR'); - done(); - } else { - done(new Error('Completed query without error, but expected error')); - } + it('Database#each prepare fail without completion handler', async function() { + await assert.rejects(db.each('SELECT id, txt FROM foo'), (err) => { + assert.equal(err.message, 'SQLITE_ERROR: no such table: foo'); + assert.equal(err.errno, sqlite3.ERROR); + assert.equal(err.code, 'SQLITE_ERROR'); + return true; }); }); @@ -114,31 +105,25 @@ describe('error handling', function() { new Error('Completed query without error, but expected error'); }); - it.skip('Database#each prepare fail with param binding', function() { - db.each('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) { - assert.ok(false, "this should not be called"); - }, function(err, num) { - if (err) { - assert.equal(err.message, 'SQLITE_ERROR: no such table: foo'); - assert.equal(err.errno, sqlite3.ERROR); - assert.equal(err.code, 'SQLITE_ERROR'); - done(); - } else { - done(new Error('Completed query without error, but expected error')); - } + it('Database#each prepare fail with param binding', async function() { + await assert.rejects(db.each('SELECT id, txt FROM foo WHERE id = ?', 1), (err) => { + assert.equal(err.message, 'SQLITE_ERROR: no such table: foo'); + assert.equal(err.errno, sqlite3.ERROR); + assert.equal(err.code, 'SQLITE_ERROR'); + return true; }); }); - it.skip('Database#each prepare fail with param binding without completion handler', function() { - db.each('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) { - if (err) { - assert.equal(err.message, 'SQLITE_ERROR: no such table: foo'); - assert.equal(err.errno, sqlite3.ERROR); - assert.equal(err.code, 'SQLITE_ERROR'); - done(); - } else { - done(new Error('Completed query without error, but expected error')); - } + it('Database#each prepare fail with param binding without completion handler', async function() { + assert.rejects(db.each('SELECT id, txt FROM foo WHERE id = ?', 1), (err) => { + assert.equal(err.message, 'SQLITE_ERROR: no such table: foo'); + assert.equal(err.errno, sqlite3.ERROR); + assert.equal(err.code, 'SQLITE_ERROR'); + return true; }); }); + + after(async function() { + await db.close(); + }); }); diff --git a/test/each.test.js b/test/each.test.js index 9f2b0301..541a0b55 100644 --- a/test/each.test.js +++ b/test/each.test.js @@ -1,5 +1,5 @@ -var sqlite3 = require('..'); -var assert = require('assert'); +const sqlite3 = require('..'); +const assert = require('assert'); describe('each', function() { /** @type {sqlite3.Database} */ @@ -9,28 +9,24 @@ describe('each', function() { }); it('retrieve 100,000 rows with Statement#each', async function() { - var total = 100000; + const total = 100000; // var total = 10; - var retrieved = 0; + let retrieved = 0; - const iterable = await db.each('SELECT id, txt FROM foo LIMIT 0, ?', total) - for await (const row of iterable) { - retrieved++ + const iterable = await db.each('SELECT id, txt FROM foo LIMIT 0, ?', total); + for await (const _row of iterable) { + retrieved++; } assert.equal(retrieved, total, "Only retrieved " + retrieved + " out of " + total + " rows."); }); + + it('Statement#each with complete callback', async function() { + const total = 10000; + let retrieved = 0; - it.skip('Statement#each with complete callback', function(done) { - var total = 10000; - var retrieved = 0; - - db.each('SELECT id, txt FROM foo LIMIT 0, ?', total, function(err, row) { - if (err) throw err; + for await (const _row of await db.each('SELECT id, txt FROM foo LIMIT 0, ?', total)) { retrieved++; - }, function(err, num) { - assert.equal(retrieved, num); - assert.equal(retrieved, total, "Only retrieved " + retrieved + " out of " + total + " rows."); - done(); - }); + } + assert.equal(retrieved, total, "Only retrieved " + retrieved + " out of " + total + " rows."); }); }); diff --git a/test/exec.test.js b/test/exec.test.js index b42ce22f..cb1d2fed 100644 --- a/test/exec.test.js +++ b/test/exec.test.js @@ -1,6 +1,6 @@ -var sqlite3 = require('..'); -var assert = require('assert'); -var fs = require('fs'); +const sqlite3 = require('..'); +const assert = require('assert'); +const fs = require('fs'); describe('exec', function() { /** @type {sqlite3.Database} */ @@ -10,7 +10,7 @@ describe('exec', function() { }); it('Database#exec', async function() { - var sql = fs.readFileSync('test/support/script.sql', 'utf8'); + const sql = fs.readFileSync('test/support/script.sql', 'utf8'); await db.exec(sql); }); diff --git a/test/extension.test.js b/test/extension.test.js index 36c350fa..59033258 100644 --- a/test/extension.test.js +++ b/test/extension.test.js @@ -1,6 +1,6 @@ -var sqlite3 = require('..'); -var assert = require('assert'); -var exists = require('fs').existsSync || require('path').existsSync; +// let sqlite3 = require('..'); +// let assert = require('assert'); +// let exists = require('fs').existsSync || require('path').existsSync; /* @@ -23,4 +23,4 @@ describe('loadExtension', function(done) { } }); -*/ \ No newline at end of file +*/ diff --git a/test/fts-content.test.js b/test/fts-content.test.js index 3b0302fa..39a99707 100644 --- a/test/fts-content.test.js +++ b/test/fts-content.test.js @@ -1,4 +1,4 @@ -var sqlite3 = require('..'); +const sqlite3 = require('..'); describe('fts', function() { /** @type {sqlite3.Database} */ diff --git a/test/interrupt.test.js b/test/interrupt.test.js index e0ecf460..5ca531ba 100644 --- a/test/interrupt.test.js +++ b/test/interrupt.test.js @@ -1,74 +1,70 @@ -var sqlite3 = require('..'); -var assert = require('assert'); +const sqlite3 = require('..'); +const assert = require('assert'); describe('interrupt', function() { - // TODO: each - it.skip('should interrupt queries', async function() { + it('should interrupt queries', async function() { let interrupted = false; let saved = null; const db = await sqlite3.Database.create(':memory:'); - await db.serialize(); - - var setup = 'create table t (n int);'; - for (var i = 0; i < 8; i += 1) { - setup += 'insert into t values (' + i + ');'; - } - - await db.exec(setup); - - const query = 'select last.n ' + - 'from t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t as last'; - - db.each(query, function(err) { - if (err) { + await db.serialize(async () => { + + let setup = 'create table t (n int);'; + for (let i = 0; i < 8; i += 1) { + setup += 'insert into t values (' + i + ');'; + } + + await db.exec(setup); + + const query = 'select last.n ' + + 'from t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t as last'; + + try { + for await (const _row of await db.each(query)) { + if (!interrupted) { + interrupted = true; + db.interrupt(); + } + } + } catch (err) { saved = err; - } else if (!interrupted) { - interrupted = true; - db.interrupt(); + } finally { + await db.close(); } - }); - - await db.close(); - - if (saved) { + + if (!saved) throw new Error('Completed query without error, but expected error'); assert.equal(saved.message, 'SQLITE_INTERRUPT: interrupted'); assert.equal(saved.errno, sqlite3.INTERRUPT); assert.equal(saved.code, 'SQLITE_INTERRUPT'); - } - new Error('Completed query without error, but expected error'); + }); + }); - it('should throw if interrupt is called before open', function(done) { - var db = new sqlite3.Database(':memory:'); + it('should throw if interrupt is called before open', async function() { + // @ts-expect-error Calling private constructor for testing + const db = new sqlite3.Database(':memory:'); assert.throws(function() { db.interrupt(); }, (/Database is not open/)); - - db.close(); - done(); }); - it('should throw if interrupt is called after close', function(done) { - var db = new sqlite3.Database(':memory:'); + it('should throw if interrupt is called after close', async function() { + const db = await sqlite3.Database.create(':memory:'); - db.close(function() { - assert.throws(function() { - db.interrupt(); - }, (/Database is not open/)); + await db.close(); - done(); - }); + assert.throws(function() { + db.interrupt(); + }, (/Database is not open/)); }); - it('should throw if interrupt is called during close', function(done) { - var db = new sqlite3.Database(':memory:', function() { - db.close(); - assert.throws(function() { - db.interrupt(); - }, (/Database is closing/)); - done(); - }); + it('should throw if interrupt is called during close', async function() { + const db = await sqlite3.Database.create(':memory:'); + db.close(); + + assert.throws(function() { + db.interrupt(); + }, (/Database is closing/)); }); }); diff --git a/test/issue-108.test.js b/test/issue-108.test.js index 99343782..adddd600 100644 --- a/test/issue-108.test.js +++ b/test/issue-108.test.js @@ -1,28 +1,23 @@ -var sqlite3 = require('..'), - assert = require('assert'); +const sqlite3 = require('..'); describe('buffer', function() { - var db; + /** @type {sqlite3.Database} */ + let db; // before(function() { // }); - it('should insert blobs', function(done) { - db = new sqlite3.Database(':memory:'); - db.serialize(function () { + it('should insert blobs', async function() { + db = await sqlite3.Database.create(':memory:'); + await db.serialize(async function () { - db.run("CREATE TABLE lorem (info BLOB)"); - var stmt = db.prepare("INSERT INTO lorem VALUES (?)"); + await db.run("CREATE TABLE lorem (info BLOB)"); + const stmt = await db.prepare("INSERT INTO lorem VALUES (?)"); - stmt.on('error', function (err) { - throw err; - }); - - var buff = Buffer.alloc(2); - stmt.run(buff); - stmt.finalize(); + const buff = Buffer.alloc(2); + await stmt.run(buff); + await stmt.finalize(); }); - db.close(done); - + await db.close(); }); }); diff --git a/test/json.test.js b/test/json.test.js index 6d7d32da..44d8c15a 100644 --- a/test/json.test.js +++ b/test/json.test.js @@ -1,4 +1,4 @@ -var sqlite3 = require('..'); +const sqlite3 = require('..'); if( process.env.NODE_SQLITE3_JSON1 === 'no' ){ describe('json', function() { @@ -9,14 +9,15 @@ if( process.env.NODE_SQLITE3_JSON1 === 'no' ){ }); } else { describe('json', function() { - var db; + /** @type {sqlite3.Database} */ + let db; - before(function(done) { - db = new sqlite3.Database(':memory:', done); + before(async function() { + db = await sqlite3.Database.create(':memory:'); }); - it('should select JSON', function(done) { - db.run('SELECT json(?)', JSON.stringify({ok:true}), done); + it('should select JSON', async function() { + await db.run('SELECT json(?)', JSON.stringify({ok:true})); }); }); } diff --git a/test/limit.test.js b/test/limit.test.js index d79f2c8d..b1cca6f9 100644 --- a/test/limit.test.js +++ b/test/limit.test.js @@ -1,28 +1,32 @@ -var sqlite3 = require('..'); +const sqlite3 = require('..'); +const assert = require('node:assert'); describe('limit', function() { - var db; + /** @type {sqlite3.Database} */ + let db; - before(function(done) { - db = new sqlite3.Database(':memory:', done); + before(async function() { + db = await sqlite3.Database.create(':memory:'); }); - it('should support applying limits via configure', function(done) { + it('should support applying limits via configure', async function() { db.configure('limit', sqlite3.LIMIT_ATTACHED, 0); - db.exec("ATTACH 'test/support/prepare.db' AS zing", function(err) { - if (!err) { - throw new Error('ATTACH should not succeed'); - } - if (err.errno === sqlite3.ERROR && - err.message === 'SQLITE_ERROR: too many attached databases - max 0') { - db.configure('limit', sqlite3.LIMIT_ATTACHED, 1); - db.exec("ATTACH 'test/support/prepare.db' AS zing", function(err) { - if (err) throw err; - db.close(done); - }); - } else { - throw err; - } - }); + let caught; + try { + await db.exec("ATTACH 'test/support/prepare.db' AS zing"); + } catch (err) { + caught = err; + } + + if (!caught) { + await db.close(); + throw new Error('ATTACH should not succeed'); + } + + assert.strictEqual(caught.errno, sqlite3.ERROR); + assert.strictEqual(caught.message, 'SQLITE_ERROR: too many attached databases - max 0'); + db.configure('limit', sqlite3.LIMIT_ATTACHED, 1); + await db.exec("ATTACH 'test/support/prepare.db' AS zing"); + await db.close(); }); }); diff --git a/test/map.test.js b/test/map.test.js index db190a7c..cb0d37a0 100644 --- a/test/map.test.js +++ b/test/map.test.js @@ -1,63 +1,53 @@ -var sqlite3 = require('..'); -var assert = require('assert'); +const sqlite3 = require('..'); +const assert = require('assert'); describe('map', function() { - it('test Database#map() with two columns', function(done) { - var count = 10; - var inserted = 0; - - var db = new sqlite3.Database(':memory:'); - db.serialize(function() { - db.run("CREATE TABLE foo (id INT, value TEXT)"); - - var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)"); - for (var i = 5; i < count; i++) { - stmt.run(i, 'Value for ' + i, function(err) { - if (err) throw err; - inserted++; - }); + it('test Database#map() with two columns', async function() { + const count = 10; + let inserted = 0; + + const db = await sqlite3.Database.create(':memory:'); + await db.serialize(async function() { + await db.run("CREATE TABLE foo (id INT, value TEXT)"); + + const stmt = await db.prepare("INSERT INTO foo VALUES(?, ?)"); + for (let i = 5; i < count; i++) { + await stmt.run(i, 'Value for ' + i); + inserted++; } - stmt.finalize(); + await stmt.finalize(); - db.map("SELECT * FROM foo", function(err, map) { - if (err) throw err; - assert.deepEqual(map, { 5: 'Value for 5', 6: 'Value for 6', 7: 'Value for 7', 8: 'Value for 8', 9: 'Value for 9' }); - assert.equal(inserted, 5); - done(); - }); + const results = await db.map("SELECT * FROM foo"); + assert.deepEqual(results, { 5: 'Value for 5', 6: 'Value for 6', 7: 'Value for 7', 8: 'Value for 8', 9: 'Value for 9' }); + assert.equal(inserted, 5); }); }); - it('test Database#map() with three columns', function(done) { - var db = new sqlite3.Database(':memory:'); + it('test Database#map() with three columns', async function() { + const db = await sqlite3.Database.create(':memory:'); - var count = 10; - var inserted = 0; + const count = 10; + let inserted = 0; - db.serialize(function() { - db.run("CREATE TABLE foo (id INT, value TEXT, other TEXT)"); + await db.serialize(async function() { + await db.run("CREATE TABLE foo (id INT, value TEXT, other TEXT)"); - var stmt = db.prepare("INSERT INTO foo VALUES(?, ?, ?)"); - for (var i = 5; i < count; i++) { - stmt.run(i, 'Value for ' + i, null, function(err) { - if (err) throw err; - inserted++; - }); + const stmt = await db.prepare("INSERT INTO foo VALUES(?, ?, ?)"); + for (let i = 5; i < count; i++) { + await stmt.run(i, 'Value for ' + i); + inserted++; } - stmt.finalize(); - - db.map("SELECT * FROM foo", function(err, map) { - if (err) throw err; - assert.deepEqual(map, { - 5: { id: 5, value: 'Value for 5', other: null }, - 6: { id: 6, value: 'Value for 6', other: null }, - 7: { id: 7, value: 'Value for 7', other: null }, - 8: { id: 8, value: 'Value for 8', other: null }, - 9: { id: 9, value: 'Value for 9', other: null } - }); - assert.equal(inserted, 5); - done(); + await stmt.finalize(); + + const results = await db.map("SELECT * FROM foo"); + assert.deepEqual(results, { + 5: { id: 5, value: 'Value for 5', other: null }, + 6: { id: 6, value: 'Value for 6', other: null }, + 7: { id: 7, value: 'Value for 7', other: null }, + 8: { id: 8, value: 'Value for 8', other: null }, + 9: { id: 9, value: 'Value for 9', other: null } }); + assert.equal(inserted, 5); }); }); }); diff --git a/test/named_columns.test.js b/test/named_columns.test.js index 9973bfce..f97b5c02 100644 --- a/test/named_columns.test.js +++ b/test/named_columns.test.js @@ -1,38 +1,36 @@ -var sqlite3 = require('..'); -var assert = require('assert'); +const sqlite3 = require('..'); +const assert = require('assert'); describe('named columns', function() { - var db; - before(function(done) { - db = new sqlite3.Database(':memory:', done); + /** @type {sqlite3.Database} */ + let db; + before(async function() { + db = await sqlite3.Database.create(':memory:'); }); - it('should create the table', function(done) { - db.run("CREATE TABLE foo (txt TEXT, num INT)", done); + it('should create the table', async function() { + await db.run("CREATE TABLE foo (txt TEXT, num INT)"); }); - it('should insert a value', function(done) { - db.run("INSERT INTO foo VALUES($text, $id)", { + it('should insert a value', async function() { + await db.run("INSERT INTO foo VALUES($text, $id)", { $id: 1, $text: "Lorem Ipsum" - }, done); + }); }); - it('should retrieve the values', function(done) { - db.get("SELECT txt, num FROM foo ORDER BY num", function(err, row) { - if (err) throw err; - assert.equal(row.txt, "Lorem Ipsum"); - assert.equal(row.num, 1); - done(); - }); + it('should retrieve the values', async function() { + const row = await db.get("SELECT txt, num FROM foo ORDER BY num"); + assert.equal(row.txt, "Lorem Ipsum"); + assert.equal(row.num, 1); }); - it('should be able to retrieve rowid of last inserted value', function(done) { - db.get("SELECT last_insert_rowid() as last_id FROM foo", function(err, row) { - if (err) throw err; - assert.equal(row.last_id, 1); - done(); - }); + it('should be able to retrieve rowid of last inserted value', async function() { + const row = await db.get("SELECT last_insert_rowid() as last_id FROM foo"); + assert.equal(row.last_id, 1); }); + after(async function() { + await db.close(); + }); }); diff --git a/test/named_params.test.js b/test/named_params.test.js index c03f2dd7..e4caf849 100644 --- a/test/named_params.test.js +++ b/test/named_params.test.js @@ -1,69 +1,71 @@ -var sqlite3 = require('..'); -var assert = require('assert'); +const sqlite3 = require('..'); +const assert = require('assert'); describe('named parameters', function() { - var db; - before(function(done) { - db = new sqlite3.Database(':memory:', done); + /** @type {sqlite3.Database} */ + let db; + before(async function() { + db = await sqlite3.Database.create(':memory:'); }); - it('should create the table', function(done) { - db.run("CREATE TABLE foo (txt TEXT, num INT)", done); + it('should create the table', async function() { + await db.run("CREATE TABLE foo (txt TEXT, num INT)"); }); - it('should insert a value with $ placeholders', function(done) { - db.run("INSERT INTO foo VALUES($text, $id)", { + it('should insert a value with $ placeholders', async function() { + await db.run("INSERT INTO foo VALUES($text, $id)", { $id: 1, $text: "Lorem Ipsum" - }, done); + }); }); - it('should insert a value with : placeholders', function(done) { - db.run("INSERT INTO foo VALUES(:text, :id)", { + it('should insert a value with : placeholders', async function() { + await db.run("INSERT INTO foo VALUES(:text, :id)", { ':id': 2, ':text': "Dolor Sit Amet" - }, done); + }); }); - it('should insert a value with @ placeholders', function(done) { - db.run("INSERT INTO foo VALUES(@txt, @id)", { + it('should insert a value with @ placeholders', async function() { + await db.run("INSERT INTO foo VALUES(@txt, @id)", { "@id": 3, "@txt": "Consectetur Adipiscing Elit" - }, done); + }); }); - it('should insert a value with @ placeholders using an array', function(done) { - db.run("INSERT INTO foo VALUES(@txt, @id)", [ 'Sed Do Eiusmod', 4 ], done); + it('should insert a value with @ placeholders using an array', async function() { + await db.run("INSERT INTO foo VALUES(@txt, @id)", [ 'Sed Do Eiusmod', 4 ]); }); - it('should insert a value with indexed placeholders', function(done) { - db.run("INSERT INTO foo VALUES(?2, ?4)", - [ null, 'Tempor Incididunt', null, 5 ], done); + it('should insert a value with indexed placeholders', async function() { + await db.run("INSERT INTO foo VALUES(?2, ?4)", + [ null, 'Tempor Incididunt', null, 5 ]); }); - it('should insert a value with autoindexed placeholders', function(done) { - db.run("INSERT INTO foo VALUES(?, ?)", { + it('should insert a value with autoindexed placeholders', async function() { + await db.run("INSERT INTO foo VALUES(?, ?)", { 2: 6, 1: "Ut Labore Et Dolore" - }, done); + }); }); - it('should retrieve all inserted values', function(done) { - db.all("SELECT txt, num FROM foo ORDER BY num", function(err, rows) { - if (err) throw err; - assert.equal(rows[0].txt, "Lorem Ipsum"); - assert.equal(rows[0].num, 1); - assert.equal(rows[1].txt, "Dolor Sit Amet"); - assert.equal(rows[1].num, 2); - assert.equal(rows[2].txt, "Consectetur Adipiscing Elit"); - assert.equal(rows[2].num, 3); - assert.equal(rows[3].txt, "Sed Do Eiusmod"); - assert.equal(rows[3].num, 4); - assert.equal(rows[4].txt, "Tempor Incididunt"); - assert.equal(rows[4].num, 5); - assert.equal(rows[5].txt, "Ut Labore Et Dolore"); - assert.equal(rows[5].num, 6); - done(); - }); + it('should retrieve all inserted values', async function() { + const rows = await db.all("SELECT txt, num FROM foo ORDER BY num"); + assert.equal(rows[0].txt, "Lorem Ipsum"); + assert.equal(rows[0].num, 1); + assert.equal(rows[1].txt, "Dolor Sit Amet"); + assert.equal(rows[1].num, 2); + assert.equal(rows[2].txt, "Consectetur Adipiscing Elit"); + assert.equal(rows[2].num, 3); + assert.equal(rows[3].txt, "Sed Do Eiusmod"); + assert.equal(rows[3].num, 4); + assert.equal(rows[4].txt, "Tempor Incididunt"); + assert.equal(rows[4].num, 5); + assert.equal(rows[5].txt, "Ut Labore Et Dolore"); + assert.equal(rows[5].num, 6); + }); + + after(async function() { + await db.close(); }); }); diff --git a/test/null_error.test.js b/test/null_error.test.js index 8c34d9bf..db8a8d7c 100644 --- a/test/null_error.test.js +++ b/test/null_error.test.js @@ -1,40 +1,32 @@ -var sqlite3 = require('..'); -var assert = require('assert'); -var helper = require('./support/helper'); +const sqlite3 = require('..'); +const helper = require('./support/helper'); describe('null error', function() { - var filename = 'test/tmp/test_sqlite_ok_error.db'; - var db; + const filename = 'test/tmp/test_sqlite_ok_error.db'; + /** @type {sqlite3.Database} */ + let db; - before(function(done) { + before(async function() { helper.ensureExists('test/tmp'); helper.deleteFile(filename); - db = new sqlite3.Database(filename, done); + db = await sqlite3.Database.create(filename); }); - - it('should create a table', function(done) { - db.run("CREATE TABLE febp_data (leacode TEXT, leaname TEXT, state TEXT, postcode TEXT, fips TEXT, titleistim TEXT, ideastim TEXT, ideapool TEXT, ideapoolname TEXT, localebasis TEXT, localetype2 TEXT, version TEXT, leacount_2006 TEXT, ppexpend_2005 TEXT, ppexpend_2006 TEXT, ppexpend_2007 TEXT, ppexpend_2008 TEXT, ppexpendrank_2006 TEXT, ppexpendrank_2007 TEXT, ppexpendrank_2008 TEXT, rankppexpend_2005 TEXT, opbud_2004 TEXT, opbud_2006 TEXT, opbud_2007 TEXT, opbud_2008 TEXT, titlei_2004 TEXT, titlei_2006 TEXT, titlei_2007 TEXT, titlei_2008 TEXT, titlei_2009 TEXT, titlei_2010 TEXT, idea_2004 TEXT, idea_2005 TEXT, idea_2006 TEXT, idea_2007 TEXT, idea_2008 TEXT, idea_2009 TEXT, ideaest_2010 TEXT, impact_2007 TEXT, impact_2008 TEXT, impact_2009 TEXT, impact_2010 TEXT, fedrev_2006 TEXT, fedrev_2007 TEXT, fedrev_2008 TEXT, schonut_2006 TEXT, schonut_2007 TEXT, schomeal_2006 TEXT, schomeal_2007 TEXT, schoco_2006 TEXT, schocom_2007 TEXT, medicaid_2006 TEXT, medicaid_2007 TEXT, medicaid_2008 TEXT, cenpov_2004 TEXT, cenpov_2007 TEXT, cenpov_2008 TEXT, rankcenpov_2004 TEXT, rankcenpov_2007 TEXT, rankcenpov_2008 TEXT, enroll_2006 TEXT, enroll_2007 TEXT, enroll_2008 TEXT, white_2006 TEXT, white_2007 TEXT, white_2008 TEXT, afam_2006 TEXT, afam_2007 TEXT, afam_2008 TEXT, amin_2006 TEXT, amin_2007 TEXT, amin_2008 TEXT, asian_2006 TEXT, asian_2007 TEXT, asian_2008 TEXT, hisp_2006 TEXT, hisp_2007 TEXT, hisp_2008 TEXT, frpl_2006 TEXT, frpl_2007 TEXT, frpl_2008 TEXT, ell_2006 TEXT, ell_2007 TEXT, ell_2008 TEXT, sped_2006 TEXT, sped_2007 TEXT, sped_2008 TEXT, state4read_2005 TEXT, state4read_2006 TEXT, state4read_2007 TEXT, state4read_2008 TEXT, state4read_2009 TEXT, state4math_2005 TEXT, state4math_2006 TEXT, state4math_2007 TEXT, state4math_2008 TEXT, state4math_2009 TEXT, minor_2007 TEXT, minor_2008 TEXT, state8math_2006 TEXT, state8math_2007 TEXT, state8math_2008 TEXT, state8math_2009 TEXT, state8read_2006 TEXT, state8read_2007 TEXT, state8read_2008 TEXT, state8read_2009 TEXT, statehsmath_2006 TEXT, statehsmath_2007 TEXT, statehsmath_2008 TEXT, statehsmath_2009 TEXT, statehsread_2006 TEXT, statehsread_2007 TEXT, statehsread_2008 TEXT, statehsread_2009 TEXT)", done); - }); - - it('should insert rows with lots of null values', function(done) { - var stmt = db.prepare('INSERT INTO febp_data VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', function(err) { + + it('should insert rows with lots of null values', async function() { + await db.run("CREATE TABLE febp_data (leacode TEXT, leaname TEXT, state TEXT, postcode TEXT, fips TEXT, titleistim TEXT, ideastim TEXT, ideapool TEXT, ideapoolname TEXT, localebasis TEXT, localetype2 TEXT, version TEXT, leacount_2006 TEXT, ppexpend_2005 TEXT, ppexpend_2006 TEXT, ppexpend_2007 TEXT, ppexpend_2008 TEXT, ppexpendrank_2006 TEXT, ppexpendrank_2007 TEXT, ppexpendrank_2008 TEXT, rankppexpend_2005 TEXT, opbud_2004 TEXT, opbud_2006 TEXT, opbud_2007 TEXT, opbud_2008 TEXT, titlei_2004 TEXT, titlei_2006 TEXT, titlei_2007 TEXT, titlei_2008 TEXT, titlei_2009 TEXT, titlei_2010 TEXT, idea_2004 TEXT, idea_2005 TEXT, idea_2006 TEXT, idea_2007 TEXT, idea_2008 TEXT, idea_2009 TEXT, ideaest_2010 TEXT, impact_2007 TEXT, impact_2008 TEXT, impact_2009 TEXT, impact_2010 TEXT, fedrev_2006 TEXT, fedrev_2007 TEXT, fedrev_2008 TEXT, schonut_2006 TEXT, schonut_2007 TEXT, schomeal_2006 TEXT, schomeal_2007 TEXT, schoco_2006 TEXT, schocom_2007 TEXT, medicaid_2006 TEXT, medicaid_2007 TEXT, medicaid_2008 TEXT, cenpov_2004 TEXT, cenpov_2007 TEXT, cenpov_2008 TEXT, rankcenpov_2004 TEXT, rankcenpov_2007 TEXT, rankcenpov_2008 TEXT, enroll_2006 TEXT, enroll_2007 TEXT, enroll_2008 TEXT, white_2006 TEXT, white_2007 TEXT, white_2008 TEXT, afam_2006 TEXT, afam_2007 TEXT, afam_2008 TEXT, amin_2006 TEXT, amin_2007 TEXT, amin_2008 TEXT, asian_2006 TEXT, asian_2007 TEXT, asian_2008 TEXT, hisp_2006 TEXT, hisp_2007 TEXT, hisp_2008 TEXT, frpl_2006 TEXT, frpl_2007 TEXT, frpl_2008 TEXT, ell_2006 TEXT, ell_2007 TEXT, ell_2008 TEXT, sped_2006 TEXT, sped_2007 TEXT, sped_2008 TEXT, state4read_2005 TEXT, state4read_2006 TEXT, state4read_2007 TEXT, state4read_2008 TEXT, state4read_2009 TEXT, state4math_2005 TEXT, state4math_2006 TEXT, state4math_2007 TEXT, state4math_2008 TEXT, state4math_2009 TEXT, minor_2007 TEXT, minor_2008 TEXT, state8math_2006 TEXT, state8math_2007 TEXT, state8math_2008 TEXT, state8math_2009 TEXT, state8read_2006 TEXT, state8read_2007 TEXT, state8read_2008 TEXT, state8read_2009 TEXT, statehsmath_2006 TEXT, statehsmath_2007 TEXT, statehsmath_2008 TEXT, statehsmath_2009 TEXT, statehsread_2006 TEXT, statehsread_2007 TEXT, statehsread_2008 TEXT, statehsread_2009 TEXT)"); + const stmt = await db.prepare('INSERT INTO febp_data VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', function(err) { if (err) throw err; - for (var i = 0; i < 100; i++) { - stmt.run([ '100005', 'Albertville City School District', 'ALABAMA', 'AL', '1', '856031', '753000', 'NULL', 'NULL', '6-Small Town', 'Town', 21, '130', '6624', '7140', '8731', '8520', '102', '88', '100', '94', '23352000', '27280000', '30106000', '33028000', '768478', '845886', '782696', '1096819', '1279663', '1168521', '561522', '657649', '684366', '687531', '710543', '727276', '726647', 'N/A', 'N/A', 'N/A', 'N/A', '986', '977', '1006', '1080250', '1202325', '1009962', '1109310', '70287', '93015', '14693.56', '13634.58', 'N/A', '0.230', '0.301', '0.268882175', '73', '26', '29', '3718', '3747', '3790', '2663', '2615', '2575', '75', '82', '89', '3', '2', '6', '11', '9', '8', '955', '1028', '1102', '1991', '2061', '2146', '649', '729', '770', '443', '278', '267', '0.860', '0.86', '0.8474', '0.84', '0.8235', '0.810', '0.84', '0.7729', '0.75', '0.7843', '1121', '1205', '0.74', '0.6862', '0.72', '0.7317', '0.78', '0.7766', '0.79', '0.7387', '0.84', '0.9255', '0.86', '0.9302', '0.88', '0.9308', '0.84', '0.8605' ]); - } - - stmt.finalize(function(err) { - if (err) throw err; - done(); - }); }); - }); - it('should have created the database', function() { - assert.fileExists(filename); + for (let i = 0; i < 100; i++) { + await stmt.run([ '100005', 'Albertville City School District', 'ALABAMA', 'AL', '1', '856031', '753000', 'NULL', 'NULL', '6-Small Town', 'Town', 21, '130', '6624', '7140', '8731', '8520', '102', '88', '100', '94', '23352000', '27280000', '30106000', '33028000', '768478', '845886', '782696', '1096819', '1279663', '1168521', '561522', '657649', '684366', '687531', '710543', '727276', '726647', 'N/A', 'N/A', 'N/A', 'N/A', '986', '977', '1006', '1080250', '1202325', '1009962', '1109310', '70287', '93015', '14693.56', '13634.58', 'N/A', '0.230', '0.301', '0.268882175', '73', '26', '29', '3718', '3747', '3790', '2663', '2615', '2575', '75', '82', '89', '3', '2', '6', '11', '9', '8', '955', '1028', '1102', '1991', '2061', '2146', '649', '729', '770', '443', '278', '267', '0.860', '0.86', '0.8474', '0.84', '0.8235', '0.810', '0.84', '0.7729', '0.75', '0.7843', '1121', '1205', '0.74', '0.6862', '0.72', '0.7317', '0.78', '0.7766', '0.79', '0.7387', '0.84', '0.9255', '0.86', '0.9302', '0.88', '0.9308', '0.84', '0.8605' ]); + } + + await stmt.finalize(); }); + after(function() { helper.deleteFile(filename); }); diff --git a/test/open_close.test.js b/test/open_close.test.js index 49d2af79..fa964597 100644 --- a/test/open_close.test.js +++ b/test/open_close.test.js @@ -1,25 +1,25 @@ -var sqlite3 = require('..'); -var assert = require('assert'); -var fs = require('fs'); -var helper = require('./support/helper'); +const sqlite3 = require('..'); +const assert = require('assert'); +const helper = require('./support/helper'); describe('open/close', function() { before(function() { helper.ensureExists('test/tmp'); }); - describe('open and close non-existant database', function() { + describe('open and close non-existant database', async function() { before(function() { helper.deleteFile('test/tmp/test_create.db'); }); - var db; - it('should open the database', function(done) { - db = new sqlite3.Database('test/tmp/test_create.db', done); + /** @type {sqlite3.Database} */ + let db; + it('should open the database', async function() { + db = await sqlite3.Database.create('test/tmp/test_create.db'); }); - it('should close the database', function(done) { - db.close(done); + it('should close the database', async function() { + await db.close(); }); it('should have created the file', function() { @@ -36,13 +36,14 @@ describe('open/close', function() { helper.deleteFile('test/tmp/test_create_shared.db'); }); - var db; - it('should open the database', function(done) { - db = new sqlite3.Database('file:./test/tmp/test_create_shared.db', sqlite3.OPEN_URI | sqlite3.OPEN_SHAREDCACHE | sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE, done); + /** @type {sqlite3.Database} */ + let db; + it('should open the database', async function() { + db = await sqlite3.Database.create('file:./test/tmp/test_create_shared.db', sqlite3.OPEN_URI | sqlite3.OPEN_SHAREDCACHE | sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE); }); - it('should close the database', function(done) { - db.close(done); + it('should close the database', async function() { + await db.close(); }); it('should have created the file', function() { @@ -57,49 +58,44 @@ describe('open/close', function() { (sqlite3.VERSION_NUMBER < 3008000 ? describe.skip : describe)('open and close shared memory database', function() { - var db1; - var db2; + /** @type {sqlite3.Database} */ + let db1; + /** @type {sqlite3.Database} */ + let db2; - it('should open the first database', function(done) { - db1 = new sqlite3.Database('file:./test/tmp/test_memory.db?mode=memory', sqlite3.OPEN_URI | sqlite3.OPEN_SHAREDCACHE | sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE, done); + it('should open the first database', async function() { + db1 = await sqlite3.Database.create('file:./test/tmp/test_memory.db?mode=memory', sqlite3.OPEN_URI | sqlite3.OPEN_SHAREDCACHE | sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE); }); - it('should open the second database', function(done) { - db2 = new sqlite3.Database('file:./test/tmp/test_memory.db?mode=memory', sqlite3.OPEN_URI | sqlite3.OPEN_SHAREDCACHE | sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE, done); + it('should open the second database', async function() { + db2 = await sqlite3.Database.create('file:./test/tmp/test_memory.db?mode=memory', sqlite3.OPEN_URI | sqlite3.OPEN_SHAREDCACHE | sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE); }); - it('first database should set the user_version', function(done) { - db1.exec('PRAGMA user_version=42', done); + it('first database should set the user_version', async function() { + await db1.exec('PRAGMA user_version=42'); }); - it('second database should get the user_version', function(done) { - db2.get('PRAGMA user_version', function(err, row) { - if (err) throw err; - assert.equal(row.user_version, 42); - done(); - }); + it('second database should get the user_version', async function() { + const row = await db2.get('PRAGMA user_version'); + assert.equal(row.user_version, 42); }); - it('should close the first database', function(done) { - db1.close(done); + it('should close the first database', async function() { + await db1.close(); }); - it('should close the second database', function(done) { - db2.close(done); + it('should close the second database', async function() { + await db2.close(); }); }); - it('should not be unable to open an inaccessible database', function(done) { - // NOTE: test assumes that the user is not allowed to create new files - // in /usr/bin. - var db = new sqlite3.Database('/test/tmp/directory-does-not-exist/test.db', function(err) { - if (err && err.errno === sqlite3.CANTOPEN) { - done(); - } else if (err) { - done(err); - } else { - done('Opened database that should be inaccessible'); - } + it('should not be unable to open an inaccessible database', async function() { + await assert.rejects(async () => { + const db = await sqlite3.Database.create('/test/tmp/directory-does-not-exist/test.db'); + await db.close(); + }, (err) => { + assert.strictEqual(err.errno, sqlite3.CANTOPEN); + return true; }); }); @@ -109,19 +105,15 @@ describe('open/close', function() { helper.deleteFile('test/tmp/test_readonly.db'); }); - it('should fail to open the database', function(done) { - new sqlite3.Database('tmp/test_readonly.db', sqlite3.OPEN_READONLY, function(err) { - if (err && err.errno === sqlite3.CANTOPEN) { - done(); - } else if (err) { - done(err); - } else { - done('Created database without create flag'); - } + it('should fail to open the database', async function() { + await assert.rejects(async () => { + const db = await sqlite3.Database.create('test/tmp/test_readonly.db', sqlite3.READONLY); + await db.close(); + }, (err) => { + // TODO: This is the wrong error code? + assert.strictEqual(err.errno, sqlite3.MISUSE); + return true; }); - }); - - it('should not have created the file', function() { assert.fileDoesNotExist('test/tmp/test_readonly.db'); }); @@ -131,57 +123,43 @@ describe('open/close', function() { }); describe('open and close memory database queuing', function() { - var db; - it('should open the database', function(done) { - db = new sqlite3.Database(':memory:', done); - }); - it('should close the database', function(done) { - db.close(done); - }); - - it('shouldn\'t close the database again', function(done) { - db.close(function(err) { + + it('shouldn\'t close the database twice', async function() { + const db = await sqlite3.Database.create(':memory:'); + await db.close(); + await assert.rejects(db.close(), (err) => { assert.ok(err, 'No error object received on second close'); assert.ok(err.errno === sqlite3.MISUSE); - done(); + return true; }); }); }); describe('closing with unfinalized statements', function(done) { - var completed = false; - var completedSecond = false; - var closed = false; - - var db; - before(function() { - db = new sqlite3.Database(':memory:', done); - }); - - it('should create a table', function(done) { - db.run("CREATE TABLE foo (id INT, num INT)", done); - }); - - var stmt; - it('should prepare/run a statement', function(done) { - stmt = db.prepare('INSERT INTO foo VALUES (?, ?)'); + /** @type {sqlite3.Database} */ + let db; + /** @type {sqlite3.Statement} */ + let stmt; + before(async function() { + db = await sqlite3.Database.create(':memory:', done); + await db.run("CREATE TABLE foo (id INT, num INT)"); + stmt = await db.prepare('INSERT INTO foo VALUES (?, ?)'); stmt.run(1, 2, done); }); - it('should fail to close the database', function(done) { - db.close(function(err) { + it('should fail to close the database', async function() { + await assert.rejects(db.close(), function(err) { assert.ok(err.message, "SQLITE_BUSY: unable to close due to unfinalised statements"); - done(); + return true; }); }); - it('should succeed to close the database after finalizing', function(done) { - stmt.run(3, 4, function() { - stmt.finalize(); - db.close(done); - }); + it('should succeed to close the database after finalizing', async function() { + await stmt.run(3, 4); + await stmt.finalize(); + await db.close(); }); }); }); diff --git a/test/other_objects.test.js b/test/other_objects.test.js index cc516c49..3078853d 100644 --- a/test/other_objects.test.js +++ b/test/other_objects.test.js @@ -1,42 +1,33 @@ -var sqlite3 = require('..'); -var assert = require('assert'); +const sqlite3 = require('..'); +const assert = require('assert'); describe('data types', function() { - var db; - before(function(done) { - db = new sqlite3.Database(':memory:'); - db.run("CREATE TABLE txt_table (txt TEXT)"); - db.run("CREATE TABLE int_table (int INTEGER)"); - db.run("CREATE TABLE flt_table (flt FLOAT)"); - db.wait(done); + /** @type {sqlite3.Database} */ + let db; + before(async function() { + db = await sqlite3.Database.create(':memory:'); + await db.run("CREATE TABLE txt_table (txt TEXT)"); + await db.run("CREATE TABLE int_table (int INTEGER)"); + await db.run("CREATE TABLE flt_table (flt FLOAT)"); + await db.wait(); }); - beforeEach(function(done) { - db.exec('DELETE FROM txt_table; DELETE FROM int_table; DELETE FROM flt_table;', done); + beforeEach(async function() { + await db.exec('DELETE FROM txt_table; DELETE FROM int_table; DELETE FROM flt_table;'); }); - it('should serialize Date()', function(done) { - var date = new Date(); - db.run("INSERT INTO int_table VALUES(?)", date, function (err) { - if (err) throw err; - db.get("SELECT int FROM int_table", function(err, row) { - if (err) throw err; - assert.equal(row.int, +date); - done(); - }); - }); + it('should serialize Date()', async function() { + const date = new Date(); + await db.run("INSERT INTO int_table VALUES(?)", date); + const row = await db.get("SELECT int FROM int_table"); + assert.equal(row.int, +date); }); - it('should serialize RegExp()', function(done) { - var regexp = /^f\noo/; - db.run("INSERT INTO txt_table VALUES(?)", regexp, function (err) { - if (err) throw err; - db.get("SELECT txt FROM txt_table", function(err, row) { - if (err) throw err; - assert.equal(row.txt, String(regexp)); - done(); - }); - }); + it('should serialize RegExp()', async function() { + const regexp = /^f\noo/; + await db.run("INSERT INTO txt_table VALUES(?)", regexp); + const row = await db.get("SELECT txt FROM txt_table"); + assert.equal(row.txt, String(regexp)); }); [ @@ -52,15 +43,10 @@ describe('data types', function() { -2.3948728634826374e+83, -Infinity ].forEach(function(flt) { - it('should serialize float ' + flt, function(done) { - db.run("INSERT INTO flt_table VALUES(?)", flt, function (err) { - if (err) throw err; - db.get("SELECT flt FROM flt_table", function(err, row) { - if (err) throw err; - assert.equal(row.flt, flt); - done(); - }); - }); + it('should serialize float ' + flt, async function() { + await db.run("INSERT INTO flt_table VALUES(?)", flt); + const row = await db.get("SELECT flt FROM flt_table"); + assert.equal(row.flt, flt); }); }); @@ -75,40 +61,28 @@ describe('data types', function() { -2.3948728634826374e+83, -Infinity ].forEach(function(integer) { - it('should serialize integer ' + integer, function(done) { - db.run("INSERT INTO int_table VALUES(?)", integer, function (err) { - if (err) throw err; - db.get("SELECT int AS integer FROM int_table", function(err, row) { - if (err) throw err; - assert.equal(row.integer, integer); - done(); - }); - }); + it('should serialize integer ' + integer, async function() { + await db.run("INSERT INTO int_table VALUES(?)", integer); + const row = await db.get("SELECT int AS integer FROM int_table"); + assert.equal(row.integer, integer); }); }); - it('should ignore faulty toString', function(done) { + it('should ignore faulty toString', async function() { const faulty = { toString: 23 }; - db.run("INSERT INTO txt_table VALUES(?)", faulty, function (err) { - assert.notEqual(err, undefined); - done(); - }); + // TODO: This is the previous behavior, but it seems like maybe the + // test is labelled incorrectly? + await assert.rejects(db.run("INSERT INTO txt_table VALUES(?)", faulty)); }); - it('should ignore faulty toString in array', function(done) { + it('should ignore faulty toString in array', async function() { const faulty = [[{toString: null}], 1]; - db.all('SELECT * FROM txt_table WHERE txt = ? LIMIT ?', faulty, function (err) { - assert.equal(err, null); - done(); - }); + await db.all('SELECT * FROM txt_table WHERE txt = ? LIMIT ?', faulty); }); - it('should ignore faulty toString set to function', function(done) { + it('should ignore faulty toString set to function', async function() { const faulty = [[{toString: function () {console.log('oh no');}}], 1]; - db.all('SELECT * FROM txt_table WHERE txt = ? LIMIT ?', faulty, function (err) { - assert.equal(err, undefined); - done(); - }); + await db.all('SELECT * FROM txt_table WHERE txt = ? LIMIT ?', faulty); }); }); diff --git a/test/parallel_insert.test.js b/test/parallel_insert.test.js index fc3829bc..62cc04d3 100644 --- a/test/parallel_insert.test.js +++ b/test/parallel_insert.test.js @@ -1,40 +1,33 @@ -var sqlite3 = require('..'); -var assert = require('assert'); -var helper = require('./support/helper'); +const sqlite3 = require('..'); +const assert = require('assert'); +const helper = require('./support/helper'); describe('parallel', function() { - var db; - before(function(done) { + /** @type {sqlite3.Database} */ + let db; + before(async function() { helper.deleteFile('test/tmp/test_parallel_inserts.db'); helper.ensureExists('test/tmp'); - db = new sqlite3.Database('test/tmp/test_parallel_inserts.db', done); + db = await sqlite3.Database.create('test/tmp/test_parallel_inserts.db', ); }); - var columns = []; - for (var i = 0; i < 128; i++) { + const columns = []; + for (let i = 0; i < 128; i++) { columns.push('id' + i); } - - it('should create the table', function(done) { - db.run("CREATE TABLE foo (" + columns + ")", done); - }); - - it('should insert in parallel', function(done) { - for (var i = 0; i < 1000; i++) { - for (var values = [], j = 0; j < columns.length; j++) { + + it('should insert in parallel', async function() { + await db.run("CREATE TABLE foo (" + columns + ")"); + for (let i = 0; i < 1000; i++) { + const values = []; + for (let j = 0; j < columns.length; j++) { values.push(i * j); } db.run("INSERT INTO foo VALUES (" + values + ")"); } - db.wait(done); - }); - - it('should close the database', function(done) { - db.close(done); - }); - - it('should verify that the database exists', function() { + await db.wait(); + await db.close(); assert.fileExists('test/tmp/test_parallel_inserts.db'); }); diff --git a/test/patching.test.js b/test/patching.test.js index 3f9f68d5..ccbfcc45 100644 --- a/test/patching.test.js +++ b/test/patching.test.js @@ -1,10 +1,11 @@ -var sqlite3 = require('..'); -var assert = require('assert'); +const sqlite3 = require('..'); +const assert = require('assert'); describe('patching', function() { describe("Database", function() { - var db; - var originalFunctions = {}; + /** @type {sqlite3.Database} */ + let db; + const originalFunctions = {}; before(function() { originalFunctions.close = sqlite3.Database.prototype.close; @@ -17,48 +18,51 @@ describe('patching', function() { originalFunctions.interrupt = sqlite3.Database.prototype.interrupt; }); - it('allow patching native functions', function() { - var myFun = function myFunction() { + it('allow patching native functions', async function() { + async function myAsyncFn() { + return "Success"; + } + function myFn() { return "Success"; } assert.doesNotThrow(() => { - sqlite3.Database.prototype.close = myFun; + sqlite3.Database.prototype.close = myAsyncFn; }); assert.doesNotThrow(() => { - sqlite3.Database.prototype.exec = myFun; + sqlite3.Database.prototype.exec = myAsyncFn; }); assert.doesNotThrow(() => { - sqlite3.Database.prototype.wait = myFun; + sqlite3.Database.prototype.wait = myAsyncFn; }); assert.doesNotThrow(() => { - sqlite3.Database.prototype.loadExtension = myFun; + sqlite3.Database.prototype.loadExtension = myAsyncFn; }); assert.doesNotThrow(() => { - sqlite3.Database.prototype.serialize = myFun; + sqlite3.Database.prototype.serialize = myAsyncFn; }); assert.doesNotThrow(() => { - sqlite3.Database.prototype.parallelize = myFun; + sqlite3.Database.prototype.parallelize = myAsyncFn; }); assert.doesNotThrow(() => { - sqlite3.Database.prototype.configure = myFun; + sqlite3.Database.prototype.configure = myFn; }); assert.doesNotThrow(() => { - sqlite3.Database.prototype.interrupt = myFun; + sqlite3.Database.prototype.interrupt = myFn; }); - db = new sqlite3.Database(':memory:'); - assert.strictEqual(db.close(), "Success"); - assert.strictEqual(db.exec(), "Success"); - assert.strictEqual(db.wait(), "Success"); - assert.strictEqual(db.loadExtension(), "Success"); - assert.strictEqual(db.serialize(), "Success"); - assert.strictEqual(db.parallelize(), "Success"); + db = await sqlite3.Database.create(':memory:'); + assert.strictEqual(await db.close(), "Success"); + assert.strictEqual(await db.exec(), "Success"); + assert.strictEqual(await db.wait(), "Success"); + assert.strictEqual(await db.loadExtension(), "Success"); + assert.strictEqual(await db.serialize(), "Success"); + assert.strictEqual(await db.parallelize(), "Success"); assert.strictEqual(db.configure(), "Success"); assert.strictEqual(db.interrupt(), "Success"); }); - after(function() { + after(async function() { if(db != null) { sqlite3.Database.prototype.close = originalFunctions.close; sqlite3.Database.prototype.exec = originalFunctions.exec; @@ -68,15 +72,17 @@ describe('patching', function() { sqlite3.Database.prototype.parallelize = originalFunctions.parallelize; sqlite3.Database.prototype.configure = originalFunctions.configure; sqlite3.Database.prototype.interrupt = originalFunctions.interrupt; - db.close(); + await db.close(); } }); }); describe('Statement', function() { - var db; - var statement; - var originalFunctions = {}; + /** @type {sqlite3.Database} */ + let db; + /** @type {sqlite3.Statement} */ + let statement; + const originalFunctions = {}; before(function() { originalFunctions.bind = sqlite3.Statement.prototype.bind; @@ -88,45 +94,49 @@ describe('patching', function() { originalFunctions.finalize = sqlite3.Statement.prototype.finalize; }); - it('allow patching native functions', function() { - var myFun = function myFunction() { + it('allow patching native functions', async function() { + async function myAsyncFn() { return "Success"; } + async function* myGeneratorFn() { + yield "Success"; + } + assert.doesNotThrow(() => { - sqlite3.Statement.prototype.bind = myFun; + sqlite3.Statement.prototype.bind = myAsyncFn; }); assert.doesNotThrow(() => { - sqlite3.Statement.prototype.get = myFun; + sqlite3.Statement.prototype.get = myAsyncFn; }); assert.doesNotThrow(() => { - sqlite3.Statement.prototype.run = myFun; + sqlite3.Statement.prototype.run = myAsyncFn; }); assert.doesNotThrow(() => { - sqlite3.Statement.prototype.all = myFun; + sqlite3.Statement.prototype.all = myAsyncFn; }); assert.doesNotThrow(() => { - sqlite3.Statement.prototype.each = myFun; + sqlite3.Statement.prototype.each = myGeneratorFn; }); assert.doesNotThrow(() => { - sqlite3.Statement.prototype.reset = myFun; + sqlite3.Statement.prototype.reset = myAsyncFn; }); assert.doesNotThrow(() => { - sqlite3.Statement.prototype.finalize = myFun; + sqlite3.Statement.prototype.finalize = myAsyncFn; }); - db = new sqlite3.Database(':memory:'); - statement = db.prepare(""); - assert.strictEqual(statement.bind(), "Success"); - assert.strictEqual(statement.get(), "Success"); - assert.strictEqual(statement.run(), "Success"); - assert.strictEqual(statement.all(), "Success"); - assert.strictEqual(statement.each(), "Success"); - assert.strictEqual(statement.reset(), "Success"); - assert.strictEqual(statement.finalize(), "Success"); + db = await sqlite3.Database.create(':memory:'); + statement = await db.prepare(""); + assert.strictEqual(await statement.bind(), "Success"); + assert.strictEqual(await statement.get(), "Success"); + assert.strictEqual(await statement.run(), "Success"); + assert.strictEqual(await statement.all(), "Success"); + assert.strictEqual((await statement.each().next()).value, "Success"); + assert.strictEqual(await statement.reset(), "Success"); + assert.strictEqual(await statement.finalize(), "Success"); }); - after(function() { + after(async function() { if(statement != null) { sqlite3.Statement.prototype.bind = originalFunctions.bind; sqlite3.Statement.prototype.get = originalFunctions.get; @@ -137,47 +147,49 @@ describe('patching', function() { sqlite3.Statement.prototype.finalize = originalFunctions.finalize; } if(db != null) { - db.close(); + await db.close(); } }); }); describe('Backup', function() { - var db; - var backup; - var originalFunctions = {}; + /** @type {sqlite3.Database} */ + let db; + /** @type {sqlite3.Backup} */ + let backup; + const originalFunctions = {}; before(function() { originalFunctions.step = sqlite3.Backup.prototype.step; originalFunctions.finish = sqlite3.Backup.prototype.finish; }); - it('allow patching native functions', function() { - var myFun = function myFunction() { + it('allow patching native functions', async function() { + async function myAsyncFn() { return "Success"; } assert.doesNotThrow(() => { - sqlite3.Backup.prototype.step = myFun; + sqlite3.Backup.prototype.step = myAsyncFn; }); assert.doesNotThrow(() => { - sqlite3.Backup.prototype.finish = myFun; + sqlite3.Backup.prototype.finish = myAsyncFn; }); - db = new sqlite3.Database(':memory:'); - backup = db.backup("somefile", myFun); - assert.strictEqual(backup.step(), "Success"); - assert.strictEqual(backup.finish(), "Success"); + db = await sqlite3.Database.create(':memory:'); + backup = await db.backup("somefile"); + assert.strictEqual(await backup.step(), "Success"); + assert.strictEqual(await backup.finish(), "Success"); }); - after(function() { + after(async function() { if(backup != null) { sqlite3.Backup.prototype.step = originalFunctions.step; sqlite3.Backup.prototype.finish = originalFunctions.finish; - backup.finish(); + await backup.finish(); } if(db != null) { - db.close(); + await db.close(); } }); }); diff --git a/test/prepare.test.js b/test/prepare.test.js index c237b622..5d77a566 100644 --- a/test/prepare.test.js +++ b/test/prepare.test.js @@ -1,427 +1,395 @@ -var sqlite3 = require('..'); -var assert = require('assert'); +const sqlite3 = require('..'); +const assert = require('assert'); describe('prepare', function() { describe('invalid SQL', function() { - var db; - before(function(done) { db = new sqlite3.Database(':memory:', done); }); - - var stmt; - it('should fail preparing a statement with invalid SQL', function(done) { - stmt = db.prepare('CRATE TALE foo text bar)', function(err, statement) { - if (err && err.errno == sqlite3.ERROR && - err.message === 'SQLITE_ERROR: near "CRATE": syntax error') { - done(); - } - else throw err; + /** @type {sqlite3.Database} */ + let db; + before(async function() { + db = await sqlite3.Database.create(':memory:'); + }); + + it('should fail preparing a statement with invalid SQL', async function() { + await assert.rejects(db.prepare('CRATE TALE foo text bar)'), (err) => { + assert.strictEqual(err.errno, sqlite3.ERROR); + assert.strictEqual(err.message, 'SQLITE_ERROR: near "CRATE": syntax error'); + return true; }); }); - after(function(done) { db.close(done); }); + after(async function() { + await db.close(); + }); }); describe('simple prepared statement', function() { - var db; - before(function(done) { db = new sqlite3.Database(':memory:', done); }); + /** @type {sqlite3.Database} */ + let db; + before(async function() { + db = await sqlite3.Database.create(':memory:'); + }); - it('should prepare, run and finalize the statement', function(done) { - db.prepare("CREATE TABLE foo (text bar)") - .run() - .finalize(done); + it('should prepare, run and finalize the statement', async function() { + await db.prepare("CREATE TABLE foo (text bar)") + .then((statement) => statement.run()) + .then((statement) => statement.finalize()); }); - after(function(done) { db.close(done); }); + after(async function() { + db.close(); + }); }); describe('inserting and retrieving rows', function() { - var db; - before(function(done) { db = new sqlite3.Database(':memory:', done); }); + /** @type {sqlite3.Database} */ + let db; + before(async function() { + db = await sqlite3.Database.create(':memory:'); + }); - var inserted = 0; - var retrieved = 0; + let inserted = 0; + let retrieved = 0; // We insert and retrieve that many rows. - var count = 1000; - - it('should create the table', function(done) { - db.prepare("CREATE TABLE foo (txt text, num int, flt float, blb blob)").run().finalize(done); - }); - - it('should insert ' + count + ' rows', function(done) { - for (var i = 0; i < count; i++) { - db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)").run( - 'String ' + i, - i, - i * Math.PI, - // null (SQLite sets this implicitly) - function(err) { - if (err) throw err; - inserted++; - } - ).finalize(function(err) { - if (err) throw err; - if (inserted == count) done(); - }); + const count = 1000; + + it('should prepare a statement and run it ' + (count + 5) + ' times', async function() { + const statement = await db.prepare("CREATE TABLE foo (txt text, num int, flt float, blb blob)"); + await statement.run(); + await statement.finalize(); + + for (let i = 0; i < count; i++) { + const statement = await db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)"); + await statement.run('String ' + i, i, i * Math.PI); + inserted++; + await statement.finalize(); } - }); - - it('should prepare a statement and run it ' + (count + 5) + ' times', function(done) { - var stmt = db.prepare("SELECT txt, num, flt, blb FROM foo ORDER BY num", function(err) { - if (err) throw err; - assert.equal(stmt.sql, 'SELECT txt, num, flt, blb FROM foo ORDER BY num'); - }); - - for (var i = 0; i < count + 5; i++) (function(i) { - stmt.get(function(err, row) { - if (err) throw err; - - if (retrieved >= 1000) { - assert.equal(row, undefined); - } else { - assert.equal(row.txt, 'String ' + i); - assert.equal(row.num, i); - assert.equal(row.flt, i * Math.PI); - assert.equal(row.blb, null); - } + assert.strictEqual(inserted, count); + const stmt = await db.prepare("SELECT txt, num, flt, blb FROM foo ORDER BY num"); + assert.equal(stmt.sql, 'SELECT txt, num, flt, blb FROM foo ORDER BY num'); + + for (let i = 0; i < count; i++) { + const row = await stmt.get(); + assert.equal(row.txt, 'String ' + i); + assert.equal(row.num, i); + assert.equal(row.flt, i * Math.PI); + assert.equal(row.blb, null); - retrieved++; - }); - })(i); + retrieved++; + } + + for (let i = count; i < count + 5; i++) { + const row = await stmt.get(); + assert.equal(row, undefined); - stmt.finalize(done); - }); + retrieved++; + } - it('should have retrieved ' + (count + 5) + ' rows', function() { + await stmt.finalize(); assert.equal(count + 5, retrieved, "Didn't retrieve all rows"); }); - after(function(done) { db.close(done); }); + after(async function() { + db.close(); + }); }); describe('inserting with accidental undefined', function() { - var db; - before(function(done) { db = new sqlite3.Database(':memory:', done); }); - - var inserted = 0; - var retrieved = 0; - - it('should create the table', function(done) { - db.prepare("CREATE TABLE foo (num int)").run().finalize(done); + /** @type {sqlite3.Database} */ + let db; + before(async function() { + db = await sqlite3.Database.create(':memory:'); }); - it('should insert two rows', function(done) { - db.prepare('INSERT INTO foo VALUES(4)').run(function(err) { - if (err) throw err; - inserted++; - }).run(undefined, function (err) { + let retrieved = 0; + + it('should retrieve the data', async function() { + await db.prepare("CREATE TABLE foo (num int)") + .then((statement) => statement.run()) + .then((statement) => statement.finalize()); + + await db.prepare('INSERT INTO foo VALUES(4)') + .then((statement) => statement.run()) // The second time we pass undefined as a parameter. This is // a mistake, but it should either throw an error or be ignored, // not silently fail to run the statement. - if (err) throw err; - inserted++; - }).finalize(function(err) { - if (err) throw err; - if (inserted == 2) done(); - }); - }); - - it('should retrieve the data', function(done) { - var stmt = db.prepare("SELECT num FROM foo", function(err) { - if (err) throw err; - }); + .then((statement) => statement.run(undefined)) + .then((statement) => statement.finalize()); - for (var i = 0; i < 2; i++) (function(i) { - stmt.get(function(err, row) { - if (err) throw err; - assert(row); - assert.equal(row.num, 4); - retrieved++; - }); - })(i); + const stmt = await db.prepare("SELECT num FROM foo"); - stmt.finalize(done); - }); + for (let i = 0; i < 2; i++) { + const row = await stmt.get(); + assert(row); + assert.equal(row.num, 4); + retrieved++; + } - it('should have retrieved two rows', function() { + await stmt.finalize(); assert.equal(2, retrieved, "Didn't retrieve all rows"); }); - after(function(done) { db.close(done); }); + after(async function() { + await db.close(); + }); }); describe('retrieving reset() function', function() { - var db; - before(function(done) { db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY, done); }); - - var retrieved = 0; - - it('should retrieve the same row over and over again', function(done) { - var stmt = db.prepare("SELECT txt, num, flt, blb FROM foo ORDER BY num"); - for (var i = 0; i < 10; i++) { - stmt.reset(); - stmt.get(function(err, row) { - if (err) throw err; - assert.equal(row.txt, 'String 0'); - assert.equal(row.num, 0); - assert.equal(row.flt, 0.0); - assert.equal(row.blb, null); - retrieved++; - }); - } - stmt.finalize(done); + /** @type {sqlite3.Database} */ + let db; + before(async function() { + db = await sqlite3.Database.create('test/support/prepare.db', sqlite3.OPEN_READONLY); }); - it('should have retrieved 10 rows', function() { + let retrieved = 0; + + it('should retrieve the same row over and over again', async function() { + const stmt = await db.prepare("SELECT txt, num, flt, blb FROM foo ORDER BY num"); + for (let i = 0; i < 10; i++) { + await stmt.reset(); + const row = await stmt.get(); + assert.equal(row.txt, 'String 0'); + assert.equal(row.num, 0); + assert.equal(row.flt, 0.0); + assert.equal(row.blb, null); + retrieved++; + } + await stmt.finalize(); assert.equal(10, retrieved, "Didn't retrieve all rows"); }); - after(function(done) { db.close(done); }); + after(async function() { + await db.close(); + }); }); describe('multiple get() parameter binding', function() { - var db; - before(function(done) { db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY, done); }); - - var retrieved = 0; + /** @type {sqlite3.Database} */ + let db; + before(async function() { + db = await sqlite3.Database.create('test/support/prepare.db', sqlite3.OPEN_READONLY); + }); - it('should retrieve particular rows', function(done) { - var stmt = db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num = ?"); + let retrieved = 0; - for (var i = 0; i < 10; i++) (function(i) { - stmt.get(i * 10 + 1, function(err, row) { - if (err) throw err; - var val = i * 10 + 1; - assert.equal(row.txt, 'String ' + val); - assert.equal(row.num, val); - assert.equal(row.flt, val * Math.PI); - assert.equal(row.blb, null); - retrieved++; - }); - })(i); + it('should retrieve particular rows', async function() { + const stmt = await db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num = ?"); - stmt.finalize(done); - }); + for (let i = 0; i < 10; i++) { + const row = await stmt.get(i * 10 + 1); + const val = i * 10 + 1; + assert.equal(row.txt, 'String ' + val); + assert.equal(row.num, val); + assert.equal(row.flt, val * Math.PI); + assert.equal(row.blb, null); + retrieved++; + } - it('should have retrieved 10 rows', function() { + await stmt.finalize(); assert.equal(10, retrieved, "Didn't retrieve all rows"); }); - after(function(done) { db.close(done); }); + after(async function() { + await db.close(); + }); }); describe('prepare() parameter binding', function() { - var db; - before(function(done) { db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY, done); }); - - var retrieved = 0; - - it('should retrieve particular rows', function(done) { - db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num = ? AND txt = ?", 10, 'String 10') - .get(function(err, row) { - if (err) throw err; - assert.equal(row.txt, 'String 10'); - assert.equal(row.num, 10); - assert.equal(row.flt, 10 * Math.PI); - assert.equal(row.blb, null); - retrieved++; - }) - .finalize(done); + /** @type {sqlite3.Database} */ + let db; + before(async function() { + db = await sqlite3.Database.create('test/support/prepare.db', sqlite3.OPEN_READONLY); }); - it('should have retrieved 1 row', function() { - assert.equal(1, retrieved, "Didn't retrieve all rows"); + it('should retrieve particular rows', async function() { + const statement = await db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num = ? AND txt = ?", 10, 'String 10'); + const row = await statement.get(); + await statement.finalize(); + assert.equal(row.txt, 'String 10'); + assert.equal(row.num, 10); + assert.equal(row.flt, 10 * Math.PI); + assert.equal(row.blb, null); }); - after(function(done) { db.close(done); }); + after(async function() { + await db.close(); + }); }); describe('all()', function() { - var db; - before(function(done) { db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY, done); }); - - var retrieved = 0; - var count = 1000; - - it('should retrieve particular rows', function(done) { - db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num < ? ORDER BY num", count) - .all(function(err, rows) { - if (err) throw err; - for (var i = 0; i < rows.length; i++) { - assert.equal(rows[i].txt, 'String ' + i); - assert.equal(rows[i].num, i); - assert.equal(rows[i].flt, i * Math.PI); - assert.equal(rows[i].blb, null); - retrieved++; - } - }) - .finalize(done); - }); - - it('should have retrieved all rows', function() { + /** @type {sqlite3.Database} */ + let db; + before(async function() { + db = await sqlite3.Database.create('test/support/prepare.db', sqlite3.OPEN_READONLY); + }); + + let retrieved = 0; + const count = 1000; + + it('should retrieve particular rows', async function() { + const statement = await db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num < ? ORDER BY num", count); + const rows = await statement.all(); + await statement.finalize(); + for (let i = 0; i < rows.length; i++) { + assert.equal(rows[i].txt, 'String ' + i); + assert.equal(rows[i].num, i); + assert.equal(rows[i].flt, i * Math.PI); + assert.equal(rows[i].blb, null); + retrieved++; + } assert.equal(count, retrieved, "Didn't retrieve all rows"); }); - after(function(done) { db.close(done); }); + after(async function() { + await db.close(); + }); }); describe('all()', function() { - var db; - before(function(done) { db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY, done); }); + /** @type {sqlite3.Database} */ + let db; + before(async function() { + db = await sqlite3.Database.create('test/support/prepare.db', sqlite3.OPEN_READONLY); + }); - it('should retrieve particular rows', function(done) { - db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num > 5000") - .all(function(err, rows) { - if (err) throw err; - assert.ok(rows.length === 0); - }) - .finalize(done); + it('should retrieve particular rows', async function() { + const statement = await db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num > 5000"); + const rows = await statement.all(); + await statement.finalize(); + assert.ok(rows.length === 0); }); - after(function(done) { db.close(done); }); + after(async function() { + await db.close(); + }); }); describe('high concurrency', function() { - var db; - before(function(done) { db = new sqlite3.Database(':memory:', done); }); + /** @type {sqlite3.Database} */ + let db; + before(async function() { + db = await sqlite3.Database.create(':memory:'); + }); function randomString() { - var str = ''; - for (var i = Math.random() * 300; i > 0; i--) { + let str = ''; + for (let i = Math.random() * 300; i > 0; i--) { str += String.fromCharCode(Math.floor(Math.random() * 256)); } return str; } // Generate random data. - var data = []; - var length = Math.floor(Math.random() * 1000) + 200; - for (var i = 0; i < length; i++) { + const data = []; + const length = Math.floor(Math.random() * 1000) + 200; + for (let i = 0; i < length; i++) { data.push([ randomString(), i, i * Math.random(), null ]); } - var inserted = 0; - var retrieved = 0; - - it('should create the table', function(done) { - db.prepare("CREATE TABLE foo (txt text, num int, flt float, blb blob)").run().finalize(done); - }); - - it('should insert all values', function(done) { - for (var i = 0; i < data.length; i++) { - var stmt = db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)"); - stmt.run(data[i][0], data[i][1], data[i][2], data[i][3], function(err) { - if (err) throw err; - inserted++; - }).finalize(function(err) { - if (err) throw err; - if (inserted == data.length) done(); - }); + let inserted = 0; + let retrieved = 0; + + it('should retrieve all values', async function() { + await db.prepare("CREATE TABLE foo (txt text, num int, flt float, blb blob)") + .then((statement) => statement.run()) + .then((statement) => statement.finalize()); + + for (let i = 0; i < data.length; i++) { + const stmt = await db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)"); + await stmt.run(data[i][0], data[i][1], data[i][2], data[i][3]); + await stmt.finalize(); + inserted++; } - }); - - it('should retrieve all values', function(done) { - db.prepare("SELECT txt, num, flt, blb FROM foo") - .all(function(err, rows) { - if (err) throw err; - for (var i = 0; i < rows.length; i++) { - assert.ok(data[rows[i].num] !== true); + const statement = await db.prepare("SELECT txt, num, flt, blb FROM foo"); + const rows = await statement.all(); + await statement.finalize(); - assert.equal(rows[i].txt, data[rows[i].num][0]); - assert.equal(rows[i].num, data[rows[i].num][1]); - assert.equal(rows[i].flt, data[rows[i].num][2]); - assert.equal(rows[i].blb, data[rows[i].num][3]); + for (let i = 0; i < rows.length; i++) { + assert.ok(data[rows[i].num] !== true); - // Mark the data row as already retrieved. - data[rows[i].num] = true; - retrieved++; + assert.equal(rows[i].txt, data[rows[i].num][0]); + assert.equal(rows[i].num, data[rows[i].num][1]); + assert.equal(rows[i].flt, data[rows[i].num][2]); + assert.equal(rows[i].blb, data[rows[i].num][3]); - } + // Mark the data row as already retrieved. + data[rows[i].num] = true; + retrieved++; + } - assert.equal(retrieved, data.length); - assert.equal(retrieved, inserted); - }) - .finalize(done); + assert.equal(retrieved, data.length); + assert.equal(retrieved, inserted); }); - after(function(done) { db.close(done); }); + after(async function() { + await db.close(); + }); }); describe('test Database#get()', function() { - var db; - before(function(done) { db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY, done); }); - - var retrieved = 0; - - it('should get a row', function(done) { - db.get("SELECT txt, num, flt, blb FROM foo WHERE num = ? AND txt = ?", 10, 'String 10', function(err, row) { - if (err) throw err; - assert.equal(row.txt, 'String 10'); - assert.equal(row.num, 10); - assert.equal(row.flt, 10 * Math.PI); - assert.equal(row.blb, null); - retrieved++; - done(); - }); + /** @type {sqlite3.Database} */ + let db; + before(async function() { + db = await sqlite3.Database.create('test/support/prepare.db', sqlite3.OPEN_READONLY); }); - it('should have retrieved all rows', function() { + let retrieved = 0; + + it('should get a row', async function() { + const row = await db.get("SELECT txt, num, flt, blb FROM foo WHERE num = ? AND txt = ?", 10, 'String 10'); + assert.equal(row.txt, 'String 10'); + assert.equal(row.num, 10); + assert.equal(row.flt, 10 * Math.PI); + assert.equal(row.blb, null); + retrieved++; assert.equal(1, retrieved, "Didn't retrieve all rows"); }); - after(function(done) { db.close(done); }); + after(async function() { + await db.close(); + }); }); describe('Database#run() and Database#all()', function() { - var db; - before(function(done) { db = new sqlite3.Database(':memory:', done); }); + /** @type {sqlite3.Database} */ + let db; + before(async function() { + db = await sqlite3.Database.create(':memory:'); + }); - var inserted = 0; - var retrieved = 0; + let inserted = 0; + let retrieved = 0; // We insert and retrieve that many rows. - var count = 1000; - - it('should create the table', function(done) { - db.run("CREATE TABLE foo (txt text, num int, flt float, blb blob)", done); - }); - - it('should insert ' + count + ' rows', function(done) { - for (var i = 0; i < count; i++) { - db.run("INSERT INTO foo VALUES(?, ?, ?, ?)", - 'String ' + i, - i, - i * Math.PI, - // null (SQLite sets this implicitly) - function(err) { - if (err) throw err; - inserted++; - if (inserted == count) done(); - } - ); + const count = 1000; + + it('should retrieve all rows', async function() { + await db.run("CREATE TABLE foo (txt text, num int, flt float, blb blob)"); + + for (let i = 0; i < count; i++) { + await db.run("INSERT INTO foo VALUES(?, ?, ?, ?)", 'String ' + i, i, i * Math.PI); + inserted++; } - }); - it('should retrieve all rows', function(done) { - db.all("SELECT txt, num, flt, blb FROM foo ORDER BY num", function(err, rows) { - if (err) throw err; - for (var i = 0; i < rows.length; i++) { - assert.equal(rows[i].txt, 'String ' + i); - assert.equal(rows[i].num, i); - assert.equal(rows[i].flt, i * Math.PI); - assert.equal(rows[i].blb, null); - retrieved++; - } + const rows = await db.all("SELECT txt, num, flt, blb FROM foo ORDER BY num"); - assert.equal(retrieved, count); - assert.equal(retrieved, inserted); + for (let i = 0; i < rows.length; i++) { + assert.equal(rows[i].txt, 'String ' + i); + assert.equal(rows[i].num, i); + assert.equal(rows[i].flt, i * Math.PI); + assert.equal(rows[i].blb, null); + retrieved++; + } - done(); - }); + assert.equal(retrieved, count); + assert.equal(retrieved, inserted); }); - after(function(done) { db.close(done); }); + after(async function() { + await db.close(); + }); }); }); diff --git a/test/profile.test.js b/test/profile.test.js index d8eb8b5d..07f92a09 100644 --- a/test/profile.test.js +++ b/test/profile.test.js @@ -1,13 +1,14 @@ -var sqlite3 = require('..'); -var assert = require('assert'); +const sqlite3 = require('..'); +const assert = require('assert'); describe('profiling', function() { - var create = false; - var select = false; + let create = false; + let select = false; - var db; - before(function(done) { - db = new sqlite3.Database(':memory:', done); + /** @type {sqlite3.Database} */ + let db; + before(async function() { + db = await sqlite3.Database.create(':memory:'); db.on('profile', function(sql, nsecs) { assert.ok(typeof nsecs === "number"); @@ -29,9 +30,8 @@ describe('profiling', function() { it('should profile a create table', function(done) { assert.ok(!create); - db.run("CREATE TABLE foo (id int)", function(err) { - if (err) throw err; - setImmediate(function() { + db.run("CREATE TABLE foo (id int)").then(() => { + setImmediate(() => { assert.ok(create); done(); }); @@ -41,16 +41,15 @@ describe('profiling', function() { it('should profile a select', function(done) { assert.ok(!select); - db.run("SELECT * FROM foo", function(err) { - if (err) throw err; + db.run("SELECT * FROM foo").then(() => { setImmediate(function() { assert.ok(select); done(); - }, 0); + }); }); }); - after(function(done) { - db.close(done); + after(async function() { + await db.close(); }); }); diff --git a/test/rerun.test.js b/test/rerun.test.js index e98562ec..4a83a4b2 100644 --- a/test/rerun.test.js +++ b/test/rerun.test.js @@ -1,50 +1,36 @@ -var sqlite3 = require('..'); -var assert = require('assert'); +const sqlite3 = require('..'); +const assert = require('assert'); describe('rerunning statements', function() { - var db; - before(function(done) { db = new sqlite3.Database(':memory:', done); }); + /** @type {sqlite3.Database} */ + let db; + const count = 10; - var count = 10; - var inserted = 0; - var retrieved = 0; - - it('should create the table', function(done) { - db.run("CREATE TABLE foo (id int)", done); - }); - - it('should insert repeatedly, reusing the same statement', function(done) { - var stmt = db.prepare("INSERT INTO foo VALUES(?)"); - for (var i = 5; i < count; i++) { - stmt.run(i, function(err) { - if (err) throw err; - inserted++; - }); + before(async function() { + db = await sqlite3.Database.create(':memory:'); + await db.run("CREATE TABLE foo (id int)"); + + const stmt = await db.prepare("INSERT INTO foo VALUES(?)"); + for (let i = 5; i < count; i++) { + await stmt.run(i); } - stmt.finalize(done); + + await stmt.finalize(); }); - it('should retrieve repeatedly, resuing the same statement', function(done) { - var collected = []; - var stmt = db.prepare("SELECT id FROM foo WHERE id = ?"); - for (var i = 0; i < count; i++) { - stmt.get(i, function(err, row) { - if (err) throw err; - if (row) collected.push(row); - }); + it('should retrieve repeatedly, resuing the same statement', async function() { + const collected = []; + const stmt = await db.prepare("SELECT id FROM foo WHERE id = ?"); + for (let i = 0; i < count; i++) { + const row = await stmt.get(i); + if (row) collected.push(row); } - stmt.finalize(function(err) { - if (err) throw err; - retrieved += collected.length; - assert.deepEqual(collected, [ { id: 5 }, { id: 6 }, { id: 7 }, { id: 8 }, { id: 9 } ]); - done(); - }); + await stmt.finalize(); + assert.deepEqual(collected, [ { id: 5 }, { id: 6 }, { id: 7 }, { id: 8 }, { id: 9 } ]); + assert.equal(collected.length, 5); }); - it('should have inserted and retrieved the right amount', function() { - assert.equal(inserted, 5); - assert.equal(retrieved, 5); + after(async function() { + await db.close(); }); - - after(function(done) { db.close(done); }); }); diff --git a/test/scheduling.test.js b/test/scheduling.test.js index e00a8cf5..3e8eaf38 100644 --- a/test/scheduling.test.js +++ b/test/scheduling.test.js @@ -1,44 +1,29 @@ -var sqlite3 = require('..'); -var assert = require('assert'); +const sqlite3 = require('..'); +const assert = require('assert'); describe('scheduling', function() { - it('scheduling after the database was closed', function(done) { - var db = new sqlite3.Database(':memory:'); - db.on('error', function(err) { - assert.ok(err.message && err.message.indexOf("SQLITE_MISUSE: Database handle is closed") > -1); - done(); - }); - - db.close(); - db.run("CREATE TABLE foo (id int)"); - }); - - - it('scheduling a query with callback after the database was closed', function(done) { - var db = new sqlite3.Database(':memory:'); - db.on('error', function(err) { - assert.ok(false, 'Event was accidentally triggered'); - }); + it('scheduling after the database was closed', async function() { + const db = await sqlite3.Database.create(':memory:'); - db.close(); - db.run("CREATE TABLE foo (id int)", function(err) { - assert.ok(err.message && err.message.indexOf("SQLITE_MISUSE: Database handle is closed") > -1); - done(); + await db.close(); + await assert.rejects(db.run("CREATE TABLE foo (id int)"), (err) => { + assert.ok(err.message && err.message.indexOf("SQLITE_MISUSE: Database is closed") > -1); + return true; }); }); - it('running a query after the database was closed', function(done) { - var db = new sqlite3.Database(':memory:'); + it('running a query after the database was closed', async function() { + const db = await sqlite3.Database.create(':memory:'); - var stmt = db.prepare("SELECT * FROM sqlite_master", function(err) { - if (err) throw err; - db.close(function(err) { - assert.ok(err); - assert.ok(err.message && err.message.indexOf("SQLITE_BUSY: unable to close due to") > -1); + const stmt = await db.prepare("SELECT * FROM sqlite_master"); - // Running a statement now should not fail. - stmt.run(done); - }); + await assert.rejects(db.close(), (err) => { + assert.ok(err); + assert.ok(err.message && err.message.indexOf("SQLITE_BUSY: unable to close due to") > -1); + return true; }); + // Running a statement now should not fail. + await stmt.run(); + await stmt.finalize(); }); }); diff --git a/test/serialization.test.js b/test/serialization.test.js index ccc58673..59b47ac5 100644 --- a/test/serialization.test.js +++ b/test/serialization.test.js @@ -1,104 +1,101 @@ -var sqlite3 = require('..'); -var assert = require('assert'); +const sqlite3 = require('..'); +const assert = require('assert'); describe('serialize() and parallelize()', function() { - var db; - before(function(done) { db = new sqlite3.Database(':memory:', done); }); + /** @type {sqlite3.Database} */ + let db; + before(async function() { + db = await sqlite3.Database.create(':memory:'); + }); - var inserted1 = 0; - var inserted2 = 0; - var retrieved = 0; + let inserted1 = 0; + let inserted2 = 0; + let retrieved = 0; - var count = 1000; + const count = 1000; - it('should toggle', function(done) { - db.serialize(); - db.run("CREATE TABLE foo (txt text, num int, flt float, blb blob)"); - db.parallelize(done); + it('should toggle', async function() { + await db.serialize(); + await db.run("CREATE TABLE foo (txt text, num int, flt float, blb blob)"); + await db.parallelize(); }); - it('should insert rows', function() { - var stmt1 = db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)"); - var stmt2 = db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)"); - for (var i = 0; i < count; i++) { + it('should insert rows', async function() { + const stmt1 = await db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)"); + const stmt2 = await db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)"); + for (let i = 0; i < count; i++) { // Interleaved inserts with two statements. - stmt1.run('String ' + i, i, i * Math.PI, function(err) { - if (err) throw err; - inserted1++; - }); + await stmt1.run('String ' + i, i, i * Math.PI); + inserted1++; i++; - stmt2.run('String ' + i, i, i * Math.PI, function(err) { - if (err) throw err; - inserted2++; - }); + await stmt2.run('String ' + i, i, i * Math.PI); + inserted2++; } - stmt1.finalize(); - stmt2.finalize(); + await stmt1.finalize(); + await stmt2.finalize(); }); - it('should have inserted all the rows after synchronizing with serialize()', function(done) { - db.serialize(); - db.all("SELECT txt, num, flt, blb FROM foo ORDER BY num", function(err, rows) { - if (err) throw err; - for (var i = 0; i < rows.length; i++) { - assert.equal(rows[i].txt, 'String ' + i); - assert.equal(rows[i].num, i); - assert.equal(rows[i].flt, i * Math.PI); - assert.equal(rows[i].blb, null); - retrieved++; - } + it('should have inserted all the rows after synchronizing with serialize()', async function() { + await db.serialize(); + const rows = await db.all("SELECT txt, num, flt, blb FROM foo ORDER BY num"); - assert.equal(count, inserted1 + inserted2, "Didn't insert all rows"); - assert.equal(count, retrieved, "Didn't retrieve all rows"); - done(); - }); + for (let i = 0; i < rows.length; i++) { + assert.equal(rows[i].txt, 'String ' + i); + assert.equal(rows[i].num, i); + assert.equal(rows[i].flt, i * Math.PI); + assert.equal(rows[i].blb, null); + retrieved++; + } + + assert.equal(count, inserted1 + inserted2, "Didn't insert all rows"); + assert.equal(count, retrieved, "Didn't retrieve all rows"); }); - after(function(done) { db.close(done); }); + after(async function() { + await db.close(); + }); }); describe('serialize(fn)', function() { - var db; - before(function(done) { db = new sqlite3.Database(':memory:', done); }); + /** @type {sqlite3.Database} */ + let db; + before(async function() { + db = await sqlite3.Database.create(':memory:'); + }); - var inserted = 0; - var retrieved = 0; + let inserted = 0; + let retrieved = 0; - var count = 1000; + const count = 1000; - it('should call the callback', function(done) { - db.serialize(function() { - db.run("CREATE TABLE foo (txt text, num int, flt float, blb blob)"); + it('should call the callback', async function() { + await db.serialize(async function() { + await db.run("CREATE TABLE foo (txt text, num int, flt float, blb blob)"); - var stmt = db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)"); - for (var i = 0; i < count; i++) { - stmt.run('String ' + i, i, i * Math.PI, function(err) { - if (err) throw err; - inserted++; - }); + const stmt = await db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)"); + for (let i = 0; i < count; i++) { + await stmt.run('String ' + i, i, i * Math.PI); + inserted++; } - stmt.finalize(); - - db.all("SELECT txt, num, flt, blb FROM foo ORDER BY num", function(err, rows) { - if (err) throw err; - for (var i = 0; i < rows.length; i++) { - assert.equal(rows[i].txt, 'String ' + i); - assert.equal(rows[i].num, i); - assert.equal(rows[i].flt, i * Math.PI); - assert.equal(rows[i].blb, null); - retrieved++; - } - done(); - }); - }); - }); + await stmt.finalize(); + const rows = await db.all("SELECT txt, num, flt, blb FROM foo ORDER BY num"); + + for (let i = 0; i < rows.length; i++) { + assert.equal(rows[i].txt, 'String ' + i); + assert.equal(rows[i].num, i); + assert.equal(rows[i].flt, i * Math.PI); + assert.equal(rows[i].blb, null); + retrieved++; + } + }); - it('should have inserted and retrieved all rows', function() { assert.equal(count, inserted, "Didn't insert all rows"); assert.equal(count, retrieved, "Didn't retrieve all rows"); }); - after(function(done) { db.close(done); }); + after(async function() { + await db.close(); + }); }); diff --git a/test/support/createdb-electron.js b/test/support/createdb-electron.js index 7db72701..59ee32df 100644 --- a/test/support/createdb-electron.js +++ b/test/support/createdb-electron.js @@ -1,6 +1,6 @@ -var {app} = require('electron'); -var createdb = require('./createdb.js'); +const {app} = require('electron'); +const createdb = require('./createdb.js'); createdb().then(() => { setTimeout(function () { diff --git a/test/support/createdb.js b/test/support/createdb.js index f4fb3a7c..3e861c3c 100755 --- a/test/support/createdb.js +++ b/test/support/createdb.js @@ -1,36 +1,36 @@ #!/usr/bin/env node async function createdb() { - var existsSync = require('fs').existsSync || require('path').existsSync; - var statSync = require('fs').statSync || require('path').statSync; - var path = require('path'); + const existsSync = require('fs').existsSync || require('path').existsSync; + const statSync = require('fs').statSync || require('path').statSync; + const path = require('path'); - var sqlite3 = require('../../lib/sqlite3'); + const sqlite3 = require('../../lib/sqlite3'); - var count = 1000000; - var db_path = path.join(__dirname,'big.db'); + const count = 1000000; + const dbPath = path.join(__dirname,'big.db'); function randomString() { - var str = ''; - var chars = 'abcdefghijklmnopqrstuvwxzyABCDEFGHIJKLMNOPQRSTUVWXZY0123456789 '; - for (var i = Math.random() * 100; i > 0; i--) { + let str = ''; + const chars = 'abcdefghijklmnopqrstuvwxzyABCDEFGHIJKLMNOPQRSTUVWXZY0123456789 '; + for (let i = Math.random() * 100; i > 0; i--) { str += chars[Math.floor(Math.random() * chars.length)]; } return str; } // Make sure the file exists and is also valid. - if (existsSync(db_path) && statSync(db_path).size !== 0) { - console.log('okay: database already created (' + db_path + ')'); + if (existsSync(dbPath) && statSync(dbPath).size !== 0) { + console.log('okay: database already created (' + dbPath + ')'); } else { console.log("Creating test database... This may take several minutes."); - var db = await sqlite3.Database.create(db_path); + const db = await sqlite3.Database.create(dbPath); await db.serialize(async function() { await db.run("CREATE TABLE foo (id INT, txt TEXT)"); - db.run("BEGIN TRANSACTION"); - var stmt = await db.prepare("INSERT INTO foo VALUES(?, ?)"); - for (var i = 0; i < count; i++) { - stmt.run(i, randomString()); + await db.run("BEGIN TRANSACTION"); + const stmt = await db.prepare("INSERT INTO foo VALUES(?, ?)"); + for (let i = 0; i < count; i++) { + await stmt.run(i, randomString()); } await stmt.finalize(); await db.run("COMMIT TRANSACTION", []); diff --git a/test/support/helper.js b/test/support/helper.js index cb2075d2..73761668 100644 --- a/test/support/helper.js +++ b/test/support/helper.js @@ -1,6 +1,6 @@ -var assert = require('assert'); -var fs = require('fs'); -var pathExists = require('fs').existsSync || require('path').existsSync; +const assert = require('assert'); +const fs = require('fs'); +const pathExists = require('fs').existsSync || require('path').existsSync; exports.deleteFile = function(name) { try { @@ -12,7 +12,7 @@ exports.deleteFile = function(name) { } }; -exports.ensureExists = function(name,cb) { +exports.ensureExists = function(name) { if (!pathExists(name)) { fs.mkdirSync(name); } @@ -30,4 +30,4 @@ assert.fileDoesNotExist = function(name) { assert.fileExists = function(name) { fs.statSync(name); -}; \ No newline at end of file +}; diff --git a/test/trace.test.js b/test/trace.test.js index 3f790bd8..4d7c0887 100644 --- a/test/trace.test.js +++ b/test/trace.test.js @@ -1,11 +1,11 @@ -var sqlite3 = require('..'); -var assert = require('assert'); +const sqlite3 = require('..'); +const assert = require('assert'); describe('tracing', function() { - it('Database tracing', function(done) { - var db = new sqlite3.Database(':memory:'); - var create = false; - var select = false; + it('Database tracing', async function() { + const db = await sqlite3.Database.create(':memory:'); + let create = false; + let select = false; db.on('trace', function(sql) { if (sql.match(/^SELECT/)) { @@ -23,45 +23,42 @@ describe('tracing', function() { } }); - db.serialize(function() { - db.run("CREATE TABLE foo (id int)"); - db.run("SELECT * FROM foo"); + await db.serialize(async function() { + await db.run("CREATE TABLE foo (id int)"); + await db.run("SELECT * FROM foo"); }); - db.close(function(err) { - if (err) throw err; - assert.ok(create); - assert.ok(select); - done(); - }); + await db.close(); + assert.ok(create); + assert.ok(select); }); - it('test disabling tracing #1', function(done) { - var db = new sqlite3.Database(':memory:'); + it('test disabling tracing #1', async function() { + const db = await sqlite3.Database.create(':memory:'); - db.on('trace', function(sql) {}); + db.on('trace', function() {}); db.removeAllListeners('trace'); - db._events['trace'] = function(sql) { + db._events['trace'] = function() { assert.ok(false); }; - db.run("CREATE TABLE foo (id int)"); - db.close(done); + await db.run("CREATE TABLE foo (id int)"); + await db.close(); }); - it('test disabling tracing #2', function(done) { - var db = new sqlite3.Database(':memory:'); + it('test disabling tracing #2', async function() { + const db = await sqlite3.Database.create(':memory:'); - var trace = function(sql) {}; + const trace = function() {}; db.on('trace', trace); db.removeListener('trace', trace); - db._events['trace'] = function(sql) { + db._events['trace'] = function() { assert.ok(false); }; - db.run("CREATE TABLE foo (id int)"); - db.close(done); + await db.run("CREATE TABLE foo (id int)"); + await db.close(); }); }); diff --git a/test/unicode.test.js b/test/unicode.test.js index 9a78c53d..8676311b 100644 --- a/test/unicode.test.js +++ b/test/unicode.test.js @@ -1,16 +1,17 @@ -var sqlite3 = require('..'); -var assert = require('assert'); +const sqlite3 = require('..'); +const assert = require('assert'); describe('unicode', function() { - var first_values = [], - trailing_values = [], - chars = [], - subranges = new Array(2), - len = subranges.length, - db, - i; - - before(function(done) { db = new sqlite3.Database(':memory:', done); }); + const first_values = []; + const trailing_values = []; + const subranges = new Array(2); + const len = subranges.length; + let db; + let i; + + before(async function() { + db = await sqlite3.Database.create(':memory:'); + }); for (i = 0x20; i < 0x80; i++) { first_values.push(i); @@ -41,7 +42,7 @@ describe('unicode', function() { } function random_utf8() { - var first = random_choice(first_values); + const first = random_choice(first_values); if (first < 0x80) { return String.fromCharCode(first); @@ -57,8 +58,8 @@ describe('unicode', function() { } function randomString() { - var str = '', - i; + let str = ''; + let i; for (i = Math.random() * 300; i > 0; i--) { str += random_utf8(); @@ -69,46 +70,35 @@ describe('unicode', function() { // Generate random data. - var data = []; - var length = Math.floor(Math.random() * 1000) + 200; - for (var i = 0; i < length; i++) { + const data = []; + const length = Math.floor(Math.random() * 1000) + 200; + for (let i = 0; i < length; i++) { data.push(randomString()); } - var inserted = 0; - var retrieved = 0; - - it('should create the table', function(done) { - db.run("CREATE TABLE foo (id int, txt text)", done); - }); - - it('should insert all values', function(done) { - var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)"); - for (var i = 0; i < data.length; i++) { - stmt.run(i, data[i], function(err) { - if (err) throw err; - inserted++; - }); + let inserted = 0; + let retrieved = 0; + + it('should retrieve all values', async function() { + await db.run("CREATE TABLE foo (id int, txt text)"); + const stmt = await db.prepare("INSERT INTO foo VALUES(?, ?)"); + for (let i = 0; i < data.length; i++) { + await stmt.run(i, data[i]); + inserted++; } - stmt.finalize(done); - }); - - it('should retrieve all values', function(done) { - db.all("SELECT txt FROM foo ORDER BY id", function(err, rows) { - if (err) throw err; + await stmt.finalize(); - for (var i = 0; i < rows.length; i++) { - assert.equal(rows[i].txt, data[i]); - retrieved++; - } - done(); - }); - }); + const rows = await db.all("SELECT txt FROM foo ORDER BY id"); - it('should have inserted and retrieved the correct amount', function() { + for (let i = 0; i < rows.length; i++) { + assert.equal(rows[i].txt, data[i]); + retrieved++; + } assert.equal(inserted, length); assert.equal(retrieved, length); }); - after(function(done) { db.close(done); }); + after(async function() { + await db.close(); + }); }); diff --git a/test/update_hook.test.js b/test/update_hook.test.js index 6507d2c8..26f5166a 100644 --- a/test/update_hook.test.js +++ b/test/update_hook.test.js @@ -1,15 +1,13 @@ -var sqlite3 = require('..'); -var assert = require('assert'); +const sqlite3 = require('..'); +const assert = require('assert'); describe('update_hook', function() { - var db; + /** @type {sqlite3.Database} */ + let db; - beforeEach(function(done) { - db = new sqlite3.Database(':memory:', function(err) { - if (err) return done(err); - - db.run("CREATE TABLE update_hooks_test (id int PRIMARY KEY, value text)", done); - }); + beforeEach(async function() { + db = await sqlite3.Database.create(':memory:'); + await db.run("CREATE TABLE update_hooks_test (id int PRIMARY KEY, value text)"); }); it('emits insert event on inserting data to table', function(done) { @@ -22,54 +20,51 @@ describe('update_hook', function() { return done(); }); - db.run("INSERT INTO update_hooks_test VALUES (1, 'value')", function(err) { - if (err) return done(err); - }); + db.run("INSERT INTO update_hooks_test VALUES (1, 'value')") + .catch((err) => done(err)); }); it('emits update event on row modification in table', function(done) { - db.run("INSERT INTO update_hooks_test VALUES (2, 'value'), (3, 'value4')", function(err) { - if (err) return done(err); - - db.addListener('change', function(eventType, database, table, rowId) { - assert.equal(eventType, 'update'); - assert.equal(database, 'main'); - assert.equal(table, 'update_hooks_test'); - assert.equal(rowId, 1); - - db.all("SELECT * FROM update_hooks_test WHERE rowid = ?", rowId, function(err, rows) { - assert.deepEqual(rows, [{ id: 2, value: 'new_val' }]); - - return done(err); + db.run("INSERT INTO update_hooks_test VALUES (2, 'value'), (3, 'value4')") + .catch((err) => done(err)) + .then(() => { + db.addListener('change', function(eventType, database, table, rowId) { + assert.equal(eventType, 'update'); + assert.equal(database, 'main'); + assert.equal(table, 'update_hooks_test'); + assert.equal(rowId, 1); + + db.all("SELECT * FROM update_hooks_test WHERE rowid = ?", rowId) + .catch((err) => done(err)) + .then((rows) => { + assert.deepEqual(rows, [{ id: 2, value: 'new_val' }]); + + return done(); + }); }); - }); - db.run("UPDATE update_hooks_test SET value = 'new_val' WHERE id = 2", function(err) { - if (err) return done(err); + db.run("UPDATE update_hooks_test SET value = 'new_val' WHERE id = 2") + .catch((err) => done(err)); }); - }); }); it('emits delete event on row was deleted from table', function(done) { - db.run("INSERT INTO update_hooks_test VALUES (2, 'value')", function(err) { - if (err) return done(err); - - db.addListener('change', function(eventType, database, table, rowId) { - assert.equal(eventType, 'delete'); - assert.equal(database, 'main'); - assert.equal(table, 'update_hooks_test'); - assert.equal(rowId, 1); - - return done(); - }); + db.run("INSERT INTO update_hooks_test VALUES (2, 'value')") + .catch((err) => done(err)) + .then(() => { + db.addListener('change', function(eventType, database, table, rowId) { + assert.equal(eventType, 'delete'); + assert.equal(database, 'main'); + assert.equal(table, 'update_hooks_test'); + assert.equal(rowId, 1); + }); - db.run("DELETE FROM update_hooks_test WHERE id = 2", function(err) { - if (err) return done(err); + db.run("DELETE FROM update_hooks_test WHERE id = 2") + .catch((err) => done(err)).then(() => done()); }); - }); }); - afterEach(function(done) { - db.close(done); + afterEach(async function() { + await db.close(); }); }); diff --git a/test/upsert.test.js b/test/upsert.test.js index f2aa8fa8..1f0f6e25 100644 --- a/test/upsert.test.js +++ b/test/upsert.test.js @@ -1,27 +1,26 @@ -var sqlite3 = require('..'); -var assert = require('assert'); +const sqlite3 = require('..'); +const assert = require('assert'); describe('query properties', function() { - var db; - before(function(done) { - db = new sqlite3.Database(':memory:'); - db.run("CREATE TABLE foo (id INT PRIMARY KEY, count INT)", done); + /** @type {sqlite3.Database} */ + let db; + before(async function() { + db = await sqlite3.Database.create(':memory:'); + await db.run("CREATE TABLE foo (id INT PRIMARY KEY, count INT)"); }); - (sqlite3.VERSION_NUMBER < 3024000 ? it.skip : it)('should upsert', function(done) { - var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)"); - stmt.run(1, 1, function(err) { // insert 1 - if (err) throw err; - var upsert_stmt = db.prepare("INSERT INTO foo VALUES(?, ?) ON CONFLICT (id) DO UPDATE SET count = count + excluded.count"); - upsert_stmt.run(1, 2, function(err) { // add 2 - if (err) throw err; - var select_stmt = db.prepare("SELECT count FROM foo WHERE id = ?"); - select_stmt.get(1, function(err, row) { - if (err) throw err; - assert.equal(row.count, 3); // equals 3 - }); - }); - }); - db.wait(done); + (sqlite3.VERSION_NUMBER < 3024000 ? it.skip : it)('should upsert', async function() { + const stmt = await db.prepare("INSERT INTO foo VALUES(?, ?)"); + await stmt.run(1, 1); + await stmt.finalize(); + + const upsertStmt = await db.prepare("INSERT INTO foo VALUES(?, ?) ON CONFLICT (id) DO UPDATE SET count = count + excluded.count"); + await upsertStmt.run(1, 2); + await upsertStmt.finalize(); + + const selectStmt = await db.prepare("SELECT count FROM foo WHERE id = ?"); + const row = await selectStmt.get(1); + await selectStmt.finalize(); + assert.equal(row.count, 3); }); }); diff --git a/test/verbose.test.js b/test/verbose.test.js index b680280c..8871f75f 100644 --- a/test/verbose.test.js +++ b/test/verbose.test.js @@ -1,60 +1,60 @@ -var sqlite3 = require('..'); -var assert = require('assert'); +const sqlite3 = require('..'); +const assert = require('assert'); -var invalid_sql = 'update non_existent_table set id=1'; +const invalidSql = 'update non_existent_table set id=1'; -var originalMethods = { +const originalMethods = { Database: {}, Statement: {}, }; function backupOriginalMethods() { - for (var obj in originalMethods) { - for (var attr in sqlite3[obj].prototype) { + for (const obj in originalMethods) { + for (const attr in sqlite3[obj].prototype) { originalMethods[obj][attr] = sqlite3[obj].prototype[attr]; } } } function resetVerbose() { - for (var obj in originalMethods) { - for (var attr in originalMethods[obj]) { + for (const obj in originalMethods) { + for (const attr in originalMethods[obj]) { sqlite3[obj].prototype[attr] = originalMethods[obj][attr]; } } } describe('verbose', function() { - it('Shoud add trace info to error when verbose is called', function(done) { - var db = new sqlite3.Database(':memory:'); + it('Shoud add trace info to error when verbose is called', async function() { + const db = await sqlite3.Database.create(':memory:'); backupOriginalMethods(); sqlite3.verbose(); - db.run(invalid_sql, function(err) { - assert(err instanceof Error); + await assert.rejects(db.run(invalidSql), function(err) { + assert.ok(err instanceof Error); - assert( - err.stack.indexOf(`Database#run('${invalid_sql}'`) > -1, + assert.ok( + err.stack.indexOf(`Database#run('${invalidSql}'`) > -1, `Stack shoud contain trace info, stack = ${err.stack}` ); - done(); resetVerbose(); + return true; }); }); - it('Shoud not add trace info to error when verbose is not called', function(done) { - var db = new sqlite3.Database(':memory:'); + it('Shoud not add trace info to error when verbose is not called', async function() { + const db = await sqlite3.Database.create(':memory:'); - db.run(invalid_sql, function(err) { - assert(err instanceof Error); + await assert.rejects(db.run(invalidSql), function(err) { + assert.ok(err instanceof Error); - assert( - err.stack.indexOf(invalid_sql) === -1, + assert.ok( + err.stack.indexOf(invalidSql) === -1, `Stack shoud not contain trace info, stack = ${err.stack}` ); - done(); + return true; }); }); }); diff --git a/tools/benchmark/insert.js b/tools/benchmark/insert.js index f2ebf7b9..57fbaa73 100644 --- a/tools/benchmark/insert.js +++ b/tools/benchmark/insert.js @@ -1,68 +1,72 @@ -var sqlite3 = require('../../lib/sqlite3'); -var fs = require('fs'); +const sqlite3 = require('../../lib/sqlite3'); +const fs = require('fs'); -var iterations = 10000; +const iterations = 10000; exports.compare = { - 'insert literal file': function(finished) { - var db = new sqlite3.Database(''); - var file = fs.readFileSync('benchmark/insert-transaction.sql', 'utf8'); - db.exec(file); - db.close(finished); + 'insert literal file': async function(finished) { + const db = await sqlite3.Database.create(''); + const file = fs.readFileSync('benchmark/insert-transaction.sql', 'utf8'); + await db.exec(file); + await db.close(); + finished(); }, - 'insert with transaction and two statements': function(finished) { - var db = new sqlite3.Database(''); + 'insert with transaction and two statements': async function(finished) { + const db = await sqlite3.Database.create(''); - db.serialize(function() { - db.run("CREATE TABLE foo (id INT, txt TEXT)"); - db.run("BEGIN"); + await db.serialize(async function() { + await db.run("CREATE TABLE foo (id INT, txt TEXT)"); + await db.run("BEGIN"); - db.parallelize(function() { - var stmt1 = db.prepare("INSERT INTO foo VALUES (?, ?)"); - var stmt2 = db.prepare("INSERT INTO foo VALUES (?, ?)"); - for (var i = 0; i < iterations; i++) { - stmt1.run(i, 'Row ' + i); + await db.parallelize(async function() { + const stmt1 = await db.prepare("INSERT INTO foo VALUES (?, ?)"); + const stmt2 = await db.prepare("INSERT INTO foo VALUES (?, ?)"); + for (let i = 0; i < iterations; i++) { + await stmt1.run(i, 'Row ' + i); i++; - stmt2.run(i, 'Row ' + i); + await stmt2.run(i, 'Row ' + i); } - stmt1.finalize(); - stmt2.finalize(); + await stmt1.finalize(); + await stmt2.finalize(); }); - db.run("COMMIT"); + await db.run("COMMIT"); }); - db.close(finished); + await db.close(); + finished(); }, - 'insert with transaction': function(finished) { - var db = new sqlite3.Database(''); + 'insert with transaction': async function(finished) { + const db = await sqlite3.Database.create(''); - db.serialize(function() { - db.run("CREATE TABLE foo (id INT, txt TEXT)"); - db.run("BEGIN"); - var stmt = db.prepare("INSERT INTO foo VALUES (?, ?)"); - for (var i = 0; i < iterations; i++) { - stmt.run(i, 'Row ' + i); + await db.serialize(async function() { + await db.run("CREATE TABLE foo (id INT, txt TEXT)"); + await db.run("BEGIN"); + const stmt = await db.prepare("INSERT INTO foo VALUES (?, ?)"); + for (let i = 0; i < iterations; i++) { + await stmt.run(i, 'Row ' + i); } - stmt.finalize(); - db.run("COMMIT"); + await stmt.finalize(); + await db.run("COMMIT"); }); - db.close(finished); + await db.close(); + finished(); }, - 'insert without transaction': function(finished) { - var db = new sqlite3.Database(''); + 'insert without transaction': async function(finished) { + const db = await sqlite3.Database.create(''); - db.serialize(function() { - db.run("CREATE TABLE foo (id INT, txt TEXT)"); - var stmt = db.prepare("INSERT INTO foo VALUES (?, ?)"); - for (var i = 0; i < iterations; i++) { - stmt.run(i, 'Row ' + i); + await db.serialize(async function() { + await db.run("CREATE TABLE foo (id INT, txt TEXT)"); + const stmt = await db.prepare("INSERT INTO foo VALUES (?, ?)"); + for (let i = 0; i < iterations; i++) { + await stmt.run(i, 'Row ' + i); } - stmt.finalize(); + await stmt.finalize(); }); - db.close(finished); + await db.close(); + finished(); } -}; \ No newline at end of file +}; diff --git a/tools/benchmark/select.js b/tools/benchmark/select.js index be4b0e71..c9977358 100644 --- a/tools/benchmark/select.js +++ b/tools/benchmark/select.js @@ -1,28 +1,28 @@ const sqlite3 = require('../../'); const { readFileSync } = require('fs'); -const db = new sqlite3.Database(':memory:'); -db.serialize(() => { - db.exec(readFileSync(`${__dirname}/select-data.sql`, 'utf8'), (err) => { - if (err) throw err; - console.time('db.each'); - }); - { - const results = []; - db.each('SELECT * FROM foo', (err, row) => { - if (err) throw err; - results.push(row); - }, () => { +async function benchmark() { + const db = await sqlite3.Database.create(':memory:'); + + await db.serialize(async () => { + await db.exec(readFileSync(`${__dirname}/select-data.sql`, 'utf8')); + console.time('db.each'); + + { + const results = []; + for await (const row of await db.each('SELECT * FROM foo')) { + results.push(row); + } console.timeEnd('db.each'); console.time('db.all'); - }); - } - - db.all('SELECT * FROM foo', (err, rows) => { + } + + await db.all('SELECT * FROM foo'); console.timeEnd('db.all'); - if (err) throw err; + + await db.close(); }); +} - db.close(); -}); +benchmark();