better-sqlite3-multiple-ciphers 7.4.7-beta.1 → 7.5.1-beta.1

package/test/24.statement.bind.js

@@ -1,107 +0,0 @@
-'use strict';
-const Database = require('../.');
-
-describe('Statement#bind()', function () {
-	beforeEach(function () {
-		this.db = new Database(util.next());
-		this.db.prepare('CREATE TABLE entries (a TEXT, b INTEGER, c BLOB)').run();
-	});
-	afterEach(function () {
-		this.db.close();
-	});
-
-	it('should permanently bind the given parameters', function () {
-		const stmt = this.db.prepare('INSERT INTO entries VALUES (?, ?, ?)');
-		const buffer = Buffer.alloc(4).fill(0xdd);
-		stmt.bind('foobar', 25, buffer)
-		stmt.run();
-		buffer.fill(0xaa);
-		stmt.run();
-		const row1 = this.db.prepare('SELECT * FROM entries WHERE rowid=1').get();
-		const row2 = this.db.prepare('SELECT * FROM entries WHERE rowid=2').get();
-		expect(row1.a).to.equal(row2.a);
-		expect(row1.b).to.equal(row2.b);
-		expect(row1.c).to.deep.equal(row2.c);
-	});
-	it('should not allow you to bind temporary parameters afterwards', function () {
-		const stmt = this.db.prepare('INSERT INTO entries VALUES (?, ?, ?)');
-		const buffer = Buffer.alloc(4).fill(0xdd);
-		stmt.bind('foobar', 25, buffer)
-		expect(() => stmt.run(null)).to.throw(TypeError);
-		expect(() => stmt.run(buffer)).to.throw(TypeError);
-		expect(() => stmt.run('foobar', 25, buffer)).to.throw(TypeError);
-	});
-	it('should throw an exception when invoked twice on the same statement', function () {
-		let stmt = this.db.prepare('INSERT INTO entries VALUES (?, ?, ?)');
-		stmt.bind('foobar', 25, null);
-		expect(() => stmt.bind('foobar', 25, null)).to.throw(TypeError);
-		expect(() => stmt.bind()).to.throw(TypeError);
-
-		stmt = this.db.prepare('SELECT * FROM entries');
-		stmt.bind();
-		expect(() => stmt.bind()).to.throw(TypeError);
-	});
-	it('should throw an exception when invalid parameters are given', function () {
-		let stmt = this.db.prepare('INSERT INTO entries VALUES (?, ?, ?)');
-
-		expect(() =>
-			stmt.bind('foo', 25)
-		).to.throw(RangeError);
-
-		expect(() =>
-			stmt.bind('foo', 25, null, null)
-		).to.throw(RangeError);
-
-		expect(() =>
-			stmt.bind('foo', new Number(25), null)
-		).to.throw(TypeError);
-
-		expect(() =>
-			stmt.bind()
-		).to.throw(RangeError);
-
-		stmt.bind('foo', 25, null);
-
-		stmt = this.db.prepare('INSERT INTO entries VALUES (@a, @a, ?)');
-
-		expect(() =>
-			stmt.bind({ a: '123' })
-		).to.throw(RangeError);
-
-		expect(() =>
-			stmt.bind({ a: '123', 1: null })
-		).to.throw(RangeError);
-
-		expect(() =>
-			stmt.bind({ a: '123' }, null, null)
-		).to.throw(RangeError);
-
-		stmt.bind({ a: '123' }, null);
-
-		stmt = this.db.prepare('INSERT INTO entries VALUES (@a, @a, ?)');
-		stmt.bind({ a: '123', b: null }, null);
-	});
-	it('should propagate exceptions thrown while accessing array/object members', function () {
-		const arr = [22];
-		const obj = {};
-		const err = new TypeError('foobar');
-		Object.defineProperty(arr, '0', { get: () => { throw err; } })
-		Object.defineProperty(obj, 'baz', { get: () => { throw err; } })
-		const stmt1 = this.db.prepare('SELECT ?');
-		const stmt2 = this.db.prepare('SELECT @baz');
-		expect(() => stmt1.bind(arr)).to.throw(err);
-		expect(() => stmt2.bind(obj)).to.throw(err);
-	});
-	it('should properly bind empty buffers', function () {
-		this.db.prepare('INSERT INTO entries (c) VALUES (?)').bind(Buffer.alloc(0)).run();
-		const result = this.db.prepare('SELECT c FROM entries').pluck().get();
-		expect(result).to.be.an.instanceof(Buffer);
-		expect(result.length).to.equal(0);
-	});
-	it('should properly bind empty strings', function () {
-		this.db.prepare('INSERT INTO entries (a) VALUES (?)').bind('').run();
-		const result = this.db.prepare('SELECT a FROM entries').pluck().get();
-		expect(result).to.be.a('string');
-		expect(result.length).to.equal(0);
-	});
-});

package/test/25.statement.columns.js

@@ -1,46 +0,0 @@
-'use strict';
-const Database = require('../.');
-
-describe('Statement#columns()', function () {
-	beforeEach(function () {
-		this.db = new Database(util.next());
-		this.db.prepare('CREATE TABLE entries (a TEXT, b INTEGER, c WHATthe)').run();
-	});
-	afterEach(function () {
-		this.db.close();
-	});
-
-	it('should throw an exception if invoked on a non-reader statement', function () {
-		const stmt = this.db.prepare('INSERT INTO entries VALUES (?, ?, ?)');
-		expect(() => stmt.columns()).to.throw(TypeError);
-	});
-	it('should return an array of column descriptors', function () {
-		expect(this.db.prepare('SELECT 5.0 as d, * FROM entries').columns()).to.deep.equal([
-			{ name: 'd', column: null, table: null, database: null, type: null },
-			{ name: 'a', column: 'a', table: 'entries', database: 'main', type: 'TEXT' },
-			{ name: 'b', column: 'b', table: 'entries', database: 'main', type: 'INTEGER' },
-			{ name: 'c', column: 'c', table: 'entries', database: 'main', type: 'WHATthe' },
-		]);
-		expect(this.db.prepare('SELECT a, c as b, b FROM entries').columns()).to.deep.equal([
-			{ name: 'a', column: 'a', table: 'entries', database: 'main', type: 'TEXT' },
-			{ name: 'b', column: 'c', table: 'entries', database: 'main', type: 'WHATthe' },
-			{ name: 'b', column: 'b', table: 'entries', database: 'main', type: 'INTEGER' },
-		]);
-	});
-	it('should not return stale column descriptors after being recompiled', function () {
-		const stmt = this.db.prepare('SELECT * FROM entries');
-		expect(stmt.columns()).to.deep.equal([
-			{ name: 'a', column: 'a', table: 'entries', database: 'main', type: 'TEXT' },
-			{ name: 'b', column: 'b', table: 'entries', database: 'main', type: 'INTEGER' },
-			{ name: 'c', column: 'c', table: 'entries', database: 'main', type: 'WHATthe' },
-		]);
-		this.db.prepare('ALTER TABLE entries ADD COLUMN d FOOBAR').run();
-		stmt.get(); // Recompile
-		expect(stmt.columns()).to.deep.equal([
-			{ name: 'a', column: 'a', table: 'entries', database: 'main', type: 'TEXT' },
-			{ name: 'b', column: 'b', table: 'entries', database: 'main', type: 'INTEGER' },
-			{ name: 'c', column: 'c', table: 'entries', database: 'main', type: 'WHATthe' },
-			{ name: 'd', column: 'd', table: 'entries', database: 'main', type: 'FOOBAR' },
-		]);
-	});
-});

package/test/30.database.transaction.js

@@ -1,157 +0,0 @@
-'use strict';
-const Database = require('../.');
-
-describe('Database#transaction()', function () {
-	beforeEach(function () {
-		this.db = new Database(util.next());
-		this.db.prepare('CREATE TABLE data (x UNIQUE)').run();
-		this.db.prepare('INSERT INTO data VALUES (1), (2), (3)').run();
-	});
-	afterEach(function () {
-		this.db.close();
-	});
-
-	it('should throw an exception if a function is not provided', function () {
-		expect(() => this.db.transaction(123)).to.throw(TypeError);
-		expect(() => this.db.transaction(0)).to.throw(TypeError);
-		expect(() => this.db.transaction(null)).to.throw(TypeError);
-		expect(() => this.db.transaction()).to.throw(TypeError);
-		expect(() => this.db.transaction([])).to.throw(TypeError);
-		expect(() => this.db.transaction('CREATE TABLE people (name TEXT)')).to.throw(TypeError);
-		expect(() => this.db.transaction(['CREATE TABLE people (name TEXT)'])).to.throw(TypeError);
-	});
-	it('should return a new transaction function', function () {
-		const fn = () => {};
-		const trx = this.db.transaction(fn);
-		expect(trx).to.not.equal(fn);
-		expect(trx).to.be.a('function');
-		expect(trx).to.equal(trx.default);
-		const keys = ['default', 'deferred', 'immediate', 'exclusive'];
-		for (const key of keys) {
-			const nested = trx[key];
-			expect(nested).to.not.equal(fn);
-			expect(nested).to.be.a('function');
-			expect(nested.database).to.equal(this.db);
-			expect(nested.run).to.be.undefined;
-			expect(nested.get).to.be.undefined;
-			expect(nested.all).to.be.undefined;
-			expect(nested.iterate).to.be.undefined;
-			expect(nested.reader).to.be.undefined;
-			expect(nested.source).to.be.undefined;
-			for (const key of keys) expect(nested[key]).to.equal(trx[key]);
-		}
-	});
-	describe('transaction function', function () {
-		it('should execute the wrapped function', function () {
-			const trx = this.db.transaction(function () { return [this, ...arguments]; });
-			const obj = {};
-			expect(trx.call(obj, 'foo', 'bar', 123, obj)).to.deep.equal([obj, 'foo', 'bar', 123, obj]);
-		});
-		it('should execute within an isolated transaction', function () {
-			const other = new Database(util.current());
-			try {
-				expect(this.db.prepare('SELECT x FROM data').pluck().all()).to.deep.equal([1, 2, 3]);
-				expect(other.prepare('SELECT x FROM data').pluck().all()).to.deep.equal([1, 2, 3]);
-				expect(this.db.inTransaction).to.be.false;
-				let ranOnce = false;
-				const trx = this.db.transaction((arg) => {
-					expect(this.db.inTransaction).to.be.true;
-					expect(arg).to.equal('foo');
-					this.db.prepare('INSERT INTO data VALUES (100)').run();
-					expect(this.db.prepare('SELECT x FROM data').pluck().all()).to.deep.equal([1, 2, 3, 100]);
-					expect(other.prepare('SELECT x FROM data').pluck().all()).to.deep.equal([1, 2, 3]);
-					ranOnce = true;
-					expect(this.db.inTransaction).to.be.true;
-					return 'bar';
-				});
-				expect(ranOnce).to.be.false;
-				expect(this.db.prepare('SELECT x FROM data').pluck().all()).to.deep.equal([1, 2, 3]);
-				expect(other.prepare('SELECT x FROM data').pluck().all()).to.deep.equal([1, 2, 3]);
-				expect(this.db.inTransaction).to.be.false;
-				expect(trx('foo')).to.equal('bar');
-				expect(this.db.inTransaction).to.be.false;
-				expect(ranOnce).to.be.true;
-				expect(this.db.prepare('SELECT x FROM data').pluck().all()).to.deep.equal([1, 2, 3, 100]);
-				expect(other.prepare('SELECT x FROM data').pluck().all()).to.deep.equal([1, 2, 3, 100]);
-			} finally {
-				other.close();
-			}
-		});
-		it('should rollback the transaction if an exception is thrown', function () {
-			expect(this.db.prepare('SELECT x FROM data').pluck().all()).to.deep.equal([1, 2, 3]);
-			expect(this.db.inTransaction).to.be.false;
-			const err = new Error('foobar');
-			let ranOnce = false;
-			const trx = this.db.transaction((arg) => {
-				expect(this.db.inTransaction).to.be.true;
-				expect(arg).to.equal('baz');
-				this.db.prepare('INSERT INTO data VALUES (100)').run();
-				expect(this.db.prepare('SELECT x FROM data').pluck().all()).to.deep.equal([1, 2, 3, 100]);
-				ranOnce = true;
-				expect(this.db.inTransaction).to.be.true;
-				throw err;
-			});
-			expect(ranOnce).to.be.false;
-			expect(this.db.prepare('SELECT x FROM data').pluck().all()).to.deep.equal([1, 2, 3]);
-			expect(this.db.inTransaction).to.be.false;
-			expect(() => trx('baz')).to.throw(err);
-			expect(this.db.inTransaction).to.be.false;
-			expect(ranOnce).to.be.true;
-			expect(this.db.prepare('SELECT x FROM data').pluck().all()).to.deep.equal([1, 2, 3]);
-		});
-		it('should work when nested within other transaction functions', function () {
-			const stmt = this.db.prepare('INSERT INTO data VALUES (?)');
-			const insertOne = this.db.transaction(x => stmt.run(x));
-			const insertMany = this.db.transaction((...values) => values.map(insertOne));
-			expect(this.db.prepare('SELECT x FROM data').pluck().all()).to.deep.equal([1, 2, 3]);
-			insertMany(10, 20, 30);
-			expect(this.db.prepare('SELECT x FROM data').pluck().all()).to.deep.equal([1, 2, 3, 10, 20, 30]);
-			expect(() => insertMany(40, 50, 3)).to.throw(Database.SqliteError).with.property('code', 'SQLITE_CONSTRAINT_UNIQUE');
-			expect(this.db.prepare('SELECT x FROM data').pluck().all()).to.deep.equal([1, 2, 3, 10, 20, 30]);
-		});
-		it('should be able to perform partial rollbacks when nested', function () {
-			expect(this.db.prepare('SELECT x FROM data').pluck().all()).to.deep.equal([1, 2, 3]);
-			const stmt = this.db.prepare('INSERT INTO data VALUES (?)');
-			const insertOne = this.db.transaction(x => stmt.run(x).changes);
-			const insertMany = this.db.transaction((...values) => values.reduce((y, x) => y + insertOne(x), 0));
-			expect(this.db.inTransaction).to.be.false;
-			const trx = this.db.transaction(() => {
-				expect(this.db.inTransaction).to.be.true;
-				let count = 0;
-				count += insertMany(10, 20, 30);
-				expect(this.db.prepare('SELECT x FROM data').pluck().all()).to.deep.equal([1, 2, 3, 10, 20, 30]);
-				try {
-					insertMany(40, 50, 3, 60);
-				} catch (_) {
-					expect(this.db.inTransaction).to.be.true;
-					count += insertOne(555);
-				}
-				expect(this.db.prepare('SELECT x FROM data').pluck().all()).to.deep.equal([1, 2, 3, 10, 20, 30, 555]);
-				this.db.prepare('SAVEPOINT foo').run();
-				insertOne(123);
-				insertMany(456, 789);
-				expect(this.db.prepare('SELECT x FROM data').pluck().all()).to.deep.equal([1, 2, 3, 10, 20, 30, 555, 123, 456, 789]);
-				this.db.prepare('ROLLBACK TO foo').run();
-				expect(this.db.prepare('SELECT x FROM data').pluck().all()).to.deep.equal([1, 2, 3, 10, 20, 30, 555]);
-				count += insertMany(1000);
-				expect(this.db.inTransaction).to.be.true;
-				return count;
-			});
-			expect(this.db.prepare('SELECT x FROM data').pluck().all()).to.deep.equal([1, 2, 3]);
-			expect(this.db.inTransaction).to.be.false;
-			expect(trx()).to.equal(5);
-			expect(this.db.inTransaction).to.be.false;
-			expect(this.db.prepare('SELECT x FROM data').pluck().all()).to.deep.equal([1, 2, 3, 10, 20, 30, 555, 1000]);
-		});
-		it('should work when the transaction is rolled back internally', function () {
-			const stmt = this.db.prepare('INSERT OR ROLLBACK INTO data VALUES (?)');
-			const insertOne = this.db.transaction(x => stmt.run(x));
-			const insertMany = this.db.transaction((...values) => values.map(insertOne));
-			expect(this.db.prepare('SELECT x FROM data').pluck().all()).to.deep.equal([1, 2, 3]);
-			insertMany(10, 20, 30);
-			expect(this.db.prepare('SELECT x FROM data').pluck().all()).to.deep.equal([1, 2, 3, 10, 20, 30]);
-			expect(() => insertMany(40, 50, 10)).to.throw(Database.SqliteError).with.property('code', 'SQLITE_CONSTRAINT_UNIQUE');
-			expect(this.db.prepare('SELECT x FROM data').pluck().all()).to.deep.equal([1, 2, 3, 10, 20, 30]);
-		});
-	});
-});

package/test/31.database.checkpoint.js

@@ -1,62 +0,0 @@
-'use strict';
-const fs = require('fs');
-const Database = require('../.');
-
-describe('Database#pragma(\'wal_checkpoint(RESTART)\')', function () {
-	let db1, db2;
-	before(function () {
-		db1 = new Database(util.next());
-		db2 = new Database(util.next());
-		db1.pragma('journal_mode = WAL');
-		db1.prepare('CREATE TABLE entries (a TEXT, b INTEGER)').run();
-		db2.pragma('journal_mode = WAL');
-		db2.prepare('CREATE TABLE entries (a TEXT, b INTEGER)').run();
-	});
-	after(function () {
-		db1.close();
-		db2.close();
-	});
-
-	function fillWall(count, expectation) {
-		[db1, db2].forEach((db) => {
-			let size1, size2;
-			for (let i = 0; i < count; ++i) {
-				size1 = fs.statSync(`${db.name}-wal`).size;
-				db.prepare('INSERT INTO entries VALUES (?, ?)').run('bar', 999);
-				size2 = fs.statSync(`${db.name}-wal`).size;
-				expectation(size2, size1, db);
-			}
-		});
-	}
-
-	describe('when used without a specified database', function () {
-		specify('every insert should increase the size of the WAL file', function () {
-			fillWall(10, (b, a) => expect(b).to.be.above(a));
-		});
-		specify('inserts after a checkpoint should NOT increase the size of the WAL file', function () {
-			db1.prepare(`ATTACH '${db2.name}' AS foobar`).run();
-			db1.pragma('wal_checkpoint(RESTART)');
-			fillWall(10, (b, a) => expect(b).to.equal(a));
-		});
-	});
-	describe('when used on a specific database', function () {
-		specify('every insert should increase the size of the WAL file', function () {
-			db1.prepare('DETACH foobar').run();
-			db1.close();
-			db2.close();
-			db1 = new Database(db1.name);
-			db2 = new Database(db2.name);
-			db1.prepare('CREATE TABLE _unused (a TEXT, b INTEGER)').run();
-			db2.prepare('CREATE TABLE _unused (a TEXT, b INTEGER)').run();
-			fillWall(10, (b, a) => expect(b).to.be.above(a));
-		});
-		specify('inserts after a checkpoint should NOT increase the size of the WAL file', function () {
-			db1.prepare(`ATTACH '${db2.name}' AS bazqux`).run();
-			db1.pragma('bazqux.wal_checkpoint(RESTART)');
-			fillWall(10, (b, a, db) => {
-				if (db === db1) expect(b).to.be.above(a);
-				else expect(b).to.be.equal(a);
-			});
-		});
-	});
-});

package/test/32.database.function.js

@@ -1,211 +0,0 @@
-'use strict';
-const Database = require('../.');
-
-describe('Database#function()', function () {
-	beforeEach(function () {
-		this.db = new Database(util.next());
-		this.get = (SQL, ...args) => this.db.prepare(`SELECT ${SQL}`).pluck().get(args);
-	});
-	afterEach(function () {
-		this.db.close();
-	});
-
-	it('should throw an exception if the correct arguments are not provided', function () {
-		expect(() => this.db.function()).to.throw(TypeError);
-		expect(() => this.db.function(null)).to.throw(TypeError);
-		expect(() => this.db.function('a')).to.throw(TypeError);
-		expect(() => this.db.function({})).to.throw(TypeError);
-		expect(() => this.db.function(() => {})).to.throw(TypeError);
-		expect(() => this.db.function(function b() {})).to.throw(TypeError);
-		expect(() => this.db.function({}, function c() {})).to.throw(TypeError);
-		expect(() => this.db.function('d', {})).to.throw(TypeError);
-		expect(() => this.db.function('e', { fn: function e() {} })).to.throw(TypeError);
-		expect(() => this.db.function('f', Object.create(Function.prototype))).to.throw(TypeError);
-		expect(() => this.db.function({ name: 'g' }, function g() {})).to.throw(TypeError);
-		expect(() => this.db.function(new String('h'), function h() {})).to.throw(TypeError);
-	});
-	it('should throw an exception if boolean options are provided as non-booleans', function () {
-		expect(() => this.db.function('a', { varargs: undefined }, () => {})).to.throw(TypeError);
-		expect(() => this.db.function('b', { deterministic: undefined }, () => {})).to.throw(TypeError);
-		expect(() => this.db.function('b', { directOnly: undefined }, () => {})).to.throw(TypeError);
-		expect(() => this.db.function('c', { safeIntegers: undefined }, () => {})).to.throw(TypeError);
-	});
-	it('should throw an exception if the provided name is empty', function () {
-		expect(() => this.db.function('', function a() {})).to.throw(TypeError);
-		expect(() => this.db.function('', { name: 'b' }, function b() {})).to.throw(TypeError);
-	});
-	it('should throw an exception if function.length is invalid', function () {
-		const length = x => Object.defineProperty(() => {}, 'length', { value: x });
-		expect(() => this.db.function('a', length(undefined))).to.throw(TypeError);
-		expect(() => this.db.function('b', length(null))).to.throw(TypeError);
-		expect(() => this.db.function('c', length('2'))).to.throw(TypeError);
-		expect(() => this.db.function('d', length(NaN))).to.throw(TypeError);
-		expect(() => this.db.function('e', length(Infinity))).to.throw(TypeError);
-		expect(() => this.db.function('f', length(2.000000001))).to.throw(TypeError);
-		expect(() => this.db.function('g', length(-0.000000001))).to.throw(TypeError);
-		expect(() => this.db.function('h', length(-2))).to.throw(TypeError);
-		expect(() => this.db.function('i', length(100.000000001))).to.throw(TypeError);
-		expect(() => this.db.function('j', length(101))).to.throw(RangeError);
-	});
-	it('should register the given function and return the database object', function () {
-		expect(this.db.function('a', () => {})).to.equal(this.db);
-		expect(this.db.function('b', {}, () => {})).to.equal(this.db);
-		expect(this.db.function('c', function x() {})).to.equal(this.db);
-		expect(this.db.function('d', {}, function y() {})).to.equal(this.db);
-	});
-	it('should enable the registered function to be executed from SQL', function () {
-		// numbers and strings
-		this.db.function('a', (a, b, c) => a + b + c);
-		expect(this.get('a(?, ?, ?)', 2, 10, 50)).to.equal(62);
-		expect(this.get('a(?, ?, ?)', 2, 10, null)).to.equal(12);
-		expect(this.get('a(?, ?, ?)', 'foo', 'z', 12)).to.equal('fooz12');
-
-		// undefined is interpreted as null
-		this.db.function('b', (a, b) => null);
-		this.db.function('c', (a, b) => {});
-		expect(this.get('b(?, ?)', 2, 10)).to.equal(null);
-		expect(this.get('c(?, ?)', 2, 10)).to.equal(null);
-
-		// buffers
-		this.db.function('d', function foo(x) { return x; });
-		const input = Buffer.alloc(8).fill(0xdd);
-		const output = this.get('d(?)', input);
-		expect(input).to.not.equal(output);
-		expect(input.equals(output)).to.be.true;
-		expect(output.equals(Buffer.alloc(8).fill(0xdd))).to.be.true;
-
-		// should not register based on function.name
-		expect(() => this.get('foo(?)', input)).to.throw(Database.SqliteError).with.property('code', 'SQLITE_ERROR');
-
-		// zero arguments
-		this.db.function('e', () => 12);
-		expect(this.get('e()')).to.equal(12);
-	});
-	it('should use a strict number of arguments by default', function () {
-		this.db.function('fn', (a, b) => {});
-		expect(() => this.get('fn()')).to.throw(Database.SqliteError).with.property('code', 'SQLITE_ERROR');
-		expect(() => this.get('fn(?)', 4)).to.throw(Database.SqliteError).with.property('code', 'SQLITE_ERROR');
-		expect(() => this.get('fn(?, ?, ?)', 4, 8, 3)).to.throw(Database.SqliteError).with.property('code', 'SQLITE_ERROR');
-		this.get('fn(?, ?)', 4, 8);
-	});
-	it('should accept a "varargs" option', function () {
-		const fn = (...args) => args.reduce((a, b) => a * b, 1);
-		Object.defineProperty(fn, 'length', { value: '-2' });
-		this.db.function('fn', { varargs: true }, fn);
-		expect(this.get('fn()')).to.equal(1);
-		expect(this.get('fn(?)', 7)).to.equal(7);
-		expect(this.get('fn(?, ?)', 4, 8)).to.equal(32);
-		expect(this.get('fn(?, ?, ?, ?, ?, ?)', 2, 3, 4, 5, 6, 7)).to.equal(5040);
-	});
-	it('should cause the function to throw when returning an invalid value', function () {
-		this.db.function('fn', x => ({}));
-		expect(() => this.get('fn(?)', 42)).to.throw(TypeError);
-	});
-	it('should propagate exceptions thrown in the registered function', function () {
-		const expectError = (name, exception) => {
-			this.db.function(name, () => { throw exception; });
-			try {
-				this.get(name + '()');
-			} catch (ex) {
-				expect(ex).to.equal(exception);
-				return;
-			}
-			throw new TypeError('Expected function to throw an exception');
-		};
-		expectError('a', new TypeError('foobar'));
-		expectError('b', new Error('baz'));
-		expectError('c', { yup: 'ok' });
-		expectError('d', 'foobarbazqux');
-		expectError('e', '');
-		expectError('f', null);
-		expectError('g', 123.4);
-	});
-	it('should close a statement iterator that caused its function to throw', function () {
-		this.db.prepare('CREATE TABLE iterable (value INTEGER)').run();
-		this.db.prepare('INSERT INTO iterable WITH RECURSIVE temp(x) AS (SELECT 1 UNION ALL SELECT x * 2 FROM temp LIMIT 10) SELECT * FROM temp').run();
-
-		let i = 0;
-		const err = new Error('foo');
-		this.db.function('fn', (x) => { if (++i >= 5) throw err; return x; });
-		const iterator = this.db.prepare('SELECT fn(value) FROM iterable').pluck().iterate();
-
-		let total = 0;
-		expect(() => {
-			for (const value of iterator) {
-				total += value;
-				expect(() => this.db.exec('SELECT fn(value) FROM iterable LIMIT 4')).to.throw(TypeError);
-			}
-		}).to.throw(err);
-
-		expect(total).to.equal(1 + 2 + 4 + 8);
-		expect(iterator.next()).to.deep.equal({ value: undefined, done: true });
-		expect(total).to.equal(1 + 2 + 4 + 8);
-
-		i = 0;
-		this.db.exec('SELECT fn(value) FROM iterable LIMIT 4');
-		expect(i).to.equal(4);
-	});
-	it('should be able to register multiple functions with the same name', function () {
-		this.db.function('fn', () => 0);
-		this.db.function('fn', (a) => 1);
-		this.db.function('fn', (a, b) => 2);
-		this.db.function('fn', (a, b, c) => 3);
-		this.db.function('fn', (a, b, c, d) => 4);
-		expect(this.get('fn()')).to.equal(0);
-		expect(this.get('fn(555)')).to.equal(1);
-		expect(this.get('fn(555, 555)')).to.equal(2);
-		expect(this.get('fn(555, 555, 555)')).to.equal(3);
-		expect(this.get('fn(555, 555, 555, 555)')).to.equal(4);
-		this.db.function('fn', (a, b) => 'foobar');
-		expect(this.get('fn()')).to.equal(0);
-		expect(this.get('fn(555)')).to.equal(1);
-		expect(this.get('fn(555, 555)')).to.equal('foobar');
-		expect(this.get('fn(555, 555, 555)')).to.equal(3);
-		expect(this.get('fn(555, 555, 555, 555)')).to.equal(4);
-	});
-	it('should not be able to affect bound buffers mid-query', function () {
-		const input = Buffer.alloc(1024 * 8).fill(0xbb);
-		let ranOnce = false;
-		this.db.function('fn', () => {
-			ranOnce = true;
-			input[0] = 2;
-		});
-		const output = this.get('?, fn()', input);
-		expect(ranOnce).to.be.true;
-		expect(output.equals(Buffer.alloc(1024 * 8).fill(0xbb))).to.be.true;
-	});
-	describe('should not affect external environment', function () {
-		specify('busy state', function () {
-			this.db.function('fn', (x) => {
-				expect(() => this.db.exec('SELECT 555')).to.throw(TypeError);
-				return x * 2;
-			});
-			let ranOnce = false;
-			for (const x of this.db.prepare('SELECT fn(555)').pluck().iterate()) {
-				ranOnce = true;
-				expect(x).to.equal(1110);
-				expect(() => this.db.exec('SELECT 555')).to.throw(TypeError);
-			}
-			expect(ranOnce).to.be.true;
-			this.db.exec('SELECT 555');
-		});
-		specify('was_js_error state', function () {
-			this.db.prepare('CREATE TABLE data (value INTEGER)').run();
-			const stmt = this.db.prepare('SELECT value FROM data');
-			this.db.prepare('DROP TABLE data').run();
-
-			const err = new Error('foo');
-			this.db.function('fn', () => { throw err; });
-
-			expect(() => this.db.prepare('SELECT fn()').get()).to.throw(err);
-			try { stmt.get(); } catch (ex) {
-				expect(ex).to.be.an.instanceof(Error);
-				expect(ex).to.not.equal(err);
-				expect(ex.message).to.not.equal(err.message);
-				expect(ex).to.be.an.instanceof(Database.SqliteError);
-				return;
-			}
-			throw new TypeError('Expected the statement to throw an exception');
-		});
-	});
-});