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

package/docs/benchmark.md

@@ -1,38 +0,0 @@
-# Benchmark
-
-To run the benchmark yourself:
-
-```bash
-git clone https://github.com/JoshuaWise/better-sqlite3.git
-cd better-sqlite3
-npm install # if you're doing this as the root user, --unsafe-perm is required
-node benchmark
-```
-
-# Results
-
-These results are from 03/29/2020, on a MacBook Pro (Retina, 15-inch, Mid 2014, OSX 10.11.6), using nodejs v12.16.1.
-
-```
---- reading rows individually ---
-better-sqlite3 x 313,899 ops/sec ±0.13%
-node-sqlite3   x 26,780 ops/sec ±2.9%
-
---- reading 100 rows into an array ---
-better-sqlite3 x 8,508 ops/sec ±0.27%
-node-sqlite3   x 2,930 ops/sec ±0.37%
-
---- iterating over 100 rows ---
-better-sqlite3 x 6,532 ops/sec ±0.32%
-node-sqlite3   x 268 ops/sec ±3.4%
-
---- inserting rows individually ---
-better-sqlite3 x 62,554 ops/sec ±7.33%
-node-sqlite3   x 22,637 ops/sec ±4.37%
-
---- inserting 100 rows in a single transaction ---
-better-sqlite3 x 4,141 ops/sec ±4.57%
-node-sqlite3   x 265 ops/sec ±4.87%
-```
-
-> All benchmarks are executed in [WAL mode](./performance.md).

package/docs/compilation.md

@@ -1,76 +0,0 @@
-# Custom configuration
-
-If you want to use a customized version of [SQLite3](https://www.sqlite.org) with `better-sqlite3-multiple-ciphers`, you can do so by specifying the directory of your [custom amalgamation](https://www.sqlite.org/amalgamation.html) during installation.
-
-```bash
-npm install better-sqlite3-multiple-ciphers --build-from-source --sqlite3=/path/to/sqlite-amalgamation
-```
-
-However, if you simply run `npm install` while `better-sqlite3-multiple-ciphers` is listed as a dependency in your `package.json`, the required flags above will *not* be applied. Therefore, it's recommended that you remove `better-sqlite3-multiple-ciphers` from your dependency list, and instead add a [`preinstall` script](https://docs.npmjs.com/misc/scripts) like the one shown below.
-
-```json
-{
-  "scripts": {
-    "preinstall": "npm install better-sqlite3-multiple-ciphers@'^7.0.0' --no-save --build-from-source --sqlite3=\"$(pwd)/sqlite-amalgamation\""
-  }
-}
-```
-
-Your amalgamation directory must contain `sqlite3.c` and `sqlite3.h`. Any desired [compile time options](https://www.sqlite.org/compile.html) must be defined directly within `sqlite3.c`.
-
-### Step by step example
-
-If you're creating a package that relies on a custom build of `better-sqlite3-multiple-ciphers`, you can follow these steps to get started.
-
-1. Download the SQLite3 source code from [their website](https://sqlite.com/download.html) (e.g., `sqlite-amalgamation-1234567.zip`)
-2. Unzip the compressed archive
-3. Move the `sqlite3.c` and `sqlite3.h` files to your project folder
-4. Add a `preinstall` script to your `package.json`, like the one shown above
-5. Make sure the `--sqlite3` flag points to the location of your `sqlite3.c` and `sqlite3.h` files
-6. Define your preferred [compile time options](https://www.sqlite.org/compile.html) at the top of `sqlite3.c`
-7. Run `npm install` in your project folder
-
-If you're using a SQLite3 encryption extension that is a drop-in replacement for SQLite3 (such as [SEE](https://www.sqlite.org/see/doc/release/www/readme.wiki) or [sqleet](https://github.com/resilar/sqleet)), then simply replace `sqlite3.c` and `sqlite3.h` with the source files of your encryption extension.
-
-# Bundled configuration
-
-By default, this distribution currently uses SQLite3 **version 3.37.2** with the following [compilation options](https://www.sqlite.org/compile.html):
-
-```
-SQLITE_DQS=0
-SQLITE_LIKE_DOESNT_MATCH_BLOBS
-SQLITE_THREADSAFE=2
-SQLITE_USE_URI=0
-SQLITE_DEFAULT_MEMSTATUS=0
-SQLITE_OMIT_DEPRECATED
-SQLITE_OMIT_GET_TABLE
-SQLITE_OMIT_TCL_VARIABLE
-SQLITE_OMIT_PROGRESS_CALLBACK
-SQLITE_OMIT_SHARED_CACHE
-SQLITE_TRACE_SIZE_LIMIT=32
-SQLITE_DEFAULT_CACHE_SIZE=-16000
-SQLITE_DEFAULT_FOREIGN_KEYS=1
-SQLITE_DEFAULT_WAL_SYNCHRONOUS=1
-SQLITE_ENABLE_MATH_FUNCTIONS
-SQLITE_ENABLE_DESERIALIZE
-SQLITE_ENABLE_COLUMN_METADATA
-SQLITE_ENABLE_UPDATE_DELETE_LIMIT
-SQLITE_ENABLE_STAT4
-SQLITE_ENABLE_FTS3_PARENTHESIS
-SQLITE_ENABLE_FTS3
-SQLITE_ENABLE_FTS4
-SQLITE_ENABLE_FTS5
-SQLITE_ENABLE_JSON1
-SQLITE_ENABLE_RTREE
-SQLITE_ENABLE_GEOPOLY
-SQLITE_INTROSPECTION_PRAGMAS
-SQLITE_SOUNDEX
-HAVE_STDINT_H=1
-HAVE_INT8_T=1
-HAVE_INT16_T=1
-HAVE_INT32_T=1
-HAVE_UINT8_T=1
-HAVE_UINT16_T=1
-HAVE_UINT32_T=1
-SQLITE_USER_AUTHENTICATION=0
-```

package/docs/integer.md

@@ -1,79 +0,0 @@
-# The `BigInt` primitive type
-
-SQLite3 can store data in 64-bit signed integers, which are too big for JavaScript's [number format](https://en.wikipedia.org/wiki/Double-precision_floating-point_format) to fully represent. To support this data type, `better-sqlite3` is fully compatible with [BigInts](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt).
-
-```js
-const big = BigInt('1152735103331642317');
-big === 1152735103331642317n; // returns true
-big.toString(); // returns "1152735103331642317"
-typeof big; // returns "bigint"
-```
-
-## Binding BigInts
-
-`BigInts` can bind to [`Statements`](./api.md#class-statement) just like regular numbers. You can also return `BigInts` from [user-defined functions](./api.md#functionname-options-function---this). However, if you provide a `BigInt` that's too large to be a 64-bit signed integer, you'll get an error so that data integrity is protected.
-
-```js
-db.prepare("SELECT * FROM users WHERE id=?").get(BigInt('1152735103331642317'));
-db.prepare("INSERT INTO users (id) VALUES (?)").run(BigInt('1152735103331642317'));
-
-db.prepare("SELECT ?").get(2n ** 63n - 1n); // returns successfully
-db.prepare("SELECT ?").get(2n ** 63n); // throws a RangeError
-```
-
-## Getting BigInts from the database
-
-By default, integers returned from the database (including the [`info.lastInsertRowid`](./api.md#runbindparameters---object) property) are normal JavaScript numbers. You can change this default as you please:
-
-```js
-db.defaultSafeIntegers(); // BigInts by default
-db.defaultSafeIntegers(true); // BigInts by default
-db.defaultSafeIntegers(false); // Numbers by default
-```
-
-Additionally, you can override the default for individual [`Statements`](./api.md#class-statement) like so:
-
-```js
-const stmt = db.prepare(SQL);
-
-stmt.safeIntegers(); // Safe integers ON
-stmt.safeIntegers(true); // Safe integers ON
-stmt.safeIntegers(false); // Safe integers OFF
-```
-
-[User-defined functions](./api.md#functionname-options-function---this) can receive `BigInts` as arguments. You can override the database's default setting like so:
-
-```js
-db.function('isInt', { safeIntegers: true }, (value) => {
-  return String(typeof value === 'bigint');
-});
-
-db.prepare('SELECT isInt(?)').pluck().get(10); // => "false"
-db.prepare('SELECT isInt(?)').pluck().get(10n); // => "true"
-```
-
-Likewise, [user-defined aggregates](./api.md#aggregatename-options---this) and [virtual tables](./api.md#tablename-definition---this) can also receive `BigInts` as arguments:
-
-```js
-db.aggregate('addInts', {
-  safeIntegers: true,
-  start: 0n,
-  step: (total, nextValue) => total + nextValue,
-});
-```
-
-```js
-db.table('sequence', {
-  safeIntegers: true,
-  columns: ['value'],
-  parameters: ['length', 'start'],
-  rows: function* (length, start = 0n) {
-    const end = start + length;
-    for (let n = start; n < end; ++n) {
-      yield { value: n };
-    }
-  },
-});
-```
-
-It's worth noting that REAL (FLOAT) values returned from the database will always be represented as normal numbers.

package/docs/performance.md

@@ -1,39 +0,0 @@
-# Performance
-
-Concurrently reading and writing from an SQLite3 database can be very slow in some cases. Since concurrency is usually very important in web applications, it's recommended to turn on [WAL mode](https://www.sqlite.org/wal.html) to greatly increase overall performance.
-
-```js
-db.pragma('journal_mode = WAL');
-```
-
-WAL mode has a *few* disadvantages to consider:
-
-- Transactions that involve ATTACHed databases are atomic for each individual database, but are not atomic across all databases as a set.
-- Under rare circumstances, the [WAL file](https://www.sqlite.org/wal.html) may experience "checkpoint starvation" (see below).
-- There are some hardware/system limitations that may affect some users, [listed here](https://www.sqlite.org/wal.html).
-
-However, you trade those disadvantages for extremely fast performance in most web applications.
-
-## Checkpoint starvation
-
-Checkpoint starvation is when SQLite3 is unable to recycle the [WAL file](https://www.sqlite.org/wal.html) due to everlasting concurrent reads to the database. If this happens, the WAL file will grow without bound, leading to unacceptable amounts of disk usage and deteriorating performance.
-
-If you don't access the database from multiple processes or threads simultaneously, you'll never encounter this issue.
-
-If you do access the database from multiple processes or threads simultaneously, just use the [`wal_checkpoint(RESTART)`](https://www.sqlite.org/pragma.html#pragma_wal_checkpoint) pragma when the WAL file gets too big.
-
-```js
-setInterval(fs.stat.bind(null, 'foobar.db-wal', (err, stat) => {
-  if (err) {
-    if (err.code !== 'ENOENT') throw err;
-  } else if (stat.size > someUnacceptableSize) {
-    db.pragma('wal_checkpoint(RESTART)');
-  }
-}), 5000).unref();
-```
-
-## A note about durability
-
-This distribution of SQLite3 uses the `SQLITE_DEFAULT_WAL_SYNCHRONOUS=1` [compile-time option](https://sqlite.org/compile.html#default_wal_synchronous), which makes databases in WAL mode default to the ["NORMAL" synchronous setting](https://sqlite.org/pragma.html#pragma_synchronous). This allows applications to achieve extreme performance, but introduces a slight loss of [durability](https://en.wikipedia.org/wiki/Durability_(database_systems)) while in WAL mode.
-
-You can override this setting by running `db.pragma('synchronous = FULL')`.

package/docs/threads.md

@@ -1,97 +0,0 @@
-# Worker threads
-
-For most applications, `better-sqlite3` is fast enough to use in the main thread without blocking for a noticeable amount of time. However, if you need to perform very slow queries, you have the option of using [worker threads](https://nodejs.org/api/worker_threads.html) to keep things running smoothly. Below is an example of using a thread pool to perform queries in the background.
-
-### worker.js
-
-The worker logic is very simple in our case. It accepts messages from the master thread, executes each message's SQL (with any given parameters), and sends back the query results.
-
-```js
-const { parentPort } = require('worker_threads');
-const db = require('better-sqlite3-multiple-ciphers')('foobar.db');
-
-parentPort.on('message', ({ sql, parameters }) => {
-  const result = db.prepare(sql).all(...parameters);
-  parentPort.postMessage(result);
-});
-```
-
-### master.js
-
-The master thread is responsible for spawning workers, respawning threads that crash, and accepting query jobs.
-
-```js
-const { Worker } = require('worker_threads');
-const os = require('os');
-
-/*
-  Export a function that queues pending work.
- */
-
-const queue = [];
-exports.asyncQuery = (sql, ...parameters) => {
-  return new Promise((resolve, reject) => {
-    queue.push({
-      resolve,
-      reject,
-      message: { sql, parameters },
-    });
-    drainQueue();
-  });
-};
-
-/*
-  Instruct workers to drain the queue.
- */
-
-let workers = [];
-function drainQueue() {
-  for (const worker of workers) {
-    worker.takeWork();
-  }
-}
-
-/*
-  Spawn workers that try to drain the queue.
- */
-
-os.cpus().forEach(function spawn() {
-  const worker = new Worker('./worker.js');
-
-  let job = null; // Current item from the queue
-  let error = null; // Error that caused the worker to crash
-
-  function takeWork() {
-    if (!job && queue.length) {
-      // If there's a job in the queue, send it to the worker
-      job = queue.shift();
-      worker.postMessage(job.message);
-    }
-  }
-
-  worker
-    .on('online', () => {
-      workers.push({ takeWork });
-      takeWork();
-    })
-    .on('message', (result) => {
-      job.resolve(result);
-      job = null;
-      takeWork(); // Check if there's more work to do
-    })
-    .on('error', (err) => {
-      console.error(err);
-      error = err;
-    })
-    .on('exit', (code) => {
-      workers = workers.filter(w => w.takeWork !== takeWork);
-      if (job) {
-        job.reject(error || new Error('worker died'));
-      }
-      if (code !== 0) {
-        console.error(`worker exited with code ${code}`);
-        spawn(); // Worker died, so spawn a new one
-      }
-    });
-});
-```

package/docs/tips.md

@@ -1,35 +0,0 @@
-# Helpful tips for SQLite3
-
-## Creating good tables
-
-It's a good idea to use `INTEGER PRIMARY KEY AUTOINCREMENT` as one of the columns in a table. This ensures two things:
-
-- `INTEGER PRIMARY KEY`: improved performance by reusing SQLite3's built-in `rowid` column.
-- `AUTOINCREMENT`: no future row will have the same ID as an old one that was deleted. This can prevent potential bugs and security breaches.
-
-If you don't use `INTEGER PRIMARY KEY`, then you *must* use `NOT NULL` in all of your your primary key columns. Otherwise you'll be victim to an SQLite3 bug that allows primary keys to be `NULL`.
-
-Any column with `INTEGER PRIMARY KEY` will automatically increment when setting its value to `NULL`. But without `AUTOINCREMENT`, the behavior only ensures uniqueness from currently existing rows.
-
-It should be noted that `NULL` values count as unique from each other. This has implications when using the `UNIQUE` contraint or any other equality test.
-
-## Default values
-
-When a column has a `DEFAULT` value, it only gets applied when no value is specified for an `INSERT` statement. If the `INSERT` statement specifies a `NULL` value, the `DEFAULT` value is **NOT** used.
-
-## Foreign keys
-
-Foreign key constraints are not enforced if the child's column value is `NULL`. To ensure that a relationship is always enforced, use `NOT NULL` on the child column.
-
-Example:
-```sql
-CREATE TABLE comments (value TEXT, user_id INTEGER NOT NULL REFERENCES users);
-```
-
-Foreign key clauses can be followed by `ON DELETE` and/or `ON UPDATE`, with the following possible values:
-
-- `SET NULL`: if the parent column is deleted or updated, the child column becomes `NULL`.
-  - *NOTE: This still causes a constraint violation if the child column has `NOT NULL`*.
-- `SET DEFAULT`: if the parent column is updated or deleted, the child column becomes its `DEFAULT` value.
-  - *NOTE: This still causes a constraint violation if the child column's `DEFAULT` value does not correspond with an actual parent row*.
-- `CASCADE`: if the parent row is deleted, the child row is deleted; if the parent column is updated, the new value is propogated to the child column.

package/docs/troubleshooting.md

@@ -1,23 +0,0 @@
-# Troubleshooting installation
-
-If you have trouble installing `better-sqlite3-multiple-ciphers`, follow this checklist:
-
-1. Make sure you're using nodejs v10.20.1 or later
-
-2. Make sure you have [`node-gyp`](https://github.com/nodejs/node-gyp#installation) globally installed, including all of [its dependencies](https://github.com/nodejs/node-gyp#on-unix). On Windows you may need to [configure some things manually](https://github.com/nodejs/node-gyp#on-windows). Use `npm ls node-gyp` to make sure none of your local packages installed an outdated version of `node-gyp` that is used over the global one.
-
-3. If you're using [Electron](https://github.com/electron/electron), try running [`electron-rebuild`](https://www.npmjs.com/package/electron-rebuild)
-
-4. If you're using Windows, follow these steps. Do them **in this order**, and **don't skip steps**.
-
-    1. Install the **latest** of node 10, 12, or 14.
-    2. Install **latest** Visual Studio Community and Desktop Development with C++ extension.
-    3. Install **latest** Python.
-    4. Run following commands:
-    ```
-    npm config set msvs_version 2019
-    npm config set msbuild_path "C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\MSBuild\Current\Bin\MSBuild.exe"
-    ```
-    5. Run `npm install`
-
-If none of these solved your problem, try browsing [previous issues](https://github.com/JoshuaWise/better-sqlite3/issues?q=is%3Aissue) or open a [new issue](https://github.com/JoshuaWise/better-sqlite3/issues/new).

package/docs/unsafe.md

@@ -1,16 +0,0 @@
-# Unsafe mode
-
-By default, `better-sqlite3` prevents you from doing things that might corrupt your database or cause undefined behavior. Such unsafe operations include:
-
-- Anything blocked by [`SQLITE_DBCONFIG_DEFENSIVE`](https://www.sqlite.org/c3ref/c_dbconfig_defensive.html#sqlitedbconfigdefensive)
-- Mutating the database while [iterating](https://github.com/JoshuaWise/better-sqlite3/blob/master/docs/api.md#iteratebindparameters---iterator) through a query's result set
-
-However, some advanced users might want to use these functionalities at their own risk. For this reason, users have the option of enabling "unsafe mode".
-
-```js
-db.unsafeMode(); // Unsafe mode ON
-db.unsafeMode(true); // Unsafe mode ON
-db.unsafeMode(false); // Unsafe mode OFF
-```
-
-Unsafe mode can be toggled at any time, and independently for each database connection. While toggled on, `better-sqlite3` will not prevent you from performing the dangerous operations listed above.

package/src/better_sqlite3.lzz

@@ -1,88 +0,0 @@
-#hdr
-#include <climits>
-#include <cstdio>
-#include <cstring>
-#include <string>
-#include <vector>
-#include <set>
-#include <unordered_map>
-#include <algorithm>
-#include <sqlite3.h>
-#include <node.h>
-#include <node_object_wrap.h>
-#include <node_buffer.h>
-#end
-
-#insert "util/macros.lzz"
-#insert "util/query-macros.lzz"
-#insert "util/constants.lzz"
-#insert "util/bind-map.lzz"
-struct Addon;
-class Statement;
-class Backup;
-#insert "objects/database.lzz"
-#insert "objects/statement.lzz"
-#insert "objects/statement-iterator.lzz"
-#insert "objects/backup.lzz"
-#insert "util/data-converter.lzz"
-#insert "util/custom-function.lzz"
-#insert "util/custom-aggregate.lzz"
-#insert "util/custom-table.lzz"
-#insert "util/data.lzz"
-#insert "util/binder.lzz"
-
-struct Addon {
-	NODE_METHOD(JS_setErrorConstructor) {
-		REQUIRE_ARGUMENT_FUNCTION(first, v8::Local<v8::Function> SqliteError);
-		OnlyAddon->SqliteError.Reset(OnlyIsolate, SqliteError);
-	}
-
-	static void Cleanup(void* ptr) {
-		Addon* addon = static_cast<Addon*>(ptr);
-		for (Database* db : addon->dbs) db->CloseHandles();
-		addon->dbs.clear();
-		delete addon;
-	}
-
-	explicit Addon(v8::Isolate* isolate) :
-		privileged_info(NULL),
-		next_id(0),
-		cs(isolate) {}
-
-	inline sqlite3_uint64 NextId() {
-		return next_id++;
-	}
-
-	CopyablePersistent<v8::Function> Statement;
-	CopyablePersistent<v8::Function> StatementIterator;
-	CopyablePersistent<v8::Function> Backup;
-	CopyablePersistent<v8::Function> SqliteError;
-	NODE_ARGUMENTS_POINTER privileged_info;
-	sqlite3_uint64 next_id;
-	CS cs;
-	std::set<Database*, Database::CompareDatabase> dbs;
-};
-
-#src
-NODE_MODULE_INIT(/* exports, context */) {
-	v8::Isolate* isolate = context->GetIsolate();
-	v8::HandleScope scope(isolate);
-
-	// Initialize addon instance.
-	Addon* addon = new Addon(isolate);
-	v8::Local<v8::External> data = v8::External::New(isolate, addon);
-	node::AddEnvironmentCleanupHook(isolate, Addon::Cleanup, addon);
-
-	// Create and export native-backed classes and functions.
-	exports->Set(context, InternalizedFromLatin1(isolate, "Database"), Database::Init(isolate, data)).FromJust();
-	exports->Set(context, InternalizedFromLatin1(isolate, "Statement"), Statement::Init(isolate, data)).FromJust();
-	exports->Set(context, InternalizedFromLatin1(isolate, "StatementIterator"), StatementIterator::Init(isolate, data)).FromJust();
-	exports->Set(context, InternalizedFromLatin1(isolate, "Backup"), Backup::Init(isolate, data)).FromJust();
-	exports->Set(context, InternalizedFromLatin1(isolate, "setErrorConstructor"), v8::FunctionTemplate::New(isolate, Addon::JS_setErrorConstructor, data)->GetFunction(context).ToLocalChecked()).FromJust();
-
-	// Store addon instance data.
-	addon->Statement.Reset(isolate, exports->Get(context, InternalizedFromLatin1(isolate, "Statement")).ToLocalChecked().As<v8::Function>());
-	addon->StatementIterator.Reset(isolate, exports->Get(context, InternalizedFromLatin1(isolate, "StatementIterator")).ToLocalChecked().As<v8::Function>());
-	addon->Backup.Reset(isolate, exports->Get(context, InternalizedFromLatin1(isolate, "Backup")).ToLocalChecked().As<v8::Function>());
-}
-#end

package/src/objects/backup.lzz

@@ -1,138 +0,0 @@
-class Backup : public node::ObjectWrap {
-public:
-
-	INIT(Init) {
-		v8::Local<v8::FunctionTemplate> t = NewConstructorTemplate(isolate, data, JS_new, "Backup");
-		SetPrototypeMethod(isolate, data, t, "transfer", JS_transfer);
-		SetPrototypeMethod(isolate, data, t, "close", JS_close);
-		return t->GetFunction(OnlyContext).ToLocalChecked();
-	}
-
-	// Used to support ordered containers.
-	static inline bool Compare(Backup const * const a, Backup const * const b) {
-		return a->id < b->id;
-	}
-
-	// Whenever this is used, db->RemoveBackup must be invoked beforehand.
-	void CloseHandles() {
-		if (alive) {
-			alive = false;
-			std::string filename(sqlite3_db_filename(dest_handle, "main"));
-			sqlite3_backup_finish(backup_handle);
-			int status = sqlite3_close(dest_handle);
-			assert(status == SQLITE_OK); ((void)status);
-			if (unlink) remove(filename.c_str());
-		}
-	}
-
-	~Backup() {
-		if (alive) db->RemoveBackup(this);
-		CloseHandles();
-	}
-
-private:
-
-	explicit Backup(
-		Database* db,
-		sqlite3* dest_handle,
-		sqlite3_backup* backup_handle,
-		sqlite3_uint64 id,
-		bool unlink
-	) :
-		node::ObjectWrap(),
-		db(db),
-		dest_handle(dest_handle),
-		backup_handle(backup_handle),
-		id(id),
-		alive(true),
-		unlink(unlink) {
-		assert(db != NULL);
-		assert(dest_handle != NULL);
-		assert(backup_handle != NULL);
-		db->AddBackup(this);
-	}
-
-	NODE_METHOD(JS_new) {
-		UseAddon;
-		if (!addon->privileged_info) return ThrowTypeError("Disabled constructor");
-		assert(info.IsConstructCall());
-		Database* db = Unwrap<Database>(addon->privileged_info->This());
-		REQUIRE_DATABASE_OPEN(db->GetState());
-		REQUIRE_DATABASE_NOT_BUSY(db->GetState());
-
-		v8::Local<v8::Object> database = (*addon->privileged_info)[0].As<v8::Object>();
-		v8::Local<v8::String> attachedName = (*addon->privileged_info)[1].As<v8::String>();
-		v8::Local<v8::String> destFile = (*addon->privileged_info)[2].As<v8::String>();
-		bool unlink = (*addon->privileged_info)[3].As<v8::Boolean>()->Value();
-
-		UseIsolate;
-		sqlite3* dest_handle;
-		v8::String::Utf8Value dest_file(isolate, destFile);
-		v8::String::Utf8Value attached_name(isolate, attachedName);
-		int mask = (SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
-
-		if (sqlite3_open_v2(*dest_file, &dest_handle, mask, NULL) != SQLITE_OK) {
-			Database::ThrowSqliteError(addon, dest_handle);
-			int status = sqlite3_close(dest_handle);
-			assert(status == SQLITE_OK); ((void)status);
-			return;
-		}
-
-		sqlite3_extended_result_codes(dest_handle, 1);
-		sqlite3_limit(dest_handle, SQLITE_LIMIT_LENGTH, INT_MAX);
-		sqlite3_backup* backup_handle = sqlite3_backup_init(dest_handle, "main", db->GetHandle(), *attached_name);
-		if (backup_handle == NULL) {
-			Database::ThrowSqliteError(addon, dest_handle);
-			int status = sqlite3_close(dest_handle);
-			assert(status == SQLITE_OK); ((void)status);
-			return;
-		}
-
-		Backup* backup = new Backup(db, dest_handle, backup_handle, addon->NextId(), unlink);
-		backup->Wrap(info.This());
-		SetFrozen(isolate, OnlyContext, info.This(), addon->cs.database, database);
-
-		info.GetReturnValue().Set(info.This());
-	}
-
-	NODE_METHOD(JS_transfer) {
-		Backup* backup = Unwrap<Backup>(info.This());
-		REQUIRE_ARGUMENT_INT32(first, int pages);
-		REQUIRE_DATABASE_OPEN(backup->db->GetState());
-		assert(backup->db->GetState()->busy == false);
-		assert(backup->alive == true);
-
-		sqlite3_backup* backup_handle = backup->backup_handle;
-		int status = sqlite3_backup_step(backup_handle, pages) & 0xff;
-
-		Addon* addon = backup->db->GetAddon();
-		if (status == SQLITE_OK || status == SQLITE_DONE || status == SQLITE_BUSY) {
-			int total_pages = sqlite3_backup_pagecount(backup_handle);
-			int remaining_pages = sqlite3_backup_remaining(backup_handle);
-			UseIsolate;
-			UseContext;
-			v8::Local<v8::Object> result = v8::Object::New(isolate);
-			result->Set(ctx, addon->cs.totalPages.Get(isolate), v8::Int32::New(isolate, total_pages)).FromJust();
-			result->Set(ctx, addon->cs.remainingPages.Get(isolate), v8::Int32::New(isolate, remaining_pages)).FromJust();
-			info.GetReturnValue().Set(result);
-			if (status == SQLITE_DONE) backup->unlink = false;
-		} else {
-			Database::ThrowSqliteError(addon, sqlite3_errstr(status), status);
-		}
-	}
-
-	NODE_METHOD(JS_close) {
-		Backup* backup = Unwrap<Backup>(info.This());
-		assert(backup->db->GetState()->busy == false);
-		if (backup->alive) backup->db->RemoveBackup(backup);
-		backup->CloseHandles();
-		info.GetReturnValue().Set(info.This());
-	}
-
-	Database* const db;
-	sqlite3* const dest_handle;
-	sqlite3_backup* const backup_handle;
-	const sqlite3_uint64 id;
-	bool alive;
-	bool unlink;
-};