better-sqlite3-multiple-ciphers 7.4.6-beta.0 → 7.5.0-beta.0

package/src/util/macros.lzz

@@ -1,159 +0,0 @@
-#define NODE_ARGUMENTS const v8::FunctionCallbackInfo<v8::Value>&
-#define NODE_ARGUMENTS_POINTER const v8::FunctionCallbackInfo<v8::Value>*
-#define NODE_METHOD(name) static void name(NODE_ARGUMENTS info)
-#define NODE_GETTER(name) static void name(v8::Local<v8::String> _, const v8::PropertyCallbackInfo<v8::Value>& info)
-#define INIT(name) static v8::Local<v8::Function> name(v8::Isolate* isolate, v8::Local<v8::External> data)
-
-#define EasyIsolate v8::Isolate* isolate = v8::Isolate::GetCurrent()
-#define OnlyIsolate info.GetIsolate()
-#define OnlyContext isolate->GetCurrentContext()
-#define OnlyAddon static_cast<Addon*>(info.Data().As<v8::External>()->Value())
-#define UseIsolate v8::Isolate* isolate = OnlyIsolate
-#define UseContext v8::Local<v8::Context> ctx = OnlyContext
-#define UseAddon Addon* addon = OnlyAddon
-#define Unwrap node::ObjectWrap::Unwrap
-
-inline v8::Local<v8::String> StringFromUtf8(v8::Isolate* isolate, const char* data, int length) {
-	return v8::String::NewFromUtf8(isolate, data, v8::NewStringType::kNormal, length).ToLocalChecked();
-}
-inline v8::Local<v8::String> InternalizedFromUtf8(v8::Isolate* isolate, const char* data, int length) {
-	return v8::String::NewFromUtf8(isolate, data, v8::NewStringType::kInternalized, length).ToLocalChecked();
-}
-inline v8::Local<v8::Value> InternalizedFromUtf8OrNull(v8::Isolate* isolate, const char* data, int length) {
-	if (data == NULL) return v8::Null(isolate);
-	return InternalizedFromUtf8(isolate, data, length);
-}
-inline v8::Local<v8::String> InternalizedFromLatin1(v8::Isolate* isolate, const char* str) {
-	return v8::String::NewFromOneByte(isolate, reinterpret_cast<const uint8_t*>(str), v8::NewStringType::kInternalized).ToLocalChecked();
-}
-
-#hdr
-template <class T> using CopyablePersistent = v8::Persistent<T, v8::CopyablePersistentTraits<T>>;
-#end
-inline void SetFrozen(v8::Isolate* isolate, v8::Local<v8::Context> ctx, v8::Local<v8::Object> obj, CopyablePersistent<v8::String>& key, v8::Local<v8::Value> value) {
-	obj->DefineOwnProperty(ctx, key.Get(isolate), value, static_cast<v8::PropertyAttribute>(v8::DontDelete | v8::ReadOnly)).FromJust();
-}
-
-void ThrowError(const char* message) { EasyIsolate; isolate->ThrowException(v8::Exception::Error(StringFromUtf8(isolate, message, -1))); }
-void ThrowTypeError(const char* message) { EasyIsolate; isolate->ThrowException(v8::Exception::TypeError(StringFromUtf8(isolate, message, -1))); }
-void ThrowRangeError(const char* message) { EasyIsolate; isolate->ThrowException(v8::Exception::RangeError(StringFromUtf8(isolate, message, -1))); }
-
-#define REQUIRE_ARGUMENT_ANY(at, var)                                          \
-	if (info.Length() <= (at()))                                               \
-		return ThrowTypeError("Expected a "#at" argument");                    \
-	var = info[at()]
-
-#define _REQUIRE_ARGUMENT(at, var, Type, message, ...)                         \
-	if (info.Length() <= (at()) || !info[at()]->Is##Type())                    \
-		return ThrowTypeError("Expected "#at" argument to be "#message);       \
-	var = (info[at()].As<v8::Type>())__VA_ARGS__
-
-#define REQUIRE_ARGUMENT_INT32(at, var)                                        \
-	_REQUIRE_ARGUMENT(at, var, Int32, a 32-bit signed integer, ->Value())
-#define REQUIRE_ARGUMENT_BOOLEAN(at, var)                                      \
-	_REQUIRE_ARGUMENT(at, var, Boolean, a boolean, ->Value())
-#define REQUIRE_ARGUMENT_STRING(at, var)                                       \
-	_REQUIRE_ARGUMENT(at, var, String, a string)
-#define REQUIRE_ARGUMENT_OBJECT(at, var)                                       \
-	_REQUIRE_ARGUMENT(at, var, Object, an object)
-#define REQUIRE_ARGUMENT_FUNCTION(at, var)                                     \
-	_REQUIRE_ARGUMENT(at, var, Function, a function)
-
-#define REQUIRE_DATABASE_OPEN(db)                                              \
-	if (!db->open)                                                             \
-		return ThrowTypeError("The database connection is not open")
-#define REQUIRE_DATABASE_NOT_BUSY(db)                                          \
-	if (db->busy)                                                              \
-		return ThrowTypeError("This database connection is busy executing a query")
-#define REQUIRE_DATABASE_NO_ITERATORS(db)                                      \
-	if (db->iterators)                                                         \
-		return ThrowTypeError("This database connection is busy executing a query")
-#define REQUIRE_DATABASE_NO_ITERATORS_UNLESS_UNSAFE(db)                        \
-	if (!db->unsafe_mode) {                                                    \
-		REQUIRE_DATABASE_NO_ITERATORS(db);                                     \
-	} ((void)0)
-#define REQUIRE_STATEMENT_NOT_LOCKED(stmt)                                     \
-	if (stmt->locked)                                                          \
-		return ThrowTypeError("This statement is busy executing a query")
-
-#define first() 0
-#define second() 1
-#define third() 2
-#define fourth() 3
-#define fifth() 4
-#define sixth() 5
-#define seventh() 6
-#define eighth() 7
-#define ninth() 8
-#define tenth() 9
-
-// Determines whether to skip the given character at the start of an SQL string.
-inline bool IS_SKIPPED(char c) {
-	return c == ' ' || c == ';' || (c >= '\t' && c <= '\r');
-}
-
-// Allocates an empty array, without calling constructors/initializers.
-template<class T> inline T* ALLOC_ARRAY(size_t count) {
-	return static_cast<T*>(::operator new[](count * sizeof(T)));
-}
-
-// Deallocates an array, without calling destructors.
-template<class T> inline void FREE_ARRAY(T* array_pointer) {
-	::operator delete[](array_pointer);
-}
-
-v8::Local<v8::FunctionTemplate> NewConstructorTemplate(
-	v8::Isolate* isolate,
-	v8::Local<v8::External> data,
-	v8::FunctionCallback func,
-	const char* name
-) {
-	v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate, func, data);
-	t->InstanceTemplate()->SetInternalFieldCount(1);
-	t->SetClassName(InternalizedFromLatin1(isolate, name));
-	return t;
-}
-void SetPrototypeMethod(
-	v8::Isolate* isolate,
-	v8::Local<v8::External> data,
-	v8::Local<v8::FunctionTemplate> recv,
-	const char* name,
-	v8::FunctionCallback func
-) {
-	v8::HandleScope scope(isolate);
-	recv->PrototypeTemplate()->Set(
-		InternalizedFromLatin1(isolate, name),
-		v8::FunctionTemplate::New(isolate, func, data, v8::Signature::New(isolate, recv))
-	);
-}
-void SetPrototypeSymbolMethod(
-	v8::Isolate* isolate,
-	v8::Local<v8::External> data,
-	v8::Local<v8::FunctionTemplate> recv,
-	v8::Local<v8::Symbol> symbol,
-	v8::FunctionCallback func
-) {
-	v8::HandleScope scope(isolate);
-	recv->PrototypeTemplate()->Set(
-		symbol,
-		v8::FunctionTemplate::New(isolate, func, data, v8::Signature::New(isolate, recv))
-	);
-}
-void SetPrototypeGetter(
-	v8::Isolate* isolate,
-	v8::Local<v8::External> data,
-	v8::Local<v8::FunctionTemplate> recv,
-	const char* name,
-	v8::AccessorGetterCallback func
-) {
-	v8::HandleScope scope(isolate);
-	recv->InstanceTemplate()->SetAccessor(
-		InternalizedFromLatin1(isolate, name),
-		func,
-		0,
-		data,
-		v8::AccessControl::DEFAULT,
-		v8::PropertyAttribute::None,
-		v8::AccessorSignature::New(isolate, recv)
-	);
-}

package/src/util/query-macros.lzz

@@ -1,71 +0,0 @@
-#define STATEMENT_BIND(handle)                                                 \
-	Binder binder(handle);                                                     \
-	if (!binder.Bind(info, info.Length(), stmt)) {                             \
-		sqlite3_clear_bindings(handle);                                        \
-		return;                                                                \
-	} ((void)0)
-
-#define STATEMENT_THROW_LOGIC()                                                \
-	db->ThrowDatabaseError();                                                  \
-	if (!bound) { sqlite3_clear_bindings(handle); }                            \
-	return
-
-#define STATEMENT_RETURN_LOGIC(return_value)                                   \
-	info.GetReturnValue().Set(return_value);                                   \
-	if (!bound) { sqlite3_clear_bindings(handle); }                            \
-	return
-
-#define STATEMENT_START_LOGIC(RETURNS_DATA_CHECK, MUTATE_CHECK)                \
-	Statement* stmt = Unwrap<Statement>(info.This());                          \
-	RETURNS_DATA_CHECK();                                                      \
-	sqlite3_stmt* handle = stmt->handle;                                       \
-	Database* db = stmt->db;                                                   \
-	REQUIRE_DATABASE_OPEN(db->GetState());                                     \
-	REQUIRE_DATABASE_NOT_BUSY(db->GetState());                                 \
-	MUTATE_CHECK();                                                            \
-	const bool bound = stmt->bound;                                            \
-	if (!bound) {                                                              \
-		STATEMENT_BIND(handle);                                                \
-	} else if (info.Length() > 0) {                                            \
-		return ThrowTypeError("This statement already has bound parameters");  \
-	} ((void)0)
-
-
-#define STATEMENT_THROW() db->GetState()->busy = false; STATEMENT_THROW_LOGIC()
-#define STATEMENT_RETURN(x) db->GetState()->busy = false; STATEMENT_RETURN_LOGIC(x)
-#define STATEMENT_START(x, y)                                                  \
-	STATEMENT_START_LOGIC(x, y);                                               \
-	db->GetState()->busy = true;                                               \
-	UseIsolate;                                                                \
-	if (db->Log(isolate, handle)) {                                            \
-		STATEMENT_THROW();                                                     \
-	} ((void)0)
-
-
-#define DOES_NOT_MUTATE() REQUIRE_STATEMENT_NOT_LOCKED(stmt)
-#define DOES_MUTATE()                                                          \
-	assert(!stmt->locked);                                                     \
-	REQUIRE_DATABASE_NO_ITERATORS_UNLESS_UNSAFE(db->GetState())
-#define DOES_ADD_ITERATOR()                                                    \
-	DOES_NOT_MUTATE();                                                         \
-	if (db->GetState()->iterators == USHRT_MAX)                                \
-		return ThrowRangeError("Too many active database iterators")
-#define REQUIRE_STATEMENT_RETURNS_DATA()                                       \
-	if (!stmt->returns_data)                                                   \
-		return ThrowTypeError("This statement does not return data. Use run() instead")
-#define ALLOW_ANY_STATEMENT()                                                  \
-	((void)0)
-
-
-#define _FUNCTION_START(type)                                                  \
-	type* self = static_cast<type*>(sqlite3_user_data(invocation));            \
-	v8::Isolate* isolate = self->isolate;                                      \
-	v8::HandleScope scope(isolate)
-
-#define FUNCTION_START()                                                       \
-	_FUNCTION_START(CustomFunction)
-
-#define AGGREGATE_START()                                                      \
-	_FUNCTION_START(CustomAggregate);                                          \
-	Accumulator* acc = self->GetAccumulator(invocation);                       \
-	if (acc->value.IsEmpty()) return

package/test/00.setup.js

@@ -1,25 +0,0 @@
-'use strict';
-const fs = require('fs-extra');
-const path = require('path');
-const os = require('os');
-const chai = require('chai');
-
-const isWindows = os.platform().startsWith('win');
-const tempDir = path.join(__dirname, '..', 'temp');
-let dbId = 0;
-
-global.expect = chai.expect;
-global.util = {
-	current: () => path.join(tempDir, `${dbId}.db`),
-	next: () => (++dbId, global.util.current()),
-	itUnix: isWindows ? it.skip : it,
-};
-
-before(function () {
-	fs.removeSync(tempDir);
-	fs.ensureDirSync(tempDir);
-});
-
-after(function () {
-	fs.removeSync(tempDir);
-});

package/test/01.sqlite-error.js

@@ -1,27 +0,0 @@
-'use strict';
-const { expect } = require('chai');
-const { SqliteError } = require('../.');
-
-describe('SqliteError', function () {
-	it('should be a subclass of Error', function () {
-		expect(SqliteError).to.be.a('function');
-		expect(SqliteError).to.not.equal(Error);
-		expect(SqliteError.prototype).to.be.an.instanceof(Error);
-		expect(SqliteError('foo', 'bar')).to.be.an.instanceof(Error);
-		expect(new SqliteError('foo', 'bar')).to.be.an.instanceof(Error);
-	});
-	it('should have the correct name', function () {
-		expect(SqliteError.prototype.name).to.equal('SqliteError');
-	});
-	it('should accept two arguments for setting the message and error code', function () {
-		const err = SqliteError('foobar', 'baz');
-		expect(err.message).to.equal('foobar');
-		expect(err.code).to.equal('baz');
-		expect(SqliteError(123, 'baz').message).to.equal('123');
-		expect(() => SqliteError('foo')).to.throw(TypeError);
-		expect(() => SqliteError('foo', 123)).to.throw(TypeError);
-	});
-	it('should capture stack traces', function () {
-		expect(SqliteError(null, 'baz').stack).to.be.a('string');
-	});
-});

package/test/10.database.open.js

@@ -1,159 +0,0 @@
-'use strict';
-const { existsSync } = require('fs');
-const Database = require('../.');
-
-describe('new Database()', function () {
-	afterEach(function () {
-		if (this.db) this.db.close();
-	});
-
-	it('should throw when given invalid argument types', function () {
-		expect(() => (this.db = new Database('', ''))).to.throw(TypeError);
-		expect(() => (this.db = new Database({}, ''))).to.throw(TypeError);
-		expect(() => (this.db = new Database({}, {}))).to.throw(TypeError);
-		expect(() => (this.db = new Database({}))).to.throw(TypeError);
-		expect(() => (this.db = new Database(0))).to.throw(TypeError);
-		expect(() => (this.db = new Database(123))).to.throw(TypeError);
-		expect(() => (this.db = new Database(new String(util.next())))).to.throw(TypeError);
-		expect(() => (this.db = new Database(() => util.next()))).to.throw(TypeError);
-		expect(() => (this.db = new Database([util.next()]))).to.throw(TypeError);
-	});
-	it('should throw when boolean options are provided as non-booleans', function () {
-		expect(() => (this.db = new Database(util.next(), { readOnly: false }))).to.throw(TypeError);
-		expect(() => (this.db = new Database(util.next(), { readonly: undefined }))).to.throw(TypeError);
-		expect(() => (this.db = new Database(util.next(), { fileMustExist: undefined }))).to.throw(TypeError);
-	});
-	it('should allow anonymous temporary databases to be created', function () {
-		for (const args of [[''], [], [null], [undefined], ['', { timeout: 2000 }]]) {
-			const db = this.db = new Database(...args);
-			expect(db.name).to.equal('');
-			expect(db.memory).to.be.true;
-			expect(db.readonly).to.be.false;
-			expect(db.open).to.be.true;
-			expect(db.inTransaction).to.be.false;
-			expect(existsSync('')).to.be.false;
-			expect(existsSync('null')).to.be.false;
-			expect(existsSync('undefined')).to.be.false;
-			expect(existsSync('[object Object]')).to.be.false;
-			db.close();
-		}
-	});
-	it('should allow anonymous in-memory databases to be created', function () {
-		const db = this.db = new Database(':memory:');
-		expect(db.name).to.equal(':memory:');
-		expect(db.memory).to.be.true;
-		expect(db.readonly).to.be.false;
-		expect(db.open).to.be.true;
-		expect(db.inTransaction).to.be.false;
-		expect(existsSync(':memory:')).to.be.false;
-	});
-	it('should allow disk-bound databases to be created', function () {
-		expect(existsSync(util.next())).to.be.false;
-		const db = this.db = new Database(util.current());
-		expect(db.name).to.equal(util.current());
-		expect(db.memory).to.be.false;
-		expect(db.readonly).to.be.false;
-		expect(db.open).to.be.true;
-		expect(db.inTransaction).to.be.false;
-		expect(existsSync(util.current())).to.be.true;
-	});
-	it('should allow readonly database connections to be created', function () {
-		expect(existsSync(util.next())).to.be.false;
-		expect(() => (this.db = new Database(util.current(), { readonly: true }))).to.throw(Database.SqliteError).with.property('code', 'SQLITE_CANTOPEN');
-		(new Database(util.current())).close();
-		expect(existsSync(util.current())).to.be.true;
-		const db = this.db = new Database(util.current(), { readonly: true });
-		expect(db.name).to.equal(util.current());
-		expect(db.memory).to.be.false;
-		expect(db.readonly).to.be.true;
-		expect(db.open).to.be.true;
-		expect(db.inTransaction).to.be.false;
-		expect(existsSync(util.current())).to.be.true;
-	});
-	it('should not allow the "readonly" option for in-memory databases', function () {
-		expect(existsSync(util.next())).to.be.false;
-		expect(() => (this.db = new Database(':memory:', { readonly: true }))).to.throw(TypeError);
-		expect(() => (this.db = new Database('', { readonly: true }))).to.throw(TypeError);
-		expect(existsSync(util.current())).to.be.false;
-	});
-	it('should accept the "fileMustExist" option', function () {
-		expect(existsSync(util.next())).to.be.false;
-		expect(() => (this.db = new Database(util.current(), { fileMustExist: true }))).to.throw(Database.SqliteError).with.property('code', 'SQLITE_CANTOPEN');
-		(new Database(util.current())).close();
-		expect(existsSync(util.current())).to.be.true;
-		const db = this.db = new Database(util.current(), { fileMustExist: true });
-		expect(db.name).to.equal(util.current());
-		expect(db.memory).to.be.false;
-		expect(db.readonly).to.be.false;
-		expect(db.open).to.be.true;
-		expect(db.inTransaction).to.be.false;
-		expect(existsSync(util.current())).to.be.true;
-	});
-	util.itUnix('should accept the "timeout" option', function () {
-		this.slow(4000);
-		const testTimeout = (timeout) => {
-			const db = new Database(util.current(), { timeout });
-			try {
-				const start = Date.now();
-				expect(() => db.exec('BEGIN EXCLUSIVE')).to.throw(Database.SqliteError).with.property('code', 'SQLITE_BUSY');
-				const end = Date.now();
-				expect(end - start).to.be.closeTo(timeout, 200);
-			} finally {
-				db.close();
-			}
-		};
-		const blocker = this.db = new Database(util.next(), { timeout: 0x7fffffff });
-		blocker.exec('BEGIN EXCLUSIVE');
-		testTimeout(0);
-		testTimeout(1000);
-		blocker.close();
-		expect(() => (this.db = new Database(util.current(), { timeout: undefined }))).to.throw(TypeError);
-		expect(() => (this.db = new Database(util.current(), { timeout: null }))).to.throw(TypeError);
-		expect(() => (this.db = new Database(util.current(), { timeout: NaN }))).to.throw(TypeError);
-		expect(() => (this.db = new Database(util.current(), { timeout: '75' }))).to.throw(TypeError);
-		expect(() => (this.db = new Database(util.current(), { timeout: -1 }))).to.throw(TypeError);
-		expect(() => (this.db = new Database(util.current(), { timeout: 75.01 }))).to.throw(TypeError);
-		expect(() => (this.db = new Database(util.current(), { timeout: 0x80000000 }))).to.throw(RangeError);
-	});
-	it('should throw an Error if the directory does not exist', function () {
-		expect(existsSync(util.next())).to.be.false;
-		const filepath = `temp/nonexistent/abcfoobar123/${util.current()}`;
-		expect(() => (this.db = new Database(filepath))).to.throw(TypeError);
-		expect(existsSync(filepath)).to.be.false;
-		expect(existsSync(util.current())).to.be.false;
-	});
-	it('should have a proper prototype chain', function () {
-		const db = this.db = new Database(util.next());
-		expect(db).to.be.an.instanceof(Database);
-		expect(db.constructor).to.equal(Database);
-		expect(Database.prototype.constructor).to.equal(Database);
-		expect(Database.prototype.close).to.be.a('function');
-		expect(Database.prototype.close).to.equal(db.close);
-		expect(Database.prototype).to.equal(Object.getPrototypeOf(db));
-	});
-	it('should work properly when called as a function', function () {
-		const db = this.db = Database(util.next());
-		expect(db).to.be.an.instanceof(Database);
-		expect(db.constructor).to.equal(Database);
-		expect(Database.prototype.close).to.equal(db.close);
-		expect(Database.prototype).to.equal(Object.getPrototypeOf(db));
-	});
-	it('should work properly when subclassed', function () {
-		class MyDatabase extends Database {
-			foo() {
-				return 999;
-			}
-		}
-		const db = this.db = new MyDatabase(util.next());
-		expect(db).to.be.an.instanceof(Database);
-		expect(db).to.be.an.instanceof(MyDatabase);
-		expect(db.constructor).to.equal(MyDatabase);
-		expect(Database.prototype.close).to.equal(db.close);
-		expect(MyDatabase.prototype.close).to.equal(db.close);
-		expect(Database.prototype.foo).to.be.undefined;
-		expect(MyDatabase.prototype.foo).to.equal(db.foo);
-		expect(Database.prototype).to.equal(Object.getPrototypeOf(MyDatabase.prototype));
-		expect(MyDatabase.prototype).to.equal(Object.getPrototypeOf(db));
-		expect(db.foo()).to.equal(999);
-	});
-});

package/test/11.database.close.js

@@ -1,68 +0,0 @@
-'use strict';
-const { existsSync } = require('fs');
-const Database = require('../.');
-
-describe('Database#close()', function () {
-	beforeEach(function () {
-		this.db = new Database(util.next());
-	});
-	afterEach(function () {
-		this.db.close();
-	});
-
-	it('should cause db.open to return false', function () {
-		expect(this.db.open).to.be.true;
-		this.db.close();
-		expect(this.db.open).to.be.false;
-	});
-	it('should return the database object', function () {
-		expect(this.db.open).to.be.true;
-		expect(this.db.close()).to.equal(this.db);
-		expect(this.db.open).to.be.false;
-		expect(this.db.close()).to.equal(this.db);
-		expect(this.db.open).to.be.false;
-	});
-	it('should prevent any further database operations', function () {
-		this.db.close();
-		expect(() => this.db.exec('CREATE TABLE people (name TEXT)')).to.throw(TypeError);
-		expect(() => this.db.prepare('CREATE TABLE cats (name TEXT)')).to.throw(TypeError);
-		expect(() => this.db.transaction(() => {})).to.throw(TypeError);
-		expect(() => this.db.pragma('cache_size')).to.throw(TypeError);
-		expect(() => this.db.function('foo', () => {})).to.throw(TypeError);
-		expect(() => this.db.aggregate('foo', { step: () => {} })).to.throw(TypeError);
-		expect(() => this.db.table('foo', () => {})).to.throw(TypeError);
-	});
-	it('should prevent any existing statements from running', function () {
-		this.db.prepare('CREATE TABLE people (name TEXT)').run();
-		const stmt1 = this.db.prepare('SELECT * FROM people');
-		const stmt2 = this.db.prepare("INSERT INTO people VALUES ('foobar')");
-
-		this.db.prepare('SELECT * FROM people').bind();
-		this.db.prepare("INSERT INTO people VALUES ('foobar')").bind();
-		this.db.prepare('SELECT * FROM people').get();
-		this.db.prepare('SELECT * FROM people').all();
-		this.db.prepare('SELECT * FROM people').iterate().return();
-		this.db.prepare("INSERT INTO people VALUES ('foobar')").run();
-
-		this.db.close();
-
-		expect(() => stmt1.bind()).to.throw(TypeError);
-		expect(() => stmt2.bind()).to.throw(TypeError);
-		expect(() => stmt1.get()).to.throw(TypeError);
-		expect(() => stmt1.all()).to.throw(TypeError);
-		expect(() => stmt1.iterate()).to.throw(TypeError);
-		expect(() => stmt2.run()).to.throw(TypeError);
-	});
-	it('should delete the database\'s associated temporary files', function () {
-		expect(existsSync(util.current())).to.be.true;
-		this.db.pragma('journal_mode = WAL');
-		this.db.prepare('CREATE TABLE people (name TEXT)').run();
-		this.db.prepare('INSERT INTO people VALUES (?)').run('foobar');
-		expect(existsSync(`${util.current()}-wal`)).to.be.true;
-
-		this.db.close();
-
-		expect(existsSync(util.current())).to.be.true;
-		expect(existsSync(`${util.current()}-wal`)).to.be.false;
-	});
-});

package/test/12.database.pragma.js

@@ -1,65 +0,0 @@
-'use strict';
-const Database = require('../.');
-
-describe('Database#pragma()', 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.pragma(123)).to.throw(TypeError);
-		expect(() => this.db.pragma(0)).to.throw(TypeError);
-		expect(() => this.db.pragma(null)).to.throw(TypeError);
-		expect(() => this.db.pragma()).to.throw(TypeError);
-		expect(() => this.db.pragma(new String('cache_size'))).to.throw(TypeError);
-	});
-	it('should throw an exception if boolean options are provided as non-booleans', function () {
-		expect(() => this.db.pragma('cache_size', { simple: undefined })).to.throw(TypeError);
-	});
-	it('should throw an exception if invalid/redundant SQL is provided', function () {
-		expect(() => this.db.pragma('PRAGMA cache_size')).to.throw(Database.SqliteError).with.property('code', 'SQLITE_ERROR');
-		expect(() => this.db.pragma('cache_size; PRAGMA cache_size')).to.throw(RangeError);
-	});
-	it('should execute the pragma, returning rows of results', function () {
-		const rows = this.db.pragma('cache_size');
-		expect(rows).to.be.an('array');
-		expect(rows[0]).to.be.an('object');
-		expect(rows[0].cache_size).to.be.a('number');
-		expect(rows[0].cache_size).to.equal(-16000);
-	});
-	it('should optionally return simpler results', function () {
-		expect(this.db.pragma('cache_size', { simple: false })).to.be.an('array');
-		const cache_size = this.db.pragma('cache_size', { simple: true });
-		expect(cache_size).to.be.a('number');
-		expect(cache_size).to.equal(-16000);
-		expect(() => this.db.pragma('cache_size', true)).to.throw(TypeError);
-		expect(() => this.db.pragma('cache_size', 123)).to.throw(TypeError);
-		expect(() => this.db.pragma('cache_size', function () {})).to.throw(TypeError);
-		expect(() => this.db.pragma('cache_size', NaN)).to.throw(TypeError);
-		expect(() => this.db.pragma('cache_size', 'true')).to.throw(TypeError);
-	});
-	it('should obey PRAGMA changes', function () {
-		expect(this.db.pragma('cache_size', { simple: true })).to.equal(-16000);
-		this.db.pragma('cache_size = -8000');
-		expect(this.db.pragma('cache_size', { simple: true })).to.equal(-8000);
-		expect(this.db.pragma('journal_mode', { simple: true })).to.equal('delete');
-		this.db.pragma('journal_mode = wal');
-		expect(this.db.pragma('journal_mode', { simple: true })).to.equal('wal');
-	});
-	it('should respect readonly connections', function () {
-		this.db.close();
-		this.db = new Database(util.current(), { readonly: true, fileMustExist: true });
-		expect(this.db.pragma('cache_size', { simple: true })).to.equal(-16000);
-		this.db.pragma('cache_size = -8000');
-		expect(this.db.pragma('cache_size', { simple: true })).to.equal(-8000);
-		expect(this.db.pragma('journal_mode', { simple: true })).to.equal('delete');
-		expect(() => this.db.pragma('journal_mode = wal')).to.throw(Database.SqliteError).with.property('code', 'SQLITE_READONLY');
-		expect(this.db.pragma('journal_mode', { simple: true })).to.equal('delete');
-	});
-	it('should return undefined if no rows exist and simpler results are desired', function () {
-		expect(this.db.pragma('table_info', { simple: true })).to.be.undefined;
-	});
-});

package/test/13.database.prepare.js

@@ -1,60 +0,0 @@
-'use strict';
-const Database = require('../.');
-
-describe('Database#prepare()', function () {
-	beforeEach(function () {
-		this.db = new Database(util.next());
-	});
-	afterEach(function () {
-		this.db.close();
-	});
-
-	function assertStmt(stmt, source, db, reader, readonly) {
-		expect(stmt.source).to.equal(source);
-		expect(stmt.constructor.name).to.equal('Statement');
-		expect(stmt.database).to.equal(db);
-		expect(stmt.reader).to.equal(reader);
-		expect(stmt.readonly).to.equal(readonly);
-		expect(() => new stmt.constructor(source)).to.throw(TypeError);
-	}
-
-	it('should throw an exception if a string is not provided', function () {
-		expect(() => this.db.prepare(123)).to.throw(TypeError);
-		expect(() => this.db.prepare(0)).to.throw(TypeError);
-		expect(() => this.db.prepare(null)).to.throw(TypeError);
-		expect(() => this.db.prepare()).to.throw(TypeError);
-		expect(() => this.db.prepare(new String('CREATE TABLE people (name TEXT)'))).to.throw(TypeError);
-	});
-	it('should throw an exception if invalid SQL is provided', function () {
-		expect(() => this.db.prepare('CREATE TABLE people (name TEXT')).to.throw(Database.SqliteError).with.property('code', 'SQLITE_ERROR');
-		expect(() => this.db.prepare('INSERT INTO people VALUES (?)')).to.throw(Database.SqliteError).with.property('code', 'SQLITE_ERROR');
-	});
-	it('should throw an exception if no statements are provided', function () {
-		expect(() => this.db.prepare('')).to.throw(RangeError);
-		expect(() => this.db.prepare(';')).to.throw(RangeError);
-	});
-	it('should throw an exception if more than one statement is provided', function () {
-		expect(() => this.db.prepare('CREATE TABLE people (name TEXT);CREATE TABLE animals (name TEXT)')).to.throw(RangeError);
-		expect(() => this.db.prepare('CREATE TABLE people (name TEXT);/')).to.throw(RangeError);
-		expect(() => this.db.prepare('CREATE TABLE people (name TEXT);-')).to.throw(RangeError);
-	});
-	it('should create a prepared Statement object', function () {
-		const stmt1 = this.db.prepare('CREATE TABLE people (name TEXT) ');
-		const stmt2 = this.db.prepare('CREATE TABLE people (name TEXT); ');
-		assertStmt(stmt1, 'CREATE TABLE people (name TEXT) ', this.db, false, false);
-		assertStmt(stmt2, 'CREATE TABLE people (name TEXT); ', this.db, false, false);
-		expect(stmt1).to.not.equal(stmt2);
-		expect(stmt1).to.not.equal(this.db.prepare('CREATE TABLE people (name TEXT) '));
-	});
-	it('should create a prepared Statement object with just an expression', function () {
-		const stmt = this.db.prepare('SELECT 555');
-		assertStmt(stmt, 'SELECT 555', this.db, true, true);
-	});
-	it('should set the correct values for "reader" and "readonly"', function () {
-		this.db.exec('CREATE TABLE data (value)');
-		assertStmt(this.db.prepare('SELECT 555'), 'SELECT 555', this.db, true, true);
-		assertStmt(this.db.prepare('BEGIN'), 'BEGIN', this.db, false, true);
-		assertStmt(this.db.prepare('BEGIN EXCLUSIVE'), 'BEGIN EXCLUSIVE', this.db, false, false);
-		assertStmt(this.db.prepare('DELETE FROM data RETURNING *'), 'DELETE FROM data RETURNING *', this.db, true, false);
-	});
-});