better-sqlite3-multiple-ciphers 7.4.7-beta.1 → 7.5.0-beta.0

package/test/14.database.exec.js

@@ -1,46 +0,0 @@
-'use strict';
-const Database = require('../.');
-
-describe('Database#exec()', function () {
-	beforeEach(function () {
-		this.db = new Database(util.next());
-	});
-	afterEach(function () {
-		this.db.close();
-	});
-
-	it('should throw an exception if a string is not provided', function () {
-		expect(() => this.db.exec(123)).to.throw(TypeError);
-		expect(() => this.db.exec(0)).to.throw(TypeError);
-		expect(() => this.db.exec(null)).to.throw(TypeError);
-		expect(() => this.db.exec()).to.throw(TypeError);
-		expect(() => this.db.exec(new String('CREATE TABLE entries (a TEXT, b INTEGER)'))).to.throw(TypeError);
-	});
-	it('should throw an exception if invalid SQL is provided', function () {
-		expect(() => this.db.exec('CREATE TABLE entries (a TEXT, b INTEGER')).to.throw(Database.SqliteError).with.property('code', 'SQLITE_ERROR');
-	});
-	it('should obey the restrictions of readonly mode', function () {
-		this.db.close();
-		this.db = new Database(util.current(), { readonly: true });
-		expect(() => this.db.exec('CREATE TABLE people (name TEXT)')).to.throw(Database.SqliteError).with.property('code', 'SQLITE_READONLY');
-		this.db.exec('SELECT 555');
-	});
-	it('should execute the SQL, returning the database object itself', function () {
-		const returnValues = [];
-
-		const r1 = this.db.exec('CREATE TABLE entries (a TEXT, b INTEGER)');
-		const r2 = this.db.exec("INSERT INTO entries VALUES ('foobar', 44); INSERT INTO entries VALUES ('baz', NULL);");
-		const r3 = this.db.exec('SELECT * FROM entries');
-
-		expect(r1).to.equal(this.db);
-		expect(r2).to.equal(this.db);
-		expect(r3).to.equal(this.db);
-
-		const rows = this.db.prepare('SELECT * FROM entries ORDER BY rowid').all();
-		expect(rows.length).to.equal(2);
-		expect(rows[0].a).to.equal('foobar');
-		expect(rows[0].b).to.equal(44);
-		expect(rows[1].a).to.equal('baz');
-		expect(rows[1].b).to.equal(null);
-	});
-});

package/test/20.statement.run.js

@@ -1,170 +0,0 @@
-'use strict';
-const Database = require('../.');
-
-describe('Statement#run()', function () {
-	beforeEach(function () {
-		this.db = new Database(util.next());
-		this.db.init = (data = false) => {
-			this.db.info = this.db.prepare('CREATE TABLE entries (a TEXT, b INTEGER, c REAL, d BLOB)').run();
-			if (data) {
-				this.db.prepare('CREATE TABLE people (id INTEGER PRIMARY KEY, name TEXT)').run();
-				this.db.prepare('CREATE TABLE ages (age INTEGER, person INTEGER NOT NULL REFERENCES people(id) ON DELETE CASCADE ON UPDATE CASCADE)').run();
-				this.db.prepare("INSERT INTO entries VALUES ('foo', 25, 3.14, x'1133ddff'), ('foo', 25, 3.14, x'1133ddff'), ('foo', 25, 3.14, x'1133ddff')").run();
-				this.db.prepare("INSERT INTO people VALUES (1, 'bob'), (2, 'sarah')").run();
-			}
-			return this.db;
-		};
-	});
-	afterEach(function () {
-		this.db.close();
-	});
-
-	it('should work with CREATE TABLE', function () {
-		const { info } = this.db.init();
-		expect(info.changes).to.equal(0);
-		expect(info.lastInsertRowid).to.equal(0);
-	});
-	it('should work with CREATE TABLE IF NOT EXISTS', function () {
-		const stmt = this.db.init().prepare('CREATE TABLE IF NOT EXISTS entries (a TEXT, b INTEGER, c REAL, d BLOB)');
-		const info = stmt.run();
-		expect(info.changes).to.equal(0);
-		expect(info.lastInsertRowid).to.equal(0);
-	});
-	it('should work with SELECT', function () {
-		const stmt = this.db.prepare('SELECT 555');
-		const info = stmt.run();
-		expect(info.changes).to.equal(0);
-		expect(info.lastInsertRowid).to.equal(0);
-	});
-	it('should work with INSERT INTO', function () {
-		let stmt = this.db.init().prepare("INSERT INTO entries VALUES ('foo', 25, 3.14, x'1133ddff')");
-		let info = stmt.run();
-		expect(info.changes).to.equal(1);
-		expect(info.lastInsertRowid).to.equal(1);
-
-		info = stmt.run();
-		expect(info.changes).to.equal(1);
-		expect(info.lastInsertRowid).to.equal(2);
-
-		stmt = this.db.prepare("INSERT INTO entries VALUES ('foo', 25, 3.14, x'1133ddff'), ('foo', 25, 3.14, x'1133ddff')");
-		info = stmt.run();
-		expect(info.changes).to.equal(2);
-		expect(info.lastInsertRowid).to.equal(4);
-	});
-	it('should work with UPDATE', function () {
-		const stmt = this.db.init(true).prepare("UPDATE entries SET a='bar' WHERE rowid=1");
-		expect(stmt.run().changes).to.equal(1);
-	});
-	it('should work with DELETE FROM', function () {
-		let stmt = this.db.init(true).prepare("DELETE FROM entries WHERE a='foo'");
-		expect(stmt.run().changes).to.equal(3);
-
-		stmt = this.db.prepare("INSERT INTO entries VALUES ('foo', 25, 3.14, x'1133ddff')");
-		stmt.run();
-		const info = stmt.run();
-		expect(info.changes).to.equal(1);
-		expect(info.lastInsertRowid).to.equal(2);
-	});
-	it('should work with BEGIN and COMMIT', function () {
-		expect(this.db.init(true).inTransaction).to.equal(false);
-		expect(this.db.prepare("BEGIN TRANSACTION").run().changes).to.equal(0);
-		expect(this.db.inTransaction).to.equal(true);
-		const info = this.db.prepare("INSERT INTO entries VALUES ('foo', 25, 3.14, x'1133ddff')").run();
-		expect(info.changes).to.equal(1);
-		expect(info.lastInsertRowid).to.equal(4);
-		expect(this.db.inTransaction).to.equal(true);
-		expect(this.db.prepare("COMMIT TRANSACTION").run().changes).to.equal(0);
-		expect(this.db.inTransaction).to.equal(false);
-	});
-	it('should work with DROP TABLE', function () {
-		const stmt = this.db.init(true).prepare("DROP TABLE entries");
-		expect(stmt.run().changes).to.equal(0);
-	});
-	it('should throw an exception for failed constraints', function () {
-		this.db.init(true).prepare("INSERT INTO ages VALUES (25, 1)").run();
-		this.db.prepare("INSERT INTO ages VALUES (30, 2)").run();
-		this.db.prepare("INSERT INTO ages VALUES (35, 2)").run();
-		let stmt = this.db.prepare("INSERT INTO ages VALUES (30, 3)");
-		expect(() => stmt.run()).to.throw(Database.SqliteError).with.property('code', 'SQLITE_CONSTRAINT_FOREIGNKEY');
-		stmt = this.db.prepare("INSERT INTO ages VALUES (30, NULL)");
-		expect(() => stmt.run()).to.throw(Database.SqliteError).with.property('code', 'SQLITE_CONSTRAINT_NOTNULL');
-	});
-	it('should allow ad-hoc transactions', function () {
-		expect(this.db.init(true).prepare("BEGIN TRANSACTION").run().changes).to.equal(0);
-		expect(this.db.prepare("INSERT INTO ages VALUES (45, 2)").run().changes).to.equal(1);
-		const stmt = this.db.prepare("INSERT INTO ages VALUES (30, 3)");
-		expect(() => stmt.run()).to.throw(Database.SqliteError).with.property('code', 'SQLITE_CONSTRAINT_FOREIGNKEY');
-		expect(this.db.prepare("ROLLBACK TRANSACTION").run().changes).to.equal(0);
-	});
-	it('should not count changes from indirect mechanisms', function () {
-		const stmt = this.db.init(true).prepare("UPDATE people SET id=55 WHERE id=2");
-		expect(stmt.run().changes).to.equal(1);
-	});
-	it('should count accurate DELETE changes when a dropped table has side effects', function () {
-		const stmt = this.db.init(true).prepare("DROP TABLE people");
-		expect(stmt.run().changes).to.equal(2);
-	});
-	it('should obey the restrictions of readonly mode', function () {
-		this.db.close();
-		this.db = new Database(util.current(), { readonly: true });
-		const stmt = this.db.prepare('CREATE TABLE people (name TEXT)');
-		expect(() => stmt.run()).to.throw(Database.SqliteError).with.property('code', 'SQLITE_READONLY');
-	});
-	it('should accept bind parameters', function () {
-		this.db.prepare("CREATE TABLE entries (a TEXT CHECK(typeof(a)=='text'), b INTEGER CHECK(typeof(b)=='integer' OR typeof(b)=='real'), c REAL CHECK(typeof(c)=='real' OR typeof(c)=='integer'), d BLOB CHECK(typeof(d)=='blob'))").run();
-		this.db.prepare('INSERT INTO entries VALUES (?, ?, ?, ?)').run('foo', 25, 25, Buffer.alloc(8).fill(0xdd));
-		this.db.prepare('INSERT INTO entries VALUES (?, ?, ?, ?)').run(['foo', 25, 25, Buffer.alloc(8).fill(0xdd)]);
-		this.db.prepare('INSERT INTO entries VALUES (?, ?, ?, ?)').run(['foo', 25], [25], Buffer.alloc(8).fill(0xdd));
-		this.db.prepare('INSERT INTO entries VALUES (@a, @b, @c, @d)').run({ a: 'foo', b: 25, c: 25, d: Buffer.alloc(8).fill(0xdd) });
-		this.db.prepare('INSERT INTO entries VALUES ($a, $b, $c, $d)').run({ a: 'foo', b: 25, c: 25, d: Buffer.alloc(8).fill(0xdd) });
-		this.db.prepare('INSERT INTO entries VALUES (:a, :b, :c, :d)').run({ a: 'foo', b: 25, c: 25, d: Buffer.alloc(8).fill(0xdd) });
-		this.db.prepare('INSERT INTO entries VALUES (?, @a, @a, ?)').run({ a: 25 }, ['foo'], Buffer.alloc(8).fill(0xdd));
-		expect(() =>
-			this.db.prepare('INSERT INTO entries VALUES (?, @a, @a, ?)').run({ a: 25 }, ['foo'], Buffer.alloc(8).fill(0xdd), Buffer.alloc(8).fill(0xdd))
-		).to.throw(RangeError);
-		expect(() =>
-			this.db.prepare('INSERT INTO entries VALUES (?, @a, @a, ?)').run({ a: 25 }, ['foo'])
-		).to.throw(RangeError);
-		this.db.prepare('INSERT INTO entries VALUES (?, @a, @a, ?)').run({ a: 25, c: 25 }, ['foo'], Buffer.alloc(8).fill(0xdd));
-		expect(() =>
-			this.db.prepare('INSERT INTO entries VALUES (?, @a, @a, ?)').run({}, ['foo'], Buffer.alloc(8).fill(0xdd))
-		).to.throw(RangeError);
-		expect(() =>
-			this.db.prepare('INSERT INTO entries VALUES (?, ?, ?, ?)').run(25, 'foo', 25, Buffer.alloc(8).fill(0xdd))
-		).to.throw(Database.SqliteError).with.property('code', 'SQLITE_CONSTRAINT_CHECK');
-		this.db.prepare('INSERT INTO entries VALUES (?, ?, ?, ?)').run('foo', 25, 25, Buffer.alloc(8).fill(0xdd), {});
-		this.db.prepare('INSERT INTO entries VALUES (?, ?, ?, ?)').run('foo', 25, 25, Buffer.alloc(8).fill(0xdd), { foo: 'foo' });
-		expect(() =>
-			this.db.prepare('INSERT INTO entries VALUES (?, ?, ?, ?)').run('foo', 25, 25, { 4: Buffer.alloc(8).fill(0xdd) })
-		).to.throw(RangeError);
-		expect(() =>
-			this.db.prepare('INSERT INTO entries VALUES (?, ?, ?, ?)').run()
-		).to.throw(RangeError);
-		expect(() =>
-			this.db.prepare('INSERT INTO entries VALUES (?, ?, ?, ?)').run({ length: 4, 0: 'foo', 1: 25, 2: 25, 3: Buffer.alloc(8).fill(0xdd) })
-		).to.throw(RangeError);
-		expect(() =>
-			this.db.prepare('INSERT INTO entries VALUES (?, ?, ?, ?)').run('foo', 25, new Number(25), Buffer.alloc(8).fill(0xdd))
-		).to.throw(TypeError);
-		expect(() =>
-			this.db.prepare('INSERT INTO entries VALUES (?, ?, ?, ?)').run('foo', { low: 25, high: 25 }, 25, Buffer.alloc(8).fill(0xdd))
-		).to.throw(RangeError);
-		function Foo() {
-			this.a = 'foo';
-			this.b = 25;
-			this.c = 25;
-			this.d = Buffer.alloc(8).fill(0xdd);
-		}
-		expect(() =>
-			this.db.prepare('INSERT INTO entries VALUES (@a, @b, @c, @d)').run(new Foo)
-		).to.throw(TypeError);
-
-		// This part of the test may fail is Statement#get() does not work.
-		let i = 0;
-		let row;
-		while (row = this.db.prepare(`SELECT * FROM entries WHERE rowid=${++i}`).get()) {
-			expect(row).to.deep.equal({ a: 'foo', b: 25, c: 25, d: Buffer.alloc(8).fill(0xdd) });
-		}
-		expect(i).to.equal(11);
-	});
-});

package/test/21.statement.get.js

@@ -1,109 +0,0 @@
-'use strict';
-const Database = require('../.');
-
-describe('Statement#get()', function () {
-	beforeEach(function () {
-		this.db = new Database(util.next());
-		this.db.prepare('CREATE TABLE entries (a TEXT, b INTEGER, c REAL, d BLOB, e TEXT)').run();
-		this.db.prepare("INSERT INTO entries WITH RECURSIVE temp(a, b, c, d, e) AS (SELECT 'foo', 1, 3.14, x'dddddddd', NULL UNION ALL SELECT a, b + 1, c, d, e FROM temp LIMIT 10) SELECT * FROM temp").run();
-	});
-	afterEach(function () {
-		this.db.close();
-	});
-
-	it('should throw an exception when used on a statement that returns no data', function () {
-		let stmt = this.db.prepare("INSERT INTO entries VALUES ('foo', 1, 3.14, x'dddddddd', NULL)");
-		expect(stmt.reader).to.be.false;
-		expect(() => stmt.get()).to.throw(TypeError);
-
-		stmt = this.db.prepare("CREATE TABLE IF NOT EXISTS entries (a TEXT, b INTEGER, c REAL, d BLOB, e TEXT)");
-		expect(stmt.reader).to.be.false;
-		expect(() => stmt.get()).to.throw(TypeError);
-
-		stmt = this.db.prepare("BEGIN TRANSACTION");
-		expect(stmt.reader).to.be.false;
-		expect(() => stmt.get()).to.throw(TypeError);
-	});
-	it('should return the first matching row', function () {
-		let stmt = this.db.prepare("SELECT * FROM entries ORDER BY rowid");
-		expect(stmt.reader).to.be.true;
-		expect(stmt.get()).to.deep.equal({ a: 'foo', b: 1, c: 3.14, d: Buffer.alloc(4).fill(0xdd), e: null });
-
-		stmt = this.db.prepare("SELECT * FROM entries WHERE b > 5 ORDER BY rowid");
-		expect(stmt.get()).to.deep.equal({ a: 'foo', b: 6, c: 3.14, d: Buffer.alloc(4).fill(0xdd), e: null });
-	});
-	it('should work with RETURNING clause', function () {
-		let stmt = this.db.prepare("INSERT INTO entries (a, b) VALUES ('bar', 888), ('baz', 999) RETURNING *");
-		expect(stmt.reader).to.be.true;
-		expect(stmt.get()).to.deep.equal({ a: 'bar', b: 888, c: null, d: null, e: null });
-
-		stmt = this.db.prepare("SELECT * FROM entries WHERE b > 900 ORDER BY rowid");
-		expect(stmt.get()).to.deep.equal({ a: 'baz', b: 999, c: null, d: null, e: null });
-	});
-	it('should obey the current pluck and expand settings', function () {
-		const stmt = this.db.prepare("SELECT *, 2 + 3.5 AS c FROM entries ORDER BY rowid");
-		const expanded = { entries: { a: 'foo', b: 1, c: 3.14, d: Buffer.alloc(4).fill(0xdd), e: null }, $: { c: 5.5 } };
-		const row = Object.assign({}, expanded.entries, expanded.$);
-		const plucked = expanded.entries.a;
-		const raw = Object.values(expanded.entries).concat(expanded.$.c);
-		expect(stmt.get()).to.deep.equal(row);
-		expect(stmt.pluck(true).get()).to.deep.equal(plucked);
-		expect(stmt.get()).to.deep.equal(plucked);
-		expect(stmt.pluck(false).get()).to.deep.equal(row);
-		expect(stmt.get()).to.deep.equal(row);
-		expect(stmt.pluck().get()).to.deep.equal(plucked);
-		expect(stmt.get()).to.deep.equal(plucked);
-		expect(stmt.expand().get()).to.deep.equal(expanded);
-		expect(stmt.get()).to.deep.equal(expanded);
-		expect(stmt.expand(false).get()).to.deep.equal(row);
-		expect(stmt.get()).to.deep.equal(row);
-		expect(stmt.expand(true).get()).to.deep.equal(expanded);
-		expect(stmt.get()).to.deep.equal(expanded);
-		expect(stmt.pluck(true).get()).to.deep.equal(plucked);
-		expect(stmt.get()).to.deep.equal(plucked);
-		expect(stmt.raw().get()).to.deep.equal(raw);
-		expect(stmt.get()).to.deep.equal(raw);
-		expect(stmt.raw(false).get()).to.deep.equal(row);
-		expect(stmt.get()).to.deep.equal(row);
-		expect(stmt.raw(true).get()).to.deep.equal(raw);
-		expect(stmt.get()).to.deep.equal(raw);
-		expect(stmt.expand(true).get()).to.deep.equal(expanded);
-		expect(stmt.get()).to.deep.equal(expanded);
-	});
-	it('should return undefined when no rows were found', function () {
-		const stmt = this.db.prepare("SELECT * FROM entries WHERE b == 999");
-		expect(stmt.get()).to.be.undefined;
-		expect(stmt.pluck().get()).to.be.undefined;
-	});
-	it('should accept bind parameters', function () {
-		const row = { a: 'foo', b: 1, c: 3.14, d: Buffer.alloc(4).fill(0xdd), e: null };
-		const SQL1 = 'SELECT * FROM entries WHERE a=? AND b=? AND c=? AND d=? AND e IS ?';
-		const SQL2 = 'SELECT * FROM entries WHERE a=@a AND b=@b AND c=@c AND d=@d AND e IS @e';
-		let result = this.db.prepare(SQL1).get('foo', 1, 3.14, Buffer.alloc(4).fill(0xdd), null);
-		expect(result).to.deep.equal(row);
-
-		result = this.db.prepare(SQL1).get(['foo', 1, 3.14, Buffer.alloc(4).fill(0xdd), null]);
-		expect(result).to.deep.equal(row);
-
-		result = this.db.prepare(SQL1).get(['foo', 1], [3.14], Buffer.alloc(4).fill(0xdd), [,]);
-		expect(result).to.deep.equal(row);
-
-		result = this.db.prepare(SQL2).get({ a: 'foo', b: 1, c: 3.14, d: Buffer.alloc(4).fill(0xdd), e: undefined });
-		expect(result).to.deep.equal(row);
-
-		result = this.db.prepare(SQL2).get({ a: 'foo', b: 1, c: 3.14, d: Buffer.alloc(4).fill(0xaa), e: undefined });
-		expect(result).to.be.undefined;
-
-		expect(() =>
-			this.db.prepare(SQL2).get({ a: 'foo', b: 1, c: 3.14, d: Buffer.alloc(4).fill(0xdd) })
-		).to.throw(RangeError);
-
-		expect(() =>
-			this.db.prepare(SQL1).get()
-		).to.throw(RangeError);
-
-		expect(() =>
-			this.db.prepare(SQL2).get({})
-		).to.throw(RangeError);
-	});
-});

package/test/22.statement.all.js

@@ -1,129 +0,0 @@
-'use strict';
-const Database = require('../.');
-
-describe('Statement#all()', function () {
-	beforeEach(function () {
-		this.db = new Database(util.next());
-		this.db.prepare('CREATE TABLE entries (a TEXT, b INTEGER, c REAL, d BLOB, e TEXT)').run();
-		this.db.prepare("INSERT INTO entries WITH RECURSIVE temp(a, b, c, d, e) AS (SELECT 'foo', 1, 3.14, x'dddddddd', NULL UNION ALL SELECT a, b + 1, c, d, e FROM temp LIMIT 10) SELECT * FROM temp").run();
-	});
-	afterEach(function () {
-		this.db.close();
-	});
-
-	it('should throw an exception when used on a statement that returns no data', function () {
-		let stmt = this.db.prepare("INSERT INTO entries VALUES ('foo', 1, 3.14, x'dddddddd', NULL)");
-		expect(stmt.reader).to.be.false;
-		expect(() => stmt.all()).to.throw(TypeError);
-
-		stmt = this.db.prepare("CREATE TABLE IF NOT EXISTS entries (a TEXT, b INTEGER, c REAL, d BLOB, e TEXT)");
-		expect(stmt.reader).to.be.false;
-		expect(() => stmt.all()).to.throw(TypeError);
-
-		stmt = this.db.prepare("BEGIN TRANSACTION");
-		expect(stmt.reader).to.be.false;
-		expect(() => stmt.all()).to.throw(TypeError);
-	});
-	it('should return an array of every matching row', function () {
-		const row = { a: 'foo', b: 1, c: 3.14, d: Buffer.alloc(4).fill(0xdd), e: null };
-
-		let stmt = this.db.prepare("SELECT * FROM entries ORDER BY rowid");
-		expect(stmt.reader).to.be.true;
-		matchesFrom(stmt.all(), 1);
-
-		stmt = this.db.prepare("SELECT * FROM entries WHERE b > 5 ORDER BY rowid");
-		matchesFrom(stmt.all(), 6);
-
-		function matchesFrom(rows, i) {
-			let index = 0;
-			for (; i <= 10; ++i, ++index) {
-				row.b = i;
-				expect(rows[index]).to.deep.equal(row);
-			}
-			expect(index).to.equal(rows.length);
-		}
-	});
-	it('should work with RETURNING clause', function () {
-		let stmt = this.db.prepare("INSERT INTO entries (a, b) VALUES ('bar', 888), ('baz', 999) RETURNING *");
-		expect(stmt.reader).to.be.true;
-		expect(stmt.all()).to.deep.equal([
-			{ a: 'bar', b: 888, c: null, d: null, e: null },
-			{ a: 'baz', b: 999, c: null, d: null, e: null },
-		]);
-
-		stmt = this.db.prepare("SELECT * FROM entries WHERE b > 800 ORDER BY rowid");
-		expect(stmt.all()).to.deep.equal([
-			{ a: 'bar', b: 888, c: null, d: null, e: null },
-			{ a: 'baz', b: 999, c: null, d: null, e: null },
-		]);
-	});
-	it('should obey the current pluck and expand settings', function () {
-		const stmt = this.db.prepare("SELECT *, 2 + 3.5 AS c FROM entries ORDER BY rowid");
-		const expanded = new Array(10).fill().map((_, i) => ({
-			entries: { a: 'foo', b: i + 1, c: 3.14, d: Buffer.alloc(4).fill(0xdd), e: null },
-			$: { c: 5.5 },
-		}));
-		const rows = expanded.map(x => Object.assign({}, x.entries, x.$));
-		const plucked = expanded.map(x => x.entries.a);
-		const raw = expanded.map(x => Object.values(x.entries).concat(x.$.c))
-		expect(stmt.all()).to.deep.equal(rows);
-		expect(stmt.pluck(true).all()).to.deep.equal(plucked);
-		expect(stmt.all()).to.deep.equal(plucked);
-		expect(stmt.pluck(false).all()).to.deep.equal(rows);
-		expect(stmt.all()).to.deep.equal(rows);
-		expect(stmt.pluck().all()).to.deep.equal(plucked);
-		expect(stmt.all()).to.deep.equal(plucked);
-		expect(stmt.expand().all()).to.deep.equal(expanded);
-		expect(stmt.all()).to.deep.equal(expanded);
-		expect(stmt.expand(false).all()).to.deep.equal(rows);
-		expect(stmt.all()).to.deep.equal(rows);
-		expect(stmt.expand(true).all()).to.deep.equal(expanded);
-		expect(stmt.all()).to.deep.equal(expanded);
-		expect(stmt.pluck(true).all()).to.deep.equal(plucked);
-		expect(stmt.all()).to.deep.equal(plucked);
-		expect(stmt.raw().all()).to.deep.equal(raw);
-		expect(stmt.all()).to.deep.equal(raw);
-		expect(stmt.raw(false).all()).to.deep.equal(rows);
-		expect(stmt.all()).to.deep.equal(rows);
-		expect(stmt.raw(true).all()).to.deep.equal(raw);
-		expect(stmt.all()).to.deep.equal(raw);
-		expect(stmt.expand(true).all()).to.deep.equal(expanded);
-		expect(stmt.all()).to.deep.equal(expanded);
-	});
-	it('should return an empty array when no rows were found', function () {
-		const stmt = this.db.prepare("SELECT * FROM entries WHERE b == 999");
-		expect(stmt.all()).to.deep.equal([]);
-		expect(stmt.pluck().all()).to.deep.equal([]);
-	});
-	it('should accept bind parameters', function () {
-		const rows = [{ a: 'foo', b: 1, c: 3.14, d: Buffer.alloc(4).fill(0xdd), e: null }];
-		const SQL1 = 'SELECT * FROM entries WHERE a=? AND b=? AND c=? AND d=? AND e IS ?';
-		const SQL2 = 'SELECT * FROM entries WHERE a=@a AND b=@b AND c=@c AND d=@d AND e IS @e';
-		let result = this.db.prepare(SQL1).all('foo', 1, 3.14, Buffer.alloc(4).fill(0xdd), null);
-		expect(result).to.deep.equal(rows);
-
-		result = this.db.prepare(SQL1).all(['foo', 1, 3.14, Buffer.alloc(4).fill(0xdd), null]);
-		expect(result).to.deep.equal(rows);
-
-		result = this.db.prepare(SQL1).all(['foo', 1], [3.14], Buffer.alloc(4).fill(0xdd), [,]);
-		expect(result).to.deep.equal(rows);
-
-		result = this.db.prepare(SQL2).all({ a: 'foo', b: 1, c: 3.14, d: Buffer.alloc(4).fill(0xdd), e: undefined });
-		expect(result).to.deep.equal(rows);
-
-		result = this.db.prepare(SQL2).all({ a: 'foo', b: 1, c: 3.14, d: Buffer.alloc(4).fill(0xaa), e: undefined });
-		expect(result).to.deep.equal([]);
-
-		expect(() =>
-			this.db.prepare(SQL2).all({ a: 'foo', b: 1, c: 3.14, d: Buffer.alloc(4).fill(0xdd) })
-		).to.throw(RangeError);
-
-		expect(() =>
-			this.db.prepare(SQL1).all()
-		).to.throw(RangeError);
-
-		expect(() =>
-			this.db.prepare(SQL2).all({})
-		).to.throw(RangeError);
-	});
-});

package/test/23.statement.iterate.js

@@ -1,223 +0,0 @@
-'use strict';
-const Database = require('../.');
-
-describe('Statement#iterate()', function () {
-	beforeEach(function () {
-		this.db = new Database(util.next());
-		this.db.prepare("CREATE TABLE entries (a TEXT, b INTEGER, c REAL, d BLOB, e TEXT)").run();
-		this.db.prepare("INSERT INTO entries WITH RECURSIVE temp(a, b, c, d, e) AS (SELECT 'foo', 1, 3.14, x'dddddddd', NULL UNION ALL SELECT a, b + 1, c, d, e FROM temp LIMIT 10) SELECT * FROM temp").run();
-	});
-	afterEach(function () {
-		this.db.close();
-	});
-
-	it('should throw an exception when used on a statement that returns no data', function () {
-		let stmt = this.db.prepare("INSERT INTO entries VALUES ('foo', 1, 3.14, x'dddddddd', NULL)");
-		expect(stmt.reader).to.be.false;
-		expect(() => stmt.iterate()).to.throw(TypeError);
-
-		stmt = this.db.prepare("CREATE TABLE IF NOT EXISTS entries (a TEXT, b INTEGER, c REAL, d BLOB, e TEXT)");
-		expect(stmt.reader).to.be.false;
-		expect(() => stmt.iterate()).to.throw(TypeError);
-
-		stmt = this.db.prepare("BEGIN TRANSACTION");
-		expect(stmt.reader).to.be.false;
-		expect(() => stmt.iterate()).to.throw(TypeError);
-
-		this.db.prepare("INSERT INTO entries WITH RECURSIVE temp(a, b, c, d, e) AS (SELECT 'foo', 1, 3.14, x'dddddddd', NULL UNION ALL SELECT a, b + 1, c, d, e FROM temp LIMIT 10) SELECT * FROM temp").run();
-	});
-	it('should return an iterator over each matching row', function () {
-		const row = { a: 'foo', b: 1, c: 3.14, d: Buffer.alloc(4).fill(0xdd), e: null };
-
-		let count = 0;
-		let stmt = this.db.prepare("SELECT * FROM entries ORDER BY rowid");
-		expect(stmt.reader).to.be.true;
-
-		const iterator = stmt.iterate();
-		expect(iterator).to.not.be.null;
-		expect(typeof iterator).to.equal('object');
-		expect(iterator.next).to.be.a('function');
-		expect(iterator.return).to.be.a('function');
-		expect(iterator.throw).to.not.be.a('function');
-		expect(iterator[Symbol.iterator]).to.be.a('function');
-		expect(iterator[Symbol.iterator]()).to.equal(iterator);
-
-		for (const data of iterator) {
-			row.b = ++count;
-			expect(data).to.deep.equal(row);
-		}
-		expect(count).to.equal(10);
-
-		count = 0;
-		stmt = this.db.prepare("SELECT * FROM entries WHERE b > 5 ORDER BY rowid");
-		const iterator2 = stmt.iterate();
-		expect(iterator).to.not.equal(iterator2);
-		for (const data of iterator2) {
-			row.b = ++count + 5;
-			expect(data).to.deep.equal(row);
-		}
-		expect(count).to.equal(5);
-	});
-	it('should work with RETURNING clause', function () {
-		let stmt = this.db.prepare("INSERT INTO entries (a, b) VALUES ('bar', 888), ('baz', 999) RETURNING *");
-		expect(stmt.reader).to.be.true;
-		expect([...stmt.iterate()]).to.deep.equal([
-			{ a: 'bar', b: 888, c: null, d: null, e: null },
-			{ a: 'baz', b: 999, c: null, d: null, e: null },
-		]);
-
-		stmt = this.db.prepare("SELECT * FROM entries WHERE b > 800 ORDER BY rowid");
-		expect([...stmt.iterate()]).to.deep.equal([
-			{ a: 'bar', b: 888, c: null, d: null, e: null },
-			{ a: 'baz', b: 999, c: null, d: null, e: null },
-		]);
-	});
-	it('should obey the current pluck and expand settings', function () {
-		const shouldHave = (desiredData) => {
-			let i = 0;
-			for (const data of stmt.iterate()) {
-				i += 1;
-				if (typeof desiredData === 'object' && desiredData !== null) {
-					if (Array.isArray(desiredData)) {
-						desiredData[1] = i;
-					} else if (typeof desiredData.entries === 'object' && desiredData.entries !== null) {
-						desiredData.entries.b = i;
-					} else {
-						desiredData.b = i;
-					}
-				}
-				expect(data).to.deep.equal(desiredData);
-			}
-			expect(i).to.equal(10);
-		};
-		const expanded = {
-			entries: { a: 'foo', b: 1, c: 3.14, d: Buffer.alloc(4).fill(0xdd), e: null },
-			$: { c: 5.5 },
-		};
-		const row = Object.assign({}, expanded.entries, expanded.$);
-		const plucked = expanded.entries.a;
-		const raw = Object.values(expanded.entries).concat(expanded.$.c);
-		const stmt = this.db.prepare("SELECT *, 2 + 3.5 AS c FROM entries ORDER BY rowid");
-		shouldHave(row);
-		stmt.pluck(true);
-		shouldHave(plucked);
-		shouldHave(plucked);
-		stmt.pluck(false);
-		shouldHave(row);
-		shouldHave(row);
-		stmt.pluck();
-		shouldHave(plucked);
-		shouldHave(plucked);
-		stmt.expand();
-		shouldHave(expanded);
-		shouldHave(expanded);
-		stmt.expand(false);
-		shouldHave(row);
-		shouldHave(row);
-		stmt.expand(true);
-		shouldHave(expanded);
-		shouldHave(expanded);
-		stmt.pluck(true);
-		shouldHave(plucked);
-		shouldHave(plucked);
-		stmt.raw();
-		shouldHave(raw);
-		shouldHave(raw);
-		stmt.raw(false);
-		shouldHave(row);
-		shouldHave(row);
-		stmt.raw(true);
-		shouldHave(raw);
-		shouldHave(raw);
-		stmt.expand(true);
-		shouldHave(expanded);
-		shouldHave(expanded);
-	});
-	it('should close the iterator when throwing in a for-of loop', function () {
-		const err = new Error('foobar');
-		const stmt = this.db.prepare("SELECT * FROM entries ORDER BY rowid");
-		const iterator = stmt.iterate();
-		let count = 0;
-		expect(() => {
-			for (const row of iterator) { ++count; throw err; }
-		}).to.throw(err);
-		expect(count).to.equal(1);
-		expect(iterator.next()).to.deep.equal({ value: undefined, done: true });
-		for (const row of iterator) ++count;
-		expect(count).to.equal(1);
-		for (const row of stmt.iterate()) ++count;
-		expect(count).to.equal(11);
-	});
-	it('should close the iterator when using break in a for-of loop', function () {
-		const stmt = this.db.prepare("SELECT * FROM entries ORDER BY rowid");
-		const iterator = stmt.iterate();
-		let count = 0;
-		for (const row of iterator) { ++count; break; }
-		expect(count).to.equal(1);
-		expect(iterator.next()).to.deep.equal({ value: undefined, done: true });
-		for (const row of iterator) ++count;
-		expect(count).to.equal(1);
-		for (const row of stmt.iterate()) ++count;
-		expect(count).to.equal(11);
-	});
-	it('should return an empty iterator when no rows were found', function () {
-		const stmt = this.db.prepare("SELECT * FROM entries WHERE b == 999");
-		expect(stmt.iterate().next()).to.deep.equal({ value: undefined, done: true });
-		for (const data of stmt.pluck().iterate()) {
-			throw new Error('This callback should not have been invoked');
-		}
-	});
-	it('should accept bind parameters', function () {
-		const shouldHave = (SQL, desiredData, args) => {
-			let i = 0;
-			const stmt = this.db.prepare(SQL);
-			for (const data of stmt.iterate(...args)) {
-				desiredData.b = ++i;
-				expect(data).to.deep.equal(desiredData);
-			}
-			expect(i).to.equal(1);
-		};
-
-		const row = { a: 'foo', b: 1, c: 3.14, d: Buffer.alloc(4).fill(0xdd), e: null };
-		const SQL1 = 'SELECT * FROM entries WHERE a=? AND b=? AND c=? AND d=? AND e IS ?';
-		const SQL2 = 'SELECT * FROM entries WHERE a=@a AND b=@b AND c=@c AND d=@d AND e IS @e';
-
-		shouldHave(SQL1, row, ['foo', 1, 3.14, Buffer.alloc(4).fill(0xdd), null]);
-		shouldHave(SQL1, row, [['foo', 1, 3.14, Buffer.alloc(4).fill(0xdd), null]]);
-		shouldHave(SQL1, row, [['foo', 1], [3.14], Buffer.alloc(4).fill(0xdd), [,]]);
-		shouldHave(SQL2, row, [{ a: 'foo', b: 1, c: 3.14, d: Buffer.alloc(4).fill(0xdd), e: undefined }]);
-
-		for (const data of this.db.prepare(SQL2).iterate({ a: 'foo', b: 1, c: 3.14, d: Buffer.alloc(4).fill(0xaa), e: undefined })) {
-			throw new Error('This callback should not have been invoked');
-		}
-
-		expect(() =>
-			this.db.prepare(SQL2).iterate(row, () => {})
-		).to.throw(TypeError);
-
-		expect(() =>
-			this.db.prepare(SQL2).iterate({ a: 'foo', b: 1, c: 3.14, d: Buffer.alloc(4).fill(0xdd) })
-		).to.throw(RangeError);
-
-		expect(() =>
-			this.db.prepare(SQL1).iterate()
-		).to.throw(RangeError);
-
-		expect(() =>
-			this.db.prepare(SQL2).iterate()
-		).to.throw(TypeError);
-
-		expect(() =>
-			this.db.prepare(SQL2).iterate(row, {})
-		).to.throw(TypeError);
-
-		expect(() =>
-			this.db.prepare(SQL2).iterate({})
-		).to.throw(RangeError);
-
-		this.db.prepare(SQL1).iterate('foo', 1, 3.14, Buffer.alloc(4).fill(0xdd), null).return();
-		expect(() =>
-			this.db.prepare(SQL1).iterate('foo', 1, new (function(){})(), Buffer.alloc(4).fill(0xdd), null)
-		).to.throw(TypeError);
-	});
-});