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

package/benchmark/benchmark.js

@@ -1,31 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-const benchmark = require('nodemark');
-
-const sync = (fn) => {
-	display(benchmark(fn));
-};
-
-const async = (fn) => {
-	const wrapped = cb => fn().then(() => cb(), cb);
-	benchmark(wrapped).then(display);
-};
-
-const display = (result) => {
-	process.stdout.write(String(result).replace(/ \(.*/, ''));
-	process.exit();
-};
-
-(async () => {
-	process.on('unhandledRejection', (err) => { throw err; });
-	const ctx = JSON.parse(process.argv[2]);
-	const type = require(`./types/${ctx.type}`);
-	const db = await require('./drivers').get(ctx.driver)('../temp/benchmark.db', ctx.pragma);
-	if (!type.readonly) {
-		for (const table of ctx.tables) await db.exec(`DELETE FROM ${table} WHERE rowid > 1;`);
-		await db.exec('VACUUM;');
-	}
-	const fn = type[ctx.driver](db, ctx);
-	if (typeof fn === 'function') setImmediate(sync, fn);
-	else setImmediate(async, await fn);
-})();

package/benchmark/drivers.js

@@ -1,21 +0,0 @@
-'use strict';
-
-/*
-	Every benchmark trial will be executed once for each SQLite3 driver listed
-	below. Each driver has a function to open a new database connection on a
-	given filename and a list of PRAGMA statements.
- */
-
-module.exports = new Map([
-	['better-sqlite3', async (filename, pragma) => {
-		const db = require('../.')(filename);
-		for (const str of pragma) db.pragma(str);
-		return db;
-	}],
-	['node-sqlite3', async (filename, pragma) => {
-		const driver = require('sqlite3').Database;
-		const db = await (require('sqlite').open)({ filename, driver });
-		for (const str of pragma) await db.run(`PRAGMA ${str}`);
-		return db;
-	}],
-]);

package/benchmark/index.js

@@ -1,83 +0,0 @@
-'use strict';
-const { execFileSync } = require('child_process');
-const clc = require('cli-color');
-
-const getTrials = (searchTerms) => {
-	// Without any command-line arguments, we do a general-purpose benchmark.
-	if (!searchTerms.length) return require('./trials').default;
-
-	// With command-line arguments, the user can run specific groups of trials.
-	return require('./trials').searchable.filter(filterBySearchTerms(searchTerms));
-};
-
-const filterBySearchTerms = (searchTerms) => (trial) => {
-	const terms = [
-		trial.type,
-		trial.table,
-		`(${trial.columns.join(', ')})`,
-		`(${trial.columns.join(',')})`,
-		...trial.columns,
-		...trial.customPragma,
-	];
-	return searchTerms.every(arg => terms.includes(arg));
-};
-
-const sortTrials = (a, b) => {
-	const aRo = require(`./types/${a.type}`).readonly;
-	const bRo = require(`./types/${b.type}`).readonly;
-	if (typeof aRo !== 'boolean') throw new TypeError(`Missing readonly export in benchmark type ${a.type}`);
-	if (typeof bRo !== 'boolean') throw new TypeError(`Missing readonly export in benchmark type ${b.type}`);
-	return bRo - aRo;
-};
-
-const displayTrialName = (trial) => {
-	if (trial.description) return console.log(clc.magenta(`--- ${trial.description} ---`));
-	const name = `${trial.type} ${trial.table} (${trial.columns.join(', ')})`;
-	const pragma = trial.customPragma.length ? ` | ${trial.customPragma.join('; ')}` : '';
-	console.log(clc.magenta(name) + clc.yellow(pragma));
-};
-
-const createContext = (trial, driver) => {
-	const tableInfo = Object.assign({}, tables.get(trial.table), { data: undefined });
-	return JSON.stringify(Object.assign({}, trial, tableInfo, { driver, tables: [...tables.keys()] }));
-};
-
-const erase = () => {
-	return clc.move(0, -1) + clc.erase.line;
-};
-
-// Determine which trials should be executed.
-process.chdir(__dirname);
-const trials = getTrials(process.argv.slice(2)).sort(sortTrials);
-if (!trials.length) {
-	console.log(clc.yellow('No matching benchmarks found!'));
-	process.exit();
-}
-
-// Create the temporary database needed to run the benchmark trials.
-console.log('Generating tables...');
-const tables = require('./seed')();
-process.stdout.write(erase());
-
-// Execute each trial for each available driver.
-const drivers = require('./drivers');
-const nameLength = [...drivers.keys()].reduce((m, d) => Math.max(m, d.length), 0);
-for (const trial of trials) {
-	displayTrialName(trial);
-	for (const driver of drivers.keys()) {
-		const driverName = driver.padEnd(nameLength);
-		const ctx = createContext(trial, driver);
-		process.stdout.write(`${driver} (running...)\n`);
-		try {
-			const result = execFileSync('node', ['./benchmark.js', ctx], { stdio: 'pipe', encoding: 'utf8' });
-			console.log(erase() + `${driverName} x ${result}`);
-		} catch (err) {
-			console.log(erase() + clc.red(`${driverName} ERROR (probably out of memory)`));
-			process.stderr.write(clc.xterm(247)(clc.strip(err.stderr)));
-		}
-	}
-	console.log('');
-}
-
-console.log(clc.green('All benchmarks complete!'));
-process.exit();

package/benchmark/seed.js

@@ -1,47 +0,0 @@
-'use strict';
-const fs = require('fs-extra');
-const path = require('path');
-
-const tables = new Map([
-	['small', {
-		schema: '(nul, integer INTEGER, real REAL, text TEXT, blob BLOB)',
-		data: [null, 0x7fffffff, 1 / 3, 'this is the text', Buffer.from('this is the blob')],
-		count: 10000,
-	}],
-	['large_text', {
-		schema: '(text TEXT)',
-		data: ['this is the text'.repeat(2048)],
-		count: 10000,
-	}],
-	['large_blob', {
-		schema: '(blob BLOB)',
-		data: [Buffer.from('this is the blob'.repeat(2048))],
-		count: 10000,
-	}],
-]);
-
-/*
-	This function creates a pre-populated database that is deleted when the
-	process exits.
- */
-
-module.exports = () => {
-	const tempDir = path.join(__dirname, '..', 'temp');
-	process.on('exit', () => fs.removeSync(tempDir));
-	fs.removeSync(tempDir);
-	fs.ensureDirSync(tempDir);
-
-	const db = require('../.')(path.join(tempDir, 'benchmark.db'));
-	db.pragma('journal_mode = OFF');
-	db.pragma('synchronous = OFF');
-
-	for (const [name, ctx] of tables.entries()) {
-		db.exec(`CREATE TABLE ${name} ${ctx.schema}`);
-		const columns = db.pragma(`table_info(${name})`).map(() => '?');
-		const insert = db.prepare(`INSERT INTO ${name} VALUES (${columns.join(', ')})`).bind(ctx.data);
-		for (let i = 0; i < ctx.count; ++i) insert.run();
-	}
-
-	db.close();
-	return tables;
-};

package/benchmark/trials.js

@@ -1,65 +0,0 @@
-'use strict';
-
-exports.default = [
-	{ type: 'select', table: 'small', columns: ['nul', 'integer', 'real', 'text'],
-		description: 'reading rows individually' },
-	{ type: 'select-all', table: 'small', columns: ['nul', 'integer', 'real', 'text'],
-		description: 'reading 100 rows into an array' },
-	{ type: 'select-iterate', table: 'small', columns: ['nul', 'integer', 'real', 'text'],
-		description: 'iterating over 100 rows' },
-	{ type: 'insert', table: 'small', columns: ['nul', 'integer', 'real', 'text'],
-		description: 'inserting rows individually' },
-	{ type: 'transaction', table: 'small', columns: ['nul', 'integer', 'real', 'text'],
-		description: 'inserting 100 rows in a single transaction' },
-];
-
-exports.searchable = [
-	{ type: 'select', table: 'small', columns: ['nul'] },
-	{ type: 'select', table: 'small', columns: ['integer'] },
-	{ type: 'select', table: 'small', columns: ['real'] },
-	{ type: 'select', table: 'small', columns: ['text'] },
-	{ type: 'select', table: 'small', columns: ['blob'] },
-	{ type: 'select', table: 'large_text', columns: ['text'] },
-	{ type: 'select', table: 'large_blob', columns: ['blob'] },
-	{ type: 'select-all', table: 'small', columns: ['nul'] },
-	{ type: 'select-all', table: 'small', columns: ['integer'] },
-	{ type: 'select-all', table: 'small', columns: ['real'] },
-	{ type: 'select-all', table: 'small', columns: ['text'] },
-	{ type: 'select-all', table: 'small', columns: ['blob'] },
-	{ type: 'select-all', table: 'large_text', columns: ['text'] },
-	{ type: 'select-all', table: 'large_blob', columns: ['blob'] },
-	{ type: 'select-iterate', table: 'small', columns: ['nul'] },
-	{ type: 'select-iterate', table: 'small', columns: ['integer'] },
-	{ type: 'select-iterate', table: 'small', columns: ['real'] },
-	{ type: 'select-iterate', table: 'small', columns: ['text'] },
-	{ type: 'select-iterate', table: 'small', columns: ['blob'] },
-	{ type: 'select-iterate', table: 'large_text', columns: ['text'] },
-	{ type: 'select-iterate', table: 'large_blob', columns: ['blob'] },
-	{ type: 'insert', table: 'small', columns: ['nul'] },
-	{ type: 'insert', table: 'small', columns: ['integer'] },
-	{ type: 'insert', table: 'small', columns: ['real'] },
-	{ type: 'insert', table: 'small', columns: ['text'] },
-	{ type: 'insert', table: 'small', columns: ['blob'] },
-	{ type: 'insert', table: 'large_text', columns: ['text'] },
-	{ type: 'insert', table: 'large_blob', columns: ['blob'] },
-	{ type: 'transaction', table: 'small', columns: ['nul'] },
-	{ type: 'transaction', table: 'small', columns: ['integer'] },
-	{ type: 'transaction', table: 'small', columns: ['real'] },
-	{ type: 'transaction', table: 'small', columns: ['text'] },
-	{ type: 'transaction', table: 'small', columns: ['blob'] },
-	{ type: 'transaction', table: 'large_text', columns: ['text'] },
-	{ type: 'transaction', table: 'large_blob', columns: ['blob'] },
-];
-
-(() => {
-	const defaultPragma = [];
-	const yes = /^\s*(1|true|on|yes)\s*$/i;
-	if (yes.test(process.env.NO_CACHE)) defaultPragma.push('cache_size = 0');
-	else defaultPragma.push('cache_size = -16000');
-	if (yes.test(process.env.NO_WAL)) defaultPragma.push('journal_mode = DELETE', 'synchronous = FULL');
-	else defaultPragma.push('journal_mode = WAL', 'synchronous = NORMAL');
-	for (const trial of [].concat(...Object.values(exports))) {
-		trial.customPragma = trial.pragma || [];
-		trial.pragma = defaultPragma.concat(trial.customPragma);
-	}
-})();

package/benchmark/types/insert.js

@@ -1,16 +0,0 @@
-'use strict';
-exports.readonly = false; // Inserting rows individually (`.run()`)
-
-exports['better-sqlite3'] = (db, { table, columns }) => {
-	const stmt = db.prepare(`INSERT INTO ${table} (${columns.join(', ')}) VALUES (${columns.map(x => '@' + x).join(', ')})`);
-	const row = db.prepare(`SELECT * FROM ${table} LIMIT 1`).get();
-	return () => stmt.run(row);
-};
-
-exports['node-sqlite3'] = async (db, { table, columns }) => {
-	const sql = `INSERT INTO ${table} (${columns.join(', ')}) VALUES (${columns.map(x => '@' + x).join(', ')})`;
-	const row = Object.assign({}, ...Object.entries(await db.get(`SELECT * FROM ${table} LIMIT 1`))
-		.filter(([k]) => columns.includes(k))
-		.map(([k, v]) => ({ ['@' + k]: v })));
-	return () => db.run(sql, row);
-};

package/benchmark/types/select-all.js

@@ -1,14 +0,0 @@
-'use strict';
-exports.readonly = true; // Reading 100 rows into an array (`.all()`)
-
-exports['better-sqlite3'] = (db, { table, columns, count }) => {
-	const stmt = db.prepare(`SELECT ${columns.join(', ')} FROM ${table} WHERE rowid >= ? LIMIT 100`);
-	let rowid = -100;
-	return () => stmt.all((rowid += 100) % count + 1);
-};
-
-exports['node-sqlite3'] = async (db, { table, columns, count }) => {
-	const sql = `SELECT ${columns.join(', ')} FROM ${table} WHERE rowid >= ? LIMIT 100`;
-	let rowid = -100;
-	return () => db.all(sql, (rowid += 100) % count + 1);
-};

package/benchmark/types/select-iterate.js

@@ -1,23 +0,0 @@
-'use strict';
-exports.readonly = true; // Iterating over 100 rows (`.iterate()`)
-
-exports['better-sqlite3'] = (db, { table, columns, count }) => {
-	const stmt = db.prepare(`SELECT ${columns.join(', ')} FROM ${table} WHERE rowid >= ? LIMIT 100`);
-	let rowid = -100;
-	return () => {
-		for (const row of stmt.iterate((rowid += 100) % count + 1)) {}
-	};
-};
-
-exports['node-sqlite3'] = async (db, { table, columns, count }) => {
-	const sql = `SELECT ${columns.join(', ')} FROM ${table} WHERE rowid = ?`;
-	let rowid = -100;
-	return () => {
-		rowid += 100;
-		let index = 0;
-		return (function next() {
-			if (index === 100) return;
-			return db.get(sql, (rowid + index++) % count + 1).then(next);
-		})();
-	};
-};

package/benchmark/types/select.js

@@ -1,14 +0,0 @@
-'use strict';
-exports.readonly = true; // Reading rows individually (`.get()`)
-
-exports['better-sqlite3'] = (db, { table, columns, count }) => {
-	const stmt = db.prepare(`SELECT ${columns.join(', ')} FROM ${table} WHERE rowid = ?`);
-	let rowid = -1;
-	return () => stmt.get(++rowid % count + 1);
-};
-
-exports['node-sqlite3'] = async (db, { table, columns, count }) => {
-	const sql = `SELECT ${columns.join(', ')} FROM ${table} WHERE rowid = ?`;
-	let rowid = -1;
-	return () => db.get(sql, ++rowid % count + 1);
-};

package/benchmark/types/transaction.js

@@ -1,40 +0,0 @@
-'use strict';
-exports.readonly = false; // Inserting 100 rows in a single transaction
-
-exports['better-sqlite3'] = (db, { table, columns }) => {
-	const stmt = db.prepare(`INSERT INTO ${table} (${columns.join(', ')}) VALUES (${columns.map(x => '@' + x).join(', ')})`);
-	const row = db.prepare(`SELECT * FROM ${table} LIMIT 1`).get();
-	const trx = db.transaction((row) => {
-		for (let i = 0; i < 100; ++i) stmt.run(row);
-	});
-	return () => trx(row);
-};
-
-exports['node-sqlite3'] = async (db, { table, columns, driver, pragma }) => {
-	const sql = `INSERT INTO ${table} (${columns.join(', ')}) VALUES (${columns.map(x => '@' + x).join(', ')})`;
-	const row = Object.assign({}, ...Object.entries(await db.get(`SELECT * FROM ${table} LIMIT 1`))
-		.filter(([k]) => columns.includes(k))
-		.map(([k, v]) => ({ ['@' + k]: v })));
-	const open = require('../drivers').get(driver);
-	/*
-		The only way to create an isolated transaction with node-sqlite3 in a
-		random-access environment (i.e., a web server) is to open a new database
-		connection for each transaction.
-		(http://github.com/mapbox/node-sqlite3/issues/304#issuecomment-45242331)
-	 */
-	return () => open('../temp/benchmark.db', pragma).then(async (db) => {
-		try {
-			await db.run('BEGIN');
-			try {
-				for (let i = 0; i < 100; ++i) await db.run(sql, row);
-				await db.run('COMMIT');
-			} catch (err) {
-				try { await db.run('ROLLBACK'); }
-				catch (_) { /* this is necessary because there's no db.inTransaction property */ }
-				throw err;
-			}
-		} finally {
-			await db.close();
-		}
-	});
-};

package/deps/extract.js

@@ -1,16 +0,0 @@
-'use strict';
-const path = require('path');
-const tar = require('tar');
-
-const dest = process.argv[2];
-const source = path.join(__dirname, 'sqlite3.tar.gz');
-
-process.on('unhandledRejection', (err) => { throw err; });
-
-/*
-	This extracts the bundled sqlite3.tar.gz file and places the resulting files
-	into the directory specified by <$2>.
- */
-
-tar.extract({ file: source, cwd: dest, onwarn: process.emitWarning })
-	.then(() => process.exit(0));