Commit f2b698f1cf7 for nodejs
commit f2b698f1cf7e03581e9a4a36e66424cecb153520
Author: Guilherme Araújo <arauujogui@gmail.com>
Date: Fri Sep 25 21:03:45 2026 -0300
sqlite: rename DatabaseSync and StatementSync
Rename the DatabaseSync and StatementSync classes to Database and
Statement, and the internal DatabaseSyncLimits helper to
DatabaseLimits. The old names are kept as aliases of the new classes
and are Documentation-only deprecated (DEP0210, DEP0211).
Assisted-by: Claude Code
Signed-off-by: Guilherme Araújo <arauujogui@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/65988
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Gürgün Dayıoğlu <hey@gurgun.day>
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Robert Nagy <ronagy@icloud.com>
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
diff --git a/SECURITY.md b/SECURITY.md
index f5a4ef3370a..7afe640ecf6 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -430,14 +430,14 @@ the community they pose.
* Examples of scenarios that are **not** Node.js vulnerabilities:
* Allowing untrusted users to register SQLite user-defined functions via
- `node:sqlite` (`DatabaseSync`) that can perform arbitrary operations
+ `node:sqlite` (`Database`) that can perform arbitrary operations
(e.g., closing database connections during query execution, causing crashes
or use-after-free conditions).
* Loading SQLite extensions using the `allowExtension` option in
- `DatabaseSync` — this option must be explicitly set to `true` by the
+ `Database` — this option must be explicitly set to `true` by the
application, and enabling it is the application operator's responsibility.
* Using `node:sqlite` built-in SQL functions or pragmas (e.g.,
- `ATTACH DATABASE`) to read or write files — `DatabaseSync` operates with
+ `ATTACH DATABASE`) to read or write files — `Database` operates with
the same file-system access as the process itself, and it is the
application's responsibility to restrict what SQL is executed.
* Exposing `child_process.exec()` or similar APIs to untrusted users without
@@ -532,7 +532,7 @@ The following are **not** vulnerabilities in Node.js:
access. Inconsistent checks on these paths are treated as regular bugs and
should be reported through the public issue tracker.
-* **`node:sqlite` and the permission model**: `DatabaseSync` operates with the
+* **`node:sqlite` and the permission model**: `Database` operates with the
same file-system privileges as the process. Using SQL pragmas or built-in
SQLite mechanisms (e.g., `ATTACH DATABASE`) to access files does not bypass
the permission model — the permission model does not intercept SQL-level
diff --git a/benchmark/sqlite/sqlite-diagnostic-channel.js b/benchmark/sqlite/sqlite-diagnostic-channel.js
index 0610839653d..a962a97d7c3 100644
--- a/benchmark/sqlite/sqlite-diagnostic-channel.js
+++ b/benchmark/sqlite/sqlite-diagnostic-channel.js
@@ -12,7 +12,7 @@ const bench = common.createBenchmark(main, {
function main(conf) {
const { n, mode } = conf;
- const db = new sqlite.DatabaseSync(':memory:');
+ const db = new sqlite.Database(':memory:');
db.exec('CREATE TABLE t (x INTEGER)');
const insert = db.prepare('INSERT INTO t VALUES (?)');
diff --git a/benchmark/sqlite/sqlite-is-transaction.js b/benchmark/sqlite/sqlite-is-transaction.js
index dca31a18d98..b4b7f238d03 100644
--- a/benchmark/sqlite/sqlite-is-transaction.js
+++ b/benchmark/sqlite/sqlite-is-transaction.js
@@ -9,7 +9,7 @@ const bench = common.createBenchmark(main, {
});
function main(conf) {
- const db = new sqlite.DatabaseSync(':memory:');
+ const db = new sqlite.Database(':memory:');
if (conf.transaction === 'true') {
db.exec('BEGIN');
diff --git a/benchmark/sqlite/sqlite-prepare-insert.js b/benchmark/sqlite/sqlite-prepare-insert.js
index 58e97274c98..2f56fd5602f 100644
--- a/benchmark/sqlite/sqlite-prepare-insert.js
+++ b/benchmark/sqlite/sqlite-prepare-insert.js
@@ -17,7 +17,7 @@ const bench = common.createBenchmark(main, {
});
function main(conf) {
- const db = new sqlite.DatabaseSync(':memory:');
+ const db = new sqlite.Database(':memory:');
db.exec('CREATE TABLE text_column_type (text_column TEXT)');
db.exec('CREATE TABLE integer_column_type (integer_column INTEGER)');
diff --git a/benchmark/sqlite/sqlite-prepare-select-all-options.js b/benchmark/sqlite/sqlite-prepare-select-all-options.js
index 336a6b176b0..9acada928b8 100644
--- a/benchmark/sqlite/sqlite-prepare-select-all-options.js
+++ b/benchmark/sqlite/sqlite-prepare-select-all-options.js
@@ -19,7 +19,7 @@ function main(conf) {
return acc;
}, {});
- const db = new sqlite.DatabaseSync(':memory:', optionsObj);
+ const db = new sqlite.Database(':memory:', optionsObj);
db.exec(
'CREATE TABLE foo (text_column TEXT, integer_column INTEGER, real_column REAL, blob_column BLOB)',
diff --git a/benchmark/sqlite/sqlite-prepare-select-all.js b/benchmark/sqlite/sqlite-prepare-select-all.js
index c8487dca471..e4d269b6afd 100644
--- a/benchmark/sqlite/sqlite-prepare-select-all.js
+++ b/benchmark/sqlite/sqlite-prepare-select-all.js
@@ -24,7 +24,7 @@ const bench = common.createBenchmark(main, {
});
function main(conf) {
- const db = new sqlite.DatabaseSync(':memory:');
+ const db = new sqlite.Database(':memory:');
// Create only the necessary table for the benchmark type.
// If the statement includes 'foo_large', create the foo_large table; otherwise, create the foo table.
diff --git a/benchmark/sqlite/sqlite-prepare-select-get-options.js b/benchmark/sqlite/sqlite-prepare-select-get-options.js
index eb2e5074151..bbd23b69dcf 100644
--- a/benchmark/sqlite/sqlite-prepare-select-get-options.js
+++ b/benchmark/sqlite/sqlite-prepare-select-get-options.js
@@ -18,7 +18,7 @@ function main(conf) {
return acc;
}, {});
- const db = new sqlite.DatabaseSync(':memory:', optionsObj);
+ const db = new sqlite.Database(':memory:', optionsObj);
db.exec(
'CREATE TABLE foo (text_column TEXT, integer_column INTEGER, real_column REAL, blob_column BLOB)',
diff --git a/benchmark/sqlite/sqlite-prepare-select-get.js b/benchmark/sqlite/sqlite-prepare-select-get.js
index 0fff29ce568..c7d2a9f833b 100644
--- a/benchmark/sqlite/sqlite-prepare-select-get.js
+++ b/benchmark/sqlite/sqlite-prepare-select-get.js
@@ -18,7 +18,7 @@ const bench = common.createBenchmark(main, {
});
function main(conf) {
- const db = new sqlite.DatabaseSync(':memory:');
+ const db = new sqlite.Database(':memory:');
// Create only the necessary table for the benchmark type.
// If the statement includes 'foo_large', create the foo_large table; otherwise, create the foo table.
diff --git a/doc/api/deprecations.md b/doc/api/deprecations.md
index 5179f0bc542..61f8ad523ec 100644
--- a/doc/api/deprecations.md
+++ b/doc/api/deprecations.md
@@ -4801,6 +4801,34 @@ async function example() {
}
```
+### DEP0210: `sqlite.DatabaseSync`
+
+<!-- YAML
+changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/65988
+ description: Documentation-only deprecation.
+-->
+
+Type: Documentation-only
+
+`node:sqlite`'s `DatabaseSync` class was renamed to `Database`. `DatabaseSync`
+is kept as a deprecated alias. Use `Database` instead.
+
+### DEP0211: `sqlite.StatementSync`
+
+<!-- YAML
+changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/65988
+ description: Documentation-only deprecation.
+-->
+
+Type: Documentation-only
+
+`node:sqlite`'s `StatementSync` class was renamed to `Statement`.
+`StatementSync` is kept as a deprecated alias. Use `Statement` instead.
+
[DEP0142]: #dep0142-repl_builtinlibs
[DEP0156]: #dep0156-aborted-property-and-abort-aborted-event-in-http
[NIST SP 800-38D]: https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf
diff --git a/doc/api/diagnostics_channel.md b/doc/api/diagnostics_channel.md
index 1509c830b99..d250817aa20 100644
--- a/doc/api/diagnostics_channel.md
+++ b/doc/api/diagnostics_channel.md
@@ -2003,14 +2003,14 @@ added: v26.8.0
* `sql` {string} The expanded SQL with bound parameter values substituted.
If expansion fails, the source SQL with unsubstituted placeholders is used
instead.
-* `database` {DatabaseSync} The [`DatabaseSync`][] instance that executed the
+* `database` {Database} The [`Database`][] instance that executed the
statement.
* `duration` {number} SQLite's internal estimate of the statement run time in
nanoseconds. This reflects C-layer execution time only and does not include
JavaScript binding overhead such as argument marshaling or result-row
construction.
-Emitted after a SQL statement finishes executing against a [`DatabaseSync`][]
+Emitted after a SQL statement finishes executing against a [`Database`][]
instance. This is a **profiling** event: it fires once per statement upon
completion and reports an estimated duration from SQLite's internal profiler.
It is not a distributed-tracing span. There is no corresponding start event,
@@ -2032,7 +2032,7 @@ statement, since both are still in use while the event is being delivered; see
[`--enable-fips-indicator-events`]: cli.md#--enable-fips-indicator-events
[`--force-fips=strict`]: cli.md#--force-fips
[`BoundedChannel`]: #class-boundedchannel
-[`DatabaseSync`]: sqlite.md#class-databasesync
+[`Database`]: sqlite.md#class-database
[`TracingChannel`]: #class-tracingchannel
[`asyncEnd` event]: #asyncendevent
[`asyncStart` event]: #asyncstartevent
diff --git a/doc/api/sqlite.md b/doc/api/sqlite.md
index 5866d035da5..4bfa5ab0602 100644
--- a/doc/api/sqlite.md
+++ b/doc/api/sqlite.md
@@ -40,8 +40,8 @@ The following example shows the basic usage of the `node:sqlite` module to open
an in-memory database, write data to the database, and then read the data back.
```mjs
-import { DatabaseSync } from 'node:sqlite';
-const database = new DatabaseSync(':memory:');
+import { Database } from 'node:sqlite';
+const database = new Database(':memory:');
// Execute SQL statements from strings.
database.exec(`
@@ -66,8 +66,8 @@ query.close();
```
```cjs
-const { DatabaseSync } = require('node:sqlite');
-const database = new DatabaseSync(':memory:');
+const { Database } = require('node:sqlite');
+const database = new Database(':memory:');
// Execute SQL statements from strings.
database.exec(`
@@ -124,7 +124,7 @@ option for user-defined functions. If Node.js reads an `INTEGER` value from
SQLite that is outside the JavaScript [safe integer][] range, and the option to
read BigInts is not enabled, then an `ERR_OUT_OF_RANGE` error will be thrown.
-## Class: `DatabaseSync`
+## Class: `Database`
<!-- YAML
added: v22.5.0
@@ -144,7 +144,11 @@ changes:
This class represents a single [connection][] to a SQLite database. All APIs
exposed by this class execute synchronously.
-### `new DatabaseSync(path[, options])`
+`DatabaseSync` is a deprecated alias for `Database`, kept for backward
+compatibility with the class's previous name. See
+[DEP0210](deprecations.md#dep0210-sqlitedatabasesync).
+
+### `new Database(path[, options])`
<!-- YAML
added: v22.5.0
@@ -223,7 +227,7 @@ changes:
* `variableNumber` {number} Maximum number of SQL variables.
* `triggerDepth` {number} Maximum trigger recursion depth.
-Constructs a new `DatabaseSync` instance.
+Constructs a new `Database` instance.
### `database.aggregate(name, options)`
@@ -266,9 +270,9 @@ Registers a new aggregate function with the SQLite database. This method is a wr
When used as a window function, the `result` function will be called multiple times.
```cjs
-const { DatabaseSync } = require('node:sqlite');
+const { Database } = require('node:sqlite');
-const db = new DatabaseSync(':memory:');
+const db = new Database(':memory:');
db.exec(`
CREATE TABLE t3(x, y);
INSERT INTO t3 VALUES ('a', 4),
@@ -288,9 +292,9 @@ query.get(); // { total: 21 }
```
```mjs
-import { DatabaseSync } from 'node:sqlite';
+import { Database } from 'node:sqlite';
-const db = new DatabaseSync(':memory:');
+const db = new Database(':memory:');
db.exec(`
CREATE TABLE t3(x, y);
INSERT INTO t3 VALUES ('a', 4),
@@ -336,11 +340,11 @@ added:
Loads a shared library into the database connection. This method is a wrapper
around [`sqlite3_load_extension()`][]. It is required to enable the
-`allowExtension` option when constructing the `DatabaseSync` instance.
+`allowExtension` option when constructing the `Database` instance.
```mjs
-import { DatabaseSync } from 'node:sqlite';
-const database = new DatabaseSync(':memory:', { allowExtension: true });
+import { Database } from 'node:sqlite';
+const database = new Database(':memory:', { allowExtension: true });
// Load using the entry point derived from the filename.
database.loadExtension('./decimal.dylib');
@@ -350,8 +354,8 @@ database.loadExtension('./base64.dylib', 'sqlite3_base64_init');
```
```cjs
-const { DatabaseSync } = require('node:sqlite');
-const database = new DatabaseSync(':memory:', { allowExtension: true });
+const { Database } = require('node:sqlite');
+const database = new Database(':memory:', { allowExtension: true });
// Load using the entry point derived from the filename.
database.loadExtension('./decimal.dylib');
@@ -506,8 +510,8 @@ Operations that touch no SQLite state stay available from the callback:
`{ done: true }`.
```cjs
-const { DatabaseSync, constants } = require('node:sqlite');
-const db = new DatabaseSync(':memory:');
+const { Database, constants } = require('node:sqlite');
+const db = new Database(':memory:');
// Set up an authorizer that denies all table creation
db.setAuthorizer((actionCode) => {
@@ -530,8 +534,8 @@ try {
```
```mjs
-import { DatabaseSync, constants } from 'node:sqlite';
-const db = new DatabaseSync(':memory:');
+import { Database, constants } from 'node:sqlite';
+const db = new Database(':memory:');
// Set up an authorizer that denies all table creation
db.setAuthorizer((actionCode) => {
@@ -588,7 +592,7 @@ An object for getting and setting SQLite database limits at runtime.
Each property corresponds to an SQLite limit and can be read or written.
```js
-const db = new DatabaseSync(':memory:');
+const db = new Database(':memory:');
// Read current limit
console.log(db.limits.length);
@@ -612,7 +616,7 @@ Setting a property to `Infinity` resets the limit to its compile-time maximum va
added: v22.5.0
-->
-Opens the database specified in the `path` argument of the `DatabaseSync`
+Opens the database specified in the `path` argument of the `Database`
constructor. This method should only be used when the database is not opened via
the constructor. An exception is thrown if the database is already open.
@@ -634,9 +638,9 @@ Serializes the database into a binary representation, returned as a
database. This method is a wrapper around [`sqlite3_serialize()`][].
```mjs
-import { DatabaseSync } from 'node:sqlite';
+import { Database } from 'node:sqlite';
-const db = new DatabaseSync(':memory:');
+const db = new Database(':memory:');
db.exec('CREATE TABLE t(key INTEGER PRIMARY KEY, value TEXT)');
db.exec("INSERT INTO t VALUES (1, 'hello')");
const buffer = db.serialize();
@@ -644,9 +648,9 @@ console.log(buffer.length); // Prints the byte length of the database
```
```cjs
-const { DatabaseSync } = require('node:sqlite');
+const { Database } = require('node:sqlite');
-const db = new DatabaseSync(':memory:');
+const db = new Database(':memory:');
db.exec('CREATE TABLE t(key INTEGER PRIMARY KEY, value TEXT)');
db.exec("INSERT INTO t VALUES (1, 'hello')");
const buffer = db.serialize();
@@ -676,15 +680,15 @@ function, an aggregate function, an authorizer, or a changeset filter or conflic
handler. This method is a wrapper around [`sqlite3_deserialize()`][].
```mjs
-import { DatabaseSync } from 'node:sqlite';
+import { Database } from 'node:sqlite';
-const original = new DatabaseSync(':memory:');
+const original = new Database(':memory:');
original.exec('CREATE TABLE t(key INTEGER PRIMARY KEY, value TEXT)');
original.exec("INSERT INTO t VALUES (1, 'hello')");
const buffer = original.serialize();
original.close();
-const clone = new DatabaseSync(':memory:');
+const clone = new Database(':memory:');
clone.deserialize(buffer);
using query = clone.prepare('SELECT value FROM t');
console.log(query.get());
@@ -692,15 +696,15 @@ console.log(query.get());
```
```cjs
-const { DatabaseSync } = require('node:sqlite');
+const { Database } = require('node:sqlite');
-const original = new DatabaseSync(':memory:');
+const original = new Database(':memory:');
original.exec('CREATE TABLE t(key INTEGER PRIMARY KEY, value TEXT)');
original.exec("INSERT INTO t VALUES (1, 'hello')");
const buffer = original.serialize();
original.close();
-const clone = new DatabaseSync(':memory:');
+const clone = new Database(':memory:');
clone.deserialize(buffer);
using query = clone.prepare('SELECT value FROM t');
console.log(query.get());
@@ -737,7 +741,7 @@ changes:
be retained for a long time and likely reused many times. SQLite currently
responds to this hint by avoiding lookaside memory. Corresponds to the
[`SQLITE_PREPARE_PERSISTENT`][] flag. **Default:** `false`.
-* Returns: {StatementSync} The prepared statement.
+* Returns: {Statement} The prepared statement.
Compiles a SQL statement into a [prepared statement][]. This method is a wrapper
around [`sqlite3_prepare_v3()`][].
@@ -817,9 +821,9 @@ syntax. Do not add parameter binding placeholders (`?` etc.) to the SQL query
string itself.
```mjs
-import { DatabaseSync } from 'node:sqlite';
+import { Database } from 'node:sqlite';
-const db = new DatabaseSync(':memory:');
+const db = new Database(':memory:');
const sql = db.createTagStore();
db.exec('CREATE TABLE users (id INT, name TEXT)');
@@ -844,9 +848,9 @@ console.log(allUsers);
```
```cjs
-const { DatabaseSync } = require('node:sqlite');
+const { Database } = require('node:sqlite');
-const db = new DatabaseSync(':memory:');
+const db = new Database(':memory:');
const sql = db.createTagStore();
db.exec('CREATE TABLE users (id INT, name TEXT)');
@@ -927,9 +931,9 @@ db.createModule('counter', {
```
```cjs
-const { DatabaseSync } = require('node:sqlite');
+const { Database } = require('node:sqlite');
-const db = new DatabaseSync(':memory:');
+const db = new Database(':memory:');
db.createModule('generate_series', {
columns: [
@@ -953,9 +957,9 @@ console.log(db.prepare('SELECT * FROM generate_series(1, 5, 1)').all());
```
```mjs
-import { DatabaseSync } from 'node:sqlite';
+import { Database } from 'node:sqlite';
-const db = new DatabaseSync(':memory:');
+const db = new Database(':memory:');
db.createModule('generate_series', {
columns: [
@@ -1038,10 +1042,10 @@ An exception is thrown if the database is not
open. This method is a wrapper around [`sqlite3changeset_apply()`][].
```mjs
-import { DatabaseSync } from 'node:sqlite';
+import { Database } from 'node:sqlite';
-const sourceDb = new DatabaseSync(':memory:');
-const targetDb = new DatabaseSync(':memory:');
+const sourceDb = new Database(':memory:');
+const targetDb = new Database(':memory:');
sourceDb.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
targetDb.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
@@ -1058,10 +1062,10 @@ targetDb.applyChangeset(changeset);
```
```cjs
-const { DatabaseSync } = require('node:sqlite');
+const { Database } = require('node:sqlite');
-const sourceDb = new DatabaseSync(':memory:');
-const targetDb = new DatabaseSync(':memory:');
+const sourceDb = new Database(':memory:');
+const targetDb = new Database(':memory:');
sourceDb.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
targetDb.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
@@ -1147,7 +1151,7 @@ Closes the session. If the session is already closed, then this is a no-op. An
a changeset or patchset, or if the method is called from a callback that SQLite
invoked, under the same conditions as [`session.close()`][].
-## Class: `StatementSync`
+## Class: `Statement`
<!-- YAML
added: v22.5.0
@@ -1158,6 +1162,10 @@ instantiated via its constructor. Instead, instances are created via the
`database.prepare()` method. All APIs exposed by this class execute
synchronously.
+`StatementSync` is a deprecated alias for `Statement`, kept for backward
+compatibility with the class's previous name. See
+[DEP0211](deprecations.md#dep0211-sqlitestatementsync).
+
A prepared statement is an efficient binary representation of the SQL used to
create it. Prepared statements are parameterizable, and can be invoked multiple
times with different bound values. Parameters also offer protection against
@@ -1758,9 +1766,9 @@ A read-only property that returns the maximum number of prepared statements the
added: v24.9.0
-->
-* Type: {DatabaseSync}
+* Type: {Database}
-A read-only property that returns the `DatabaseSync` object associated with this `SQLTagStore`.
+A read-only property that returns the `Database` object associated with this `SQLTagStore`.
### `sqlTagStore.clear()`
@@ -1782,7 +1790,7 @@ changes:
description: The `path` argument now supports Buffer and URL objects.
-->
-* `sourceDb` {DatabaseSync} The database to backup. The source database must be open.
+* `sourceDb` {Database} The database to backup. The source database must be open.
* `path` {string | Buffer | URL} The path where the backup will be created. If the file already exists,
the contents will be overwritten.
* `options` {Object} Optional configuration for the backup. The
@@ -1802,14 +1810,14 @@ This method makes a database backup. This method abstracts the [`sqlite3_backup_
and [`sqlite3_backup_finish()`][] functions.
The backed-up database can be used normally during the backup process. Mutations coming from the same connection - same
-{DatabaseSync} - object will be reflected in the backup right away. However, mutations from other connections will cause
+{Database} - object will be reflected in the backup right away. However, mutations from other connections will cause
the backup process to restart.
```cjs
-const { backup, DatabaseSync } = require('node:sqlite');
+const { backup, Database } = require('node:sqlite');
(async () => {
- const sourceDb = new DatabaseSync('source.db');
+ const sourceDb = new Database('source.db');
const totalPagesTransferred = await backup(sourceDb, 'backup.db', {
rate: 1, // Copy one page at a time.
progress: ({ totalPages, remainingPages }) => {
@@ -1822,9 +1830,9 @@ const { backup, DatabaseSync } = require('node:sqlite');
```
```mjs
-import { backup, DatabaseSync } from 'node:sqlite';
+import { backup, Database } from 'node:sqlite';
-const sourceDb = new DatabaseSync('source.db');
+const sourceDb = new Database('source.db');
const totalPagesTransferred = await backup(sourceDb, 'backup.db', {
rate: 1, // Copy one page at a time.
progress: ({ totalPages, remainingPages }) => {
diff --git a/doc/type-map.json b/doc/type-map.json
index 9e24eaca3e5..c603e059a7e 100644
--- a/doc/type-map.json
+++ b/doc/type-map.json
@@ -35,7 +35,7 @@
"CryptoKeyPair": "webcrypto.html#class-cryptokeypair",
"CShakeParams": "webcrypto.html#class-cshakeparams",
"CustomEvent": "events.html#class-customevent",
- "DatabaseSync": "sqlite.html#class-databasesync",
+ "Database": "sqlite.html#class-database",
"Decipher": "crypto.html#class-decipher",
"Decipheriv": "crypto.html#class-decipheriv",
"DiffieHellman": "crypto.html#class-diffiehellman",
@@ -125,7 +125,7 @@
"Shareable": "stream_iter.html#interface-shareable",
"Sign": "crypto.html#class-sign",
"SQLTagStore": "sqlite.html#class-sqltagstore",
- "StatementSync": "sqlite.html#class-statementsync",
+ "Statement": "sqlite.html#class-statement",
"Stream": "stream.html#stream",
"SubtleCrypto": "webcrypto.html#class-subtlecrypto",
"SuiteContext": "test.html#class-suitecontext",
diff --git a/lib/sqlite.js b/lib/sqlite.js
index db781a21ee1..4934a4b7700 100644
--- a/lib/sqlite.js
+++ b/lib/sqlite.js
@@ -1,3 +1,18 @@
'use strict';
-module.exports = internalBinding('sqlite');
+const { Database, Statement, Session, constants, backup } =
+ internalBinding('sqlite');
+
+module.exports = {
+ Database,
+ // DEP0210: Documentation-only deprecation, kept for backward
+ // compatibility with the class's pre-rename name.
+ DatabaseSync: Database,
+ Statement,
+ // DEP0211: Documentation-only deprecation, kept for backward
+ // compatibility with the class's pre-rename name.
+ StatementSync: Statement,
+ Session,
+ constants,
+ backup,
+};
diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc
index 0e9691a13b2..3234d9881b5 100644
--- a/src/node_sqlite.cc
+++ b/src/node_sqlite.cc
@@ -92,7 +92,7 @@ BindingData::BindingData(Realm* realm, Local<Object> wrap)
void BindingData::MemoryInfo(MemoryTracker* tracker) const {
tracker->TrackFieldWithSize("open_databases",
- open_databases.size() * sizeof(DatabaseSync*),
+ open_databases.size() * sizeof(Database*),
"open_databases");
}
@@ -346,9 +346,9 @@ void JSValueToSQLiteResult(Isolate* isolate,
}
}
-class DatabaseSync;
+class Database;
-inline void THROW_ERR_SQLITE_ERROR(Isolate* isolate, DatabaseSync* db) {
+inline void THROW_ERR_SQLITE_ERROR(Isolate* isolate, Database* db) {
if (db->ShouldIgnoreSQLiteError()) {
db->SetIgnoreNextSQLiteError(false);
return;
@@ -395,7 +395,7 @@ inline MaybeLocal<Value> NullableSQLiteStringToValue(Isolate* isolate,
class CustomAggregate {
public:
explicit CustomAggregate(Environment* env,
- BaseObjectWeakPtr<DatabaseSync> db,
+ BaseObjectWeakPtr<Database> db,
bool use_bigint_args,
Local<Value> start,
Local<Function> step_fn,
@@ -581,7 +581,7 @@ class CustomAggregate {
}
Environment* env_;
- BaseObjectWeakPtr<DatabaseSync> db_;
+ BaseObjectWeakPtr<Database> db_;
bool use_bigint_args_;
Global<Value> start_;
Global<Function> step_fn_;
@@ -592,7 +592,7 @@ class CustomAggregate {
class BackupJob : public ThreadPoolWork {
public:
explicit BackupJob(Environment* env,
- DatabaseSync* source,
+ Database* source,
Local<Promise::Resolver> resolver,
std::string source_db,
std::string destination_name,
@@ -756,7 +756,7 @@ class BackupJob : public ThreadPoolWork {
Environment* env() const { return env_; }
Environment* env_;
- BaseObjectPtr<DatabaseSync> source_;
+ BaseObjectPtr<Database> source_;
Global<Promise::Resolver> resolver_;
Global<Function> progressFunc_;
struct Sqlite3Deleter {
@@ -776,7 +776,7 @@ class BackupJob : public ThreadPoolWork {
UserDefinedFunction::UserDefinedFunction(Environment* env,
Local<Function> fn,
- BaseObjectWeakPtr<DatabaseSync> db,
+ BaseObjectWeakPtr<Database> db,
bool use_bigint_args)
: env_(env),
fn_(env->isolate(), fn),
@@ -847,26 +847,26 @@ void UserDefinedFunction::xDestroy(void* self) {
delete static_cast<UserDefinedFunction*>(self);
}
-DatabaseSyncLimits::DatabaseSyncLimits(Environment* env,
- Local<Object> object,
- BaseObjectWeakPtr<DatabaseSync> database)
+DatabaseLimits::DatabaseLimits(Environment* env,
+ Local<Object> object,
+ BaseObjectWeakPtr<Database> database)
: BaseObject(env, object), database_(std::move(database)) {
MakeWeak();
}
-DatabaseSyncLimits::~DatabaseSyncLimits() = default;
+DatabaseLimits::~DatabaseLimits() = default;
-void DatabaseSyncLimits::MemoryInfo(MemoryTracker* tracker) const {
+void DatabaseLimits::MemoryInfo(MemoryTracker* tracker) const {
tracker->TrackField("database", database_);
}
-Local<ObjectTemplate> DatabaseSyncLimits::GetTemplate(Environment* env) {
+Local<ObjectTemplate> DatabaseLimits::GetTemplate(Environment* env) {
Local<ObjectTemplate> tmpl = env->sqlite_limits_template();
if (!tmpl.IsEmpty()) return tmpl;
Isolate* isolate = env->isolate();
tmpl = ObjectTemplate::New(isolate);
- tmpl->SetInternalFieldCount(DatabaseSyncLimits::kInternalFieldCount);
+ tmpl->SetInternalFieldCount(DatabaseLimits::kInternalFieldCount);
tmpl->SetHandler(NamedPropertyHandlerConfiguration(
LimitsGetter,
LimitsSetter,
@@ -882,14 +882,14 @@ Local<ObjectTemplate> DatabaseSyncLimits::GetTemplate(Environment* env) {
return tmpl;
}
-Intercepted DatabaseSyncLimits::LimitsGetter(
+Intercepted DatabaseLimits::LimitsGetter(
Local<Name> property, const PropertyCallbackInfo<Value>& info) {
// Skip symbols
if (!property->IsString()) {
return Intercepted::kNo;
}
- DatabaseSyncLimits* limits;
+ DatabaseLimits* limits;
ASSIGN_OR_RETURN_UNWRAP(&limits, info.HolderV2(), Intercepted::kNo);
Environment* env = limits->env();
@@ -914,7 +914,7 @@ Intercepted DatabaseSyncLimits::LimitsGetter(
return Intercepted::kYes;
}
-Intercepted DatabaseSyncLimits::LimitsSetter(
+Intercepted DatabaseLimits::LimitsSetter(
Local<Name> property,
Local<Value> value,
const PropertyCallbackInfo<void>& info) {
@@ -922,7 +922,7 @@ Intercepted DatabaseSyncLimits::LimitsSetter(
return Intercepted::kNo;
}
- DatabaseSyncLimits* limits;
+ DatabaseLimits* limits;
ASSIGN_OR_RETURN_UNWRAP(&limits, info.HolderV2(), Intercepted::kNo);
Environment* env = limits->env();
@@ -976,7 +976,7 @@ Intercepted DatabaseSyncLimits::LimitsSetter(
return Intercepted::kYes;
}
-Intercepted DatabaseSyncLimits::LimitsQuery(
+Intercepted DatabaseLimits::LimitsQuery(
Local<Name> property, const PropertyCallbackInfo<Integer>& info) {
if (!property->IsString()) {
return Intercepted::kNo;
@@ -997,8 +997,7 @@ Intercepted DatabaseSyncLimits::LimitsQuery(
return Intercepted::kYes;
}
-void DatabaseSyncLimits::LimitsEnumerator(
- const PropertyCallbackInfo<Array>& info) {
+void DatabaseLimits::LimitsEnumerator(const PropertyCallbackInfo<Array>& info) {
Isolate* isolate = info.GetIsolate();
LocalVector<Value> names(isolate);
@@ -1015,14 +1014,14 @@ void DatabaseSyncLimits::LimitsEnumerator(
info.GetReturnValue().Set(Array::New(isolate, names.data(), names.size()));
}
-BaseObjectPtr<DatabaseSyncLimits> DatabaseSyncLimits::Create(
- Environment* env, BaseObjectWeakPtr<DatabaseSync> database) {
+BaseObjectPtr<DatabaseLimits> DatabaseLimits::Create(
+ Environment* env, BaseObjectWeakPtr<Database> database) {
Local<Object> obj;
if (!GetTemplate(env)->NewInstance(env->context()).ToLocal(&obj)) {
return nullptr;
}
- return MakeBaseObject<DatabaseSyncLimits>(env, obj, std::move(database));
+ return MakeBaseObject<DatabaseLimits>(env, obj, std::move(database));
}
// ---------------------------------------------------------------------------
@@ -1030,7 +1029,7 @@ BaseObjectPtr<DatabaseSyncLimits> DatabaseSyncLimits::Create(
// ---------------------------------------------------------------------------
VirtualTableModule::VirtualTableModule(Environment* env,
- BaseObjectWeakPtr<DatabaseSync> db,
+ BaseObjectWeakPtr<Database> db,
Local<Function> rows_fn,
std::string&& schema_sql,
int num_columns,
@@ -1520,11 +1519,11 @@ void VirtualTableModule::xDestroyModule(void* pAux) {
delete static_cast<VirtualTableModule*>(pAux);
}
-DatabaseSync::DatabaseSync(Environment* env,
- Local<Object> object,
- DatabaseOpenConfiguration&& open_config,
- bool open,
- bool allow_load_extension)
+Database::Database(Environment* env,
+ Local<Object> object,
+ DatabaseOpenConfiguration&& open_config,
+ bool open,
+ bool allow_load_extension)
: BaseObject(env, object), open_config_(std::move(open_config)) {
MakeWeak();
allow_load_extension_ = allow_load_extension;
@@ -1539,15 +1538,15 @@ DatabaseSync::DatabaseSync(Environment* env,
}
}
-void DatabaseSync::AddBackup(BackupJob* job) {
+void Database::AddBackup(BackupJob* job) {
backups_.insert(job);
}
-void DatabaseSync::RemoveBackup(BackupJob* job) {
+void Database::RemoveBackup(BackupJob* job) {
backups_.erase(job);
}
-std::vector<BaseObjectPtr<Session>> DatabaseSync::PinSessions() const {
+std::vector<BaseObjectPtr<Session>> Database::PinSessions() const {
std::vector<BaseObjectPtr<Session>> pinned;
pinned.reserve(sessions_.size());
for (Session* session : sessions_) {
@@ -1556,7 +1555,7 @@ std::vector<BaseObjectPtr<Session>> DatabaseSync::PinSessions() const {
return pinned;
}
-void DatabaseSync::DeleteSessions() {
+void Database::DeleteSessions() {
// all attached sessions need to be deleted before the database is closed
// https://www.sqlite.org/session/sqlite3session_create.html
while (!sessions_.empty()) {
@@ -1564,8 +1563,8 @@ void DatabaseSync::DeleteSessions() {
}
}
-DatabaseSync::~DatabaseSync() {
- // See the note in ~StatementSync: closing the connection here must not reach
+Database::~Database() {
+ // See the note in ~Statement: closing the connection here must not reach
// back into JavaScript.
DestructorScope destructor_scope(this);
@@ -1582,7 +1581,7 @@ DatabaseSync::~DatabaseSync() {
}
}
-void DatabaseSync::MemoryInfo(MemoryTracker* tracker) const {
+void Database::MemoryInfo(MemoryTracker* tracker) const {
tracker->TrackFieldWithSize("user_defined_functions",
user_defined_functions_.size() * sizeof(void*));
// TODO(tniessen): more accurately track the size of all fields
@@ -1590,7 +1589,7 @@ void DatabaseSync::MemoryInfo(MemoryTracker* tracker) const {
"open_config", sizeof(open_config_), "DatabaseOpenConfiguration");
}
-bool DatabaseSync::Open() {
+bool Database::Open() {
if (IsOpen()) {
THROW_ERR_INVALID_STATE(env(), "database is already open");
return false;
@@ -1682,7 +1681,7 @@ bool DatabaseSync::Open() {
return true;
}
-void DatabaseSync::EnableTracing() {
+void Database::EnableTracing() {
if (!IsOpen()) return;
if (!trace_channel_) {
trace_channel_ =
@@ -1692,12 +1691,12 @@ void DatabaseSync::EnableTracing() {
connection_.get(), SQLITE_TRACE_PROFILE, TraceCallback, this);
}
-void DatabaseSync::DisableTracing() {
+void Database::DisableTracing() {
if (!IsOpen()) return;
sqlite3_trace_v2(connection_.get(), 0, nullptr, nullptr);
}
-void DatabaseSync::FinalizeBackups() {
+void Database::FinalizeBackups() {
for (auto backup : backups_) {
backup->Cleanup();
}
@@ -1705,7 +1704,7 @@ void DatabaseSync::FinalizeBackups() {
backups_.clear();
}
-void DatabaseSync::FinalizeStatements() {
+void Database::FinalizeStatements() {
for (auto stmt : statements_) {
stmt->Finalize();
}
@@ -1713,28 +1712,28 @@ void DatabaseSync::FinalizeStatements() {
statements_.clear();
}
-void DatabaseSync::UntrackStatement(StatementSync* statement) {
+void Database::UntrackStatement(Statement* statement) {
statements_.erase(statement);
}
-inline bool DatabaseSync::IsOpen() {
+inline bool Database::IsOpen() {
return connection_ != nullptr;
}
-inline sqlite3* DatabaseSync::Connection() {
+inline sqlite3* Database::Connection() {
return connection_.get();
}
-void DatabaseSync::SetIgnoreNextSQLiteError(bool ignore) {
+void Database::SetIgnoreNextSQLiteError(bool ignore) {
ignore_next_sqlite_error_ = ignore;
}
-bool DatabaseSync::ShouldIgnoreSQLiteError() {
+bool Database::ShouldIgnoreSQLiteError() {
return ignore_next_sqlite_error_;
}
-void DatabaseSync::CreateTagStore(const FunctionCallbackInfo<Value>& args) {
- DatabaseSync* db = BaseObject::Unwrap<DatabaseSync>(args.This());
+void Database::CreateTagStore(const FunctionCallbackInfo<Value>& args) {
+ Database* db = BaseObject::Unwrap<Database>(args.This());
Environment* env = Environment::GetCurrent(args);
if (!db->IsOpen()) {
@@ -1761,7 +1760,7 @@ void DatabaseSync::CreateTagStore(const FunctionCallbackInfo<Value>& args) {
capacity = static_cast<int>(val);
}
BaseObjectPtr<SQLTagStore> session =
- SQLTagStore::Create(env, BaseObjectWeakPtr<DatabaseSync>(db), capacity);
+ SQLTagStore::Create(env, BaseObjectWeakPtr<Database>(db), capacity);
if (!session) {
// Handle error if creation failed
THROW_ERR_SQLITE_ERROR(env->isolate(), "Failed to create SQLTagStore");
@@ -1821,7 +1820,7 @@ std::optional<std::string> ValidateDatabasePath(Environment* env,
return std::nullopt;
}
-void DatabaseSync::New(const FunctionCallbackInfo<Value>& args) {
+void Database::New(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
if (!args.IsConstructCall()) {
THROW_ERR_CONSTRUCT_CALL_REQUIRED(env);
@@ -2076,33 +2075,32 @@ void DatabaseSync::New(const FunctionCallbackInfo<Value>& args) {
}
}
- new DatabaseSync(
+ new Database(
env, args.This(), std::move(open_config), open, allow_load_extension);
}
-void DatabaseSync::Open(const FunctionCallbackInfo<Value>& args) {
- DatabaseSync* db;
+void Database::Open(const FunctionCallbackInfo<Value>& args) {
+ Database* db;
ASSIGN_OR_RETURN_UNWRAP(&db, args.This());
db->Open();
}
-void DatabaseSync::IsOpenGetter(const FunctionCallbackInfo<Value>& args) {
- DatabaseSync* db;
+void Database::IsOpenGetter(const FunctionCallbackInfo<Value>& args) {
+ Database* db;
ASSIGN_OR_RETURN_UNWRAP(&db, args.This());
args.GetReturnValue().Set(db->IsOpen());
}
-void DatabaseSync::IsTransactionGetter(
- const FunctionCallbackInfo<Value>& args) {
- DatabaseSync* db;
+void Database::IsTransactionGetter(const FunctionCallbackInfo<Value>& args) {
+ Database* db;
ASSIGN_OR_RETURN_UNWRAP(&db, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open");
args.GetReturnValue().Set(sqlite3_get_autocommit(db->connection_.get()) == 0);
}
-void DatabaseSync::LimitsGetter(const FunctionCallbackInfo<Value>& args) {
- DatabaseSync* db;
+void Database::LimitsGetter(const FunctionCallbackInfo<Value>& args) {
+ Database* db;
ASSIGN_OR_RETURN_UNWRAP(&db, args.This());
Environment* env = Environment::GetCurrent(args);
@@ -2110,8 +2108,8 @@ void DatabaseSync::LimitsGetter(const FunctionCallbackInfo<Value>& args) {
db->object()->GetInternalField(kLimitsObject).template As<Value>();
if (limits_val->IsUndefined()) {
- BaseObjectPtr<DatabaseSyncLimits> limits =
- DatabaseSyncLimits::Create(env, BaseObjectWeakPtr<DatabaseSync>(db));
+ BaseObjectPtr<DatabaseLimits> limits =
+ DatabaseLimits::Create(env, BaseObjectWeakPtr<Database>(db));
if (limits) {
db->object()->SetInternalField(kLimitsObject, limits->object());
args.GetReturnValue().Set(limits->object());
@@ -2121,8 +2119,8 @@ void DatabaseSync::LimitsGetter(const FunctionCallbackInfo<Value>& args) {
}
}
-void DatabaseSync::Close(const FunctionCallbackInfo<Value>& args) {
- DatabaseSync* db;
+void Database::Close(const FunctionCallbackInfo<Value>& args) {
+ Database* db;
ASSIGN_OR_RETURN_UNWRAP(&db, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open");
@@ -2137,7 +2135,7 @@ void DatabaseSync::Close(const FunctionCallbackInfo<Value>& args) {
db->user_defined_functions_.clear();
}
-void DatabaseSync::Dispose(const v8::FunctionCallbackInfo<v8::Value>& args) {
+void Database::Dispose(const v8::FunctionCallbackInfo<v8::Value>& args) {
v8::TryCatch try_catch(args.GetIsolate());
Close(args);
if (try_catch.HasCaught()) {
@@ -2145,8 +2143,8 @@ void DatabaseSync::Dispose(const v8::FunctionCallbackInfo<v8::Value>& args) {
}
}
-void DatabaseSync::Prepare(const FunctionCallbackInfo<Value>& args) {
- DatabaseSync* db;
+void Database::Prepare(const FunctionCallbackInfo<Value>& args) {
+ Database* db;
ASSIGN_OR_RETURN_UNWRAP(&db, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open");
@@ -2288,8 +2286,8 @@ void DatabaseSync::Prepare(const FunctionCallbackInfo<Value>& args) {
return;
}
- BaseObjectPtr<StatementSync> stmt = StatementSync::Create(
- env, BaseObjectPtr<DatabaseSync>(db), std::move(stmt_ptr));
+ BaseObjectPtr<Statement> stmt =
+ Statement::Create(env, BaseObjectPtr<Database>(db), std::move(stmt_ptr));
if (!stmt) {
return;
}
@@ -2311,8 +2309,8 @@ void DatabaseSync::Prepare(const FunctionCallbackInfo<Value>& args) {
args.GetReturnValue().Set(stmt->object());
}
-void DatabaseSync::Exec(const FunctionCallbackInfo<Value>& args) {
- DatabaseSync* db;
+void Database::Exec(const FunctionCallbackInfo<Value>& args) {
+ Database* db;
ASSIGN_OR_RETURN_UNWRAP(&db, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open");
@@ -2327,17 +2325,17 @@ void DatabaseSync::Exec(const FunctionCallbackInfo<Value>& args) {
// Keep the database alive during sqlite3_exec(), which may call
// user-defined SQLite functions that trigger JavaScript callbacks.
// If the JavaScript callback drops all references to the database,
- // the DatabaseSync could otherwise be garbage-collected while the
+ // the Database could otherwise be garbage-collected while the
// SQLite callback is still executing, causing a use-after-free.
- BaseObjectPtr<DatabaseSync> guard(db);
+ BaseObjectPtr<Database> guard(db);
Utf8Value sql(env->isolate(), args[0].As<String>());
int r = sqlite3_exec(db->connection_.get(), *sql, nullptr, nullptr, nullptr);
CHECK_ERROR_OR_THROW(env->isolate(), db, r, SQLITE_OK, void());
}
-void DatabaseSync::CustomFunction(const FunctionCallbackInfo<Value>& args) {
- DatabaseSync* db;
+void Database::CustomFunction(const FunctionCallbackInfo<Value>& args) {
+ Database* db;
ASSIGN_OR_RETURN_UNWRAP(&db, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open");
@@ -2470,7 +2468,7 @@ void DatabaseSync::CustomFunction(const FunctionCallbackInfo<Value>& args) {
THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open");
UserDefinedFunction* user_data = new UserDefinedFunction(
- env, fn, BaseObjectWeakPtr<DatabaseSync>(db), use_bigint_args);
+ env, fn, BaseObjectWeakPtr<Database>(db), use_bigint_args);
int text_rep = SQLITE_UTF8;
if (deterministic) {
@@ -2493,8 +2491,8 @@ void DatabaseSync::CustomFunction(const FunctionCallbackInfo<Value>& args) {
CHECK_ERROR_OR_THROW(env->isolate(), db, r, SQLITE_OK, void());
}
-void DatabaseSync::Location(const FunctionCallbackInfo<Value>& args) {
- DatabaseSync* db;
+void Database::Location(const FunctionCallbackInfo<Value>& args) {
+ Database* db;
ASSIGN_OR_RETURN_UNWRAP(&db, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open");
@@ -2523,8 +2521,8 @@ void DatabaseSync::Location(const FunctionCallbackInfo<Value>& args) {
}
}
-void DatabaseSync::Serialize(const FunctionCallbackInfo<Value>& args) {
- DatabaseSync* db;
+void Database::Serialize(const FunctionCallbackInfo<Value>& args) {
+ Database* db;
ASSIGN_OR_RETURN_UNWRAP(&db, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open");
@@ -2569,8 +2567,8 @@ void DatabaseSync::Serialize(const FunctionCallbackInfo<Value>& args) {
args.GetReturnValue().Set(Uint8Array::New(ab, 0, size));
}
-void DatabaseSync::Deserialize(const FunctionCallbackInfo<Value>& args) {
- DatabaseSync* db;
+void Database::Deserialize(const FunctionCallbackInfo<Value>& args) {
+ Database* db;
ASSIGN_OR_RETURN_UNWRAP(&db, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open");
@@ -2661,8 +2659,8 @@ void DatabaseSync::Deserialize(const FunctionCallbackInfo<Value>& args) {
}
}
-void DatabaseSync::AggregateFunction(const FunctionCallbackInfo<Value>& args) {
- DatabaseSync* db;
+void Database::AggregateFunction(const FunctionCallbackInfo<Value>& args) {
+ Database* db;
ASSIGN_OR_RETURN_UNWRAP(&db, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open");
@@ -2826,7 +2824,7 @@ void DatabaseSync::AggregateFunction(const FunctionCallbackInfo<Value>& args) {
argc,
text_rep,
new CustomAggregate(env,
- BaseObjectWeakPtr<DatabaseSync>(db),
+ BaseObjectWeakPtr<Database>(db),
use_bigint_args,
start_v,
stepFunction,
@@ -2840,8 +2838,8 @@ void DatabaseSync::AggregateFunction(const FunctionCallbackInfo<Value>& args) {
CHECK_ERROR_OR_THROW(env->isolate(), db, r, SQLITE_OK, void());
}
-void DatabaseSync::CreateModule(const FunctionCallbackInfo<Value>& args) {
- DatabaseSync* db;
+void Database::CreateModule(const FunctionCallbackInfo<Value>& args) {
+ Database* db;
ASSIGN_OR_RETURN_UNWRAP(&db, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open");
@@ -3053,7 +3051,7 @@ void DatabaseSync::CreateModule(const FunctionCallbackInfo<Value>& args) {
VirtualTableModule* vtab_mod =
new VirtualTableModule(env,
- BaseObjectWeakPtr<DatabaseSync>(db),
+ BaseObjectWeakPtr<Database>(db),
rows_fn,
std::move(schema_sql),
num_columns,
@@ -3069,8 +3067,8 @@ void DatabaseSync::CreateModule(const FunctionCallbackInfo<Value>& args) {
CHECK_ERROR_OR_THROW(env->isolate(), db, r, SQLITE_OK, void());
}
-void DatabaseSync::CreateSession(const FunctionCallbackInfo<Value>& args) {
- DatabaseSync* db;
+void Database::CreateSession(const FunctionCallbackInfo<Value>& args) {
+ Database* db;
ASSIGN_OR_RETURN_UNWRAP(&db, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open");
@@ -3148,7 +3146,7 @@ void DatabaseSync::CreateSession(const FunctionCallbackInfo<Value>& args) {
CHECK_ERROR_OR_THROW(env->isolate(), db, r, SQLITE_OK, void());
BaseObjectPtr<Session> session =
- Session::Create(env, BaseObjectPtr<DatabaseSync>(db), pSession);
+ Session::Create(env, BaseObjectPtr<Database>(db), pSession);
if (!session) {
return;
}
@@ -3164,7 +3162,7 @@ void Backup(const FunctionCallbackInfo<Value>& args) {
return;
}
- DatabaseSync* db;
+ Database* db;
ASSIGN_OR_RETURN_UNWRAP(&db, args[0].As<Object>());
THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open");
std::optional<std::string> dest_path =
@@ -3300,10 +3298,10 @@ static int xFilter(void* pCtx, const char* zTab) {
return ctx->filterCallback(zTab) ? 1 : 0;
}
-void DatabaseSync::ApplyChangeset(const FunctionCallbackInfo<Value>& args) {
+void Database::ApplyChangeset(const FunctionCallbackInfo<Value>& args) {
ConflictCallbackContext context;
- DatabaseSync* db;
+ Database* db;
ASSIGN_OR_RETURN_UNWRAP(&db, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open");
@@ -3412,7 +3410,7 @@ void DatabaseSync::ApplyChangeset(const FunctionCallbackInfo<Value>& args) {
// Keep the database alive in case a callback drops all references to it,
// which could otherwise let it be garbage-collected mid-callback.
- BaseObjectPtr<DatabaseSync> guard(db);
+ BaseObjectPtr<Database> guard(db);
ArrayBufferViewContents<uint8_t> buf(args[0]);
if (buf.length() > std::numeric_limits<int>::max()) {
@@ -3461,9 +3459,8 @@ void DatabaseSync::ApplyChangeset(const FunctionCallbackInfo<Value>& args) {
THROW_ERR_SQLITE_ERROR(env->isolate(), r);
}
-void DatabaseSync::EnableLoadExtension(
- const FunctionCallbackInfo<Value>& args) {
- DatabaseSync* db;
+void Database::EnableLoadExtension(const FunctionCallbackInfo<Value>& args) {
+ Database* db;
ASSIGN_OR_RETURN_UNWRAP(&db, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open");
@@ -3494,8 +3491,8 @@ void DatabaseSync::EnableLoadExtension(
CHECK_ERROR_OR_THROW(isolate, db, load_extension_ret, SQLITE_OK, void());
}
-void DatabaseSync::EnableDefensive(const FunctionCallbackInfo<Value>& args) {
- DatabaseSync* db;
+void Database::EnableDefensive(const FunctionCallbackInfo<Value>& args) {
+ Database* db;
ASSIGN_OR_RETURN_UNWRAP(&db, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open");
@@ -3517,8 +3514,8 @@ void DatabaseSync::EnableDefensive(const FunctionCallbackInfo<Value>& args) {
CHECK_ERROR_OR_THROW(isolate, db, defensive_ret, SQLITE_OK, void());
}
-void DatabaseSync::LoadExtension(const FunctionCallbackInfo<Value>& args) {
- DatabaseSync* db;
+void Database::LoadExtension(const FunctionCallbackInfo<Value>& args) {
+ Database* db;
ASSIGN_OR_RETURN_UNWRAP(&db, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(
@@ -3551,8 +3548,8 @@ void DatabaseSync::LoadExtension(const FunctionCallbackInfo<Value>& args) {
}
}
-void DatabaseSync::SetAuthorizer(const FunctionCallbackInfo<Value>& args) {
- DatabaseSync* db;
+void Database::SetAuthorizer(const FunctionCallbackInfo<Value>& args) {
+ Database* db;
ASSIGN_OR_RETURN_UNWRAP(&db, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open");
@@ -3578,20 +3575,20 @@ void DatabaseSync::SetAuthorizer(const FunctionCallbackInfo<Value>& args) {
db->object()->SetInternalField(kAuthorizerCallback, fn);
int r = sqlite3_set_authorizer(
- db->connection_.get(), DatabaseSync::AuthorizerCallback, db);
+ db->connection_.get(), Database::AuthorizerCallback, db);
if (r != SQLITE_OK) {
CHECK_ERROR_OR_THROW(isolate, db, r, SQLITE_OK, void());
}
}
-int DatabaseSync::AuthorizerCallback(void* user_data,
- int action_code,
- const char* param1,
- const char* param2,
- const char* param3,
- const char* param4) {
- DatabaseSync* db = static_cast<DatabaseSync*>(user_data);
+int Database::AuthorizerCallback(void* user_data,
+ int action_code,
+ const char* param1,
+ const char* param2,
+ const char* param3,
+ const char* param4) {
+ Database* db = static_cast<Database*>(user_data);
CallbackDepthGuard guard(db);
AuthorizerDepthGuard authorizer_guard(db);
Environment* env = db->env();
@@ -3661,15 +3658,15 @@ int DatabaseSync::AuthorizerCallback(void* user_data,
return int_result;
}
-int DatabaseSync::TraceCallback(unsigned int type,
- void* user_data,
- void* p,
- void* x) {
+int Database::TraceCallback(unsigned int type,
+ void* user_data,
+ void* p,
+ void* x) {
if (type != SQLITE_TRACE_PROFILE) {
return 0;
}
- DatabaseSync* db = static_cast<DatabaseSync*>(user_data);
+ Database* db = static_cast<Database*>(user_data);
Environment* env = db->env();
diagnostics_channel::Channel* ch = db->trace_channel_.get();
@@ -3725,10 +3722,10 @@ int DatabaseSync::TraceCallback(unsigned int type,
return 0;
}
-StatementSync::StatementSync(Environment* env,
- Local<Object> object,
- BaseObjectPtr<DatabaseSync> db,
- StatementPtr stmt)
+Statement::Statement(Environment* env,
+ Local<Object> object,
+ BaseObjectPtr<Database> db,
+ StatementPtr stmt)
: BaseObject(env, object), db_(std::move(db)), statement_(std::move(stmt)) {
MakeWeak();
use_big_ints_ = db_->use_big_ints();
@@ -3739,7 +3736,7 @@ StatementSync::StatementSync(Environment* env,
bare_named_params_ = std::nullopt;
}
-StatementSync::~StatementSync() {
+Statement::~Statement() {
// Runs from a garbage collection callback, so finalizing the statement here
// must not reach back into JavaScript. The scope has to live here rather than
// in Close(), which is shared with the JS-facing close() and dispose().
@@ -3747,7 +3744,7 @@ StatementSync::~StatementSync() {
Close();
}
-void StatementSync::Close() {
+void Statement::Close() {
db_->UntrackStatement(this);
if (!IsFinalized()) {
@@ -3755,23 +3752,23 @@ void StatementSync::Close() {
}
}
-void StatementSync::Finalize() {
+void Statement::Finalize() {
TraceEventSuppressionGuard trace_guard(db_.get());
statement_.reset();
InvalidateColumnNameCache();
}
-void StatementSync::InvalidateColumnNameCache() {
+void Statement::InvalidateColumnNameCache() {
cached_column_names_.clear();
cached_column_names_reprepare_count_ = -1;
}
-inline bool StatementSync::IsFinalized() {
+inline bool Statement::IsFinalized() {
return statement_ == nullptr;
}
-void StatementSync::Close(const FunctionCallbackInfo<Value>& args) {
- StatementSync* stmt;
+void Statement::Close(const FunctionCallbackInfo<Value>& args) {
+ Statement* stmt;
ASSIGN_OR_RETURN_UNWRAP(&stmt, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(
@@ -3781,8 +3778,8 @@ void StatementSync::Close(const FunctionCallbackInfo<Value>& args) {
stmt->Close();
}
-void StatementSync::Dispose(const FunctionCallbackInfo<Value>& args) {
- StatementSync* stmt;
+void Statement::Dispose(const FunctionCallbackInfo<Value>& args) {
+ Statement* stmt;
ASSIGN_OR_RETURN_UNWRAP(&stmt, args.This());
Environment* env = Environment::GetCurrent(args);
// Disposal is idempotent, so an already-finalized statement is a no-op even
@@ -3795,12 +3792,12 @@ void StatementSync::Dispose(const FunctionCallbackInfo<Value>& args) {
stmt->Close();
}
-inline int StatementSync::ResetStatement() {
+inline int Statement::ResetStatement() {
reset_generation_++;
return sqlite3_reset(statement_.get());
}
-bool StatementSync::BindParams(const FunctionCallbackInfo<Value>& args) {
+bool Statement::BindParams(const FunctionCallbackInfo<Value>& args) {
int r = sqlite3_clear_bindings(statement_.get());
CHECK_ERROR_OR_THROW(env()->isolate(), db_.get(), r, SQLITE_OK, false);
@@ -3904,7 +3901,7 @@ bool StatementSync::BindParams(const FunctionCallbackInfo<Value>& args) {
return true;
}
-bool StatementSync::BindValue(const Local<Value>& value, const int index) {
+bool Statement::BindValue(const Local<Value>& value, const int index) {
// SQLite only supports a subset of JavaScript types. Some JS types such as
// functions don't make sense to support. Other JS types such as
// Dates could be supported by converting them to numbers. However, there
@@ -3967,12 +3964,12 @@ bool StatementSync::BindValue(const Local<Value>& value, const int index) {
return true;
}
-MaybeLocal<Value> StatementSync::ColumnToValue(const int column) {
+MaybeLocal<Value> Statement::ColumnToValue(const int column) {
return StatementExecutionHelper::ColumnToValue(
env(), statement_.get(), column, use_big_ints_);
}
-MaybeLocal<Name> StatementSync::ColumnNameToName(const int column) {
+MaybeLocal<Name> Statement::ColumnNameToName(const int column) {
const char* col_name = sqlite3_column_name(statement_.get(), column);
if (col_name == nullptr) {
THROW_ERR_INVALID_STATE(env(), "Cannot get name of column %d", column);
@@ -3986,7 +3983,7 @@ MaybeLocal<Name> StatementSync::ColumnNameToName(const int column) {
// Populates `keys` with cached column names, rebuilding the cache if the
// statement was re-prepared.
-bool StatementSync::GetCachedColumnNames(LocalVector<Name>* keys) {
+bool Statement::GetCachedColumnNames(LocalVector<Name>* keys) {
Isolate* isolate = env()->isolate();
const int reprepare_count =
@@ -4027,7 +4024,7 @@ MaybeLocal<Value> StatementExecutionHelper::ColumnToValue(Environment* env,
return js_val;
}
-void StatementSync::MemoryInfo(MemoryTracker* tracker) const {}
+void Statement::MemoryInfo(MemoryTracker* tracker) const {}
Maybe<void> ExtractRowValues(Environment* env,
sqlite3_stmt* stmt,
@@ -4048,8 +4045,8 @@ Maybe<void> ExtractRowValues(Environment* env,
}
MaybeLocal<Value> StatementExecutionHelper::All(Environment* env,
- StatementSync* statement) {
- DatabaseSync* db = statement->db_.get();
+ Statement* statement) {
+ Database* db = statement->db_.get();
sqlite3_stmt* stmt = statement->statement_.get();
const bool return_arrays = statement->return_arrays_;
const bool use_big_ints = statement->use_big_ints_;
@@ -4096,8 +4093,8 @@ MaybeLocal<Value> StatementExecutionHelper::All(Environment* env,
}
MaybeLocal<Object> StatementExecutionHelper::Run(Environment* env,
- StatementSync* statement) {
- DatabaseSync* db = statement->db_.get();
+ Statement* statement) {
+ Database* db = statement->db_.get();
sqlite3_stmt* stmt = statement->statement_.get();
const bool use_big_ints = statement->use_big_ints_;
Isolate* isolate = env->isolate();
@@ -4149,27 +4146,26 @@ MaybeLocal<Object> StatementExecutionHelper::Run(Environment* env,
return scope.Escape(result);
}
-BaseObjectPtr<StatementSyncIterator> StatementExecutionHelper::Iterate(
- Environment* env, BaseObjectPtr<StatementSync> stmt) {
+BaseObjectPtr<StatementIterator> StatementExecutionHelper::Iterate(
+ Environment* env, BaseObjectPtr<Statement> stmt) {
Local<Context> context = env->context();
Local<Object> global = context->Global();
Local<Value> js_iterator;
Local<Value> js_iterator_prototype;
if (!global->Get(context, env->iterator_string()).ToLocal(&js_iterator)) {
- return BaseObjectPtr<StatementSyncIterator>();
+ return BaseObjectPtr<StatementIterator>();
}
if (!js_iterator.As<Object>()
->Get(context, env->prototype_string())
.ToLocal(&js_iterator_prototype)) {
- return BaseObjectPtr<StatementSyncIterator>();
+ return BaseObjectPtr<StatementIterator>();
}
- BaseObjectPtr<StatementSyncIterator> iter =
- StatementSyncIterator::Create(env, stmt);
+ BaseObjectPtr<StatementIterator> iter = StatementIterator::Create(env, stmt);
if (!iter) {
// Error in iterator creation, likely already threw in Create
- return BaseObjectPtr<StatementSyncIterator>();
+ return BaseObjectPtr<StatementIterator>();
}
if (iter->object()
@@ -4177,15 +4173,15 @@ BaseObjectPtr<StatementSyncIterator> StatementExecutionHelper::Iterate(
.As<Object>()
->SetPrototypeV2(context, js_iterator_prototype)
.IsNothing()) {
- return BaseObjectPtr<StatementSyncIterator>();
+ return BaseObjectPtr<StatementIterator>();
}
return iter;
}
MaybeLocal<Value> StatementExecutionHelper::Get(Environment* env,
- StatementSync* statement) {
- DatabaseSync* db = statement->db_.get();
+ Statement* statement) {
+ Database* db = statement->db_.get();
sqlite3_stmt* stmt = statement->statement_.get();
const bool return_arrays = statement->return_arrays_;
const bool use_big_ints = statement->use_big_ints_;
@@ -4241,8 +4237,8 @@ MaybeLocal<Value> StatementExecutionHelper::Get(Environment* env,
return scope.Escape(result);
}
-void StatementSync::All(const FunctionCallbackInfo<Value>& args) {
- StatementSync* stmt;
+void Statement::All(const FunctionCallbackInfo<Value>& args) {
+ Statement* stmt;
ASSIGN_OR_RETURN_UNWRAP(&stmt, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(
@@ -4270,8 +4266,8 @@ void StatementSync::All(const FunctionCallbackInfo<Value>& args) {
}
}
-void StatementSync::Iterate(const FunctionCallbackInfo<Value>& args) {
- StatementSync* stmt;
+void Statement::Iterate(const FunctionCallbackInfo<Value>& args) {
+ Statement* stmt;
ASSIGN_OR_RETURN_UNWRAP(&stmt, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(
@@ -4286,8 +4282,8 @@ void StatementSync::Iterate(const FunctionCallbackInfo<Value>& args) {
return;
}
- BaseObjectPtr<StatementSyncIterator> iter = StatementExecutionHelper::Iterate(
- env, BaseObjectPtr<StatementSync>(stmt));
+ BaseObjectPtr<StatementIterator> iter =
+ StatementExecutionHelper::Iterate(env, BaseObjectPtr<Statement>(stmt));
if (!iter) {
return;
@@ -4296,8 +4292,8 @@ void StatementSync::Iterate(const FunctionCallbackInfo<Value>& args) {
args.GetReturnValue().Set(iter->object());
}
-void StatementSync::Get(const FunctionCallbackInfo<Value>& args) {
- StatementSync* stmt;
+void Statement::Get(const FunctionCallbackInfo<Value>& args) {
+ Statement* stmt;
ASSIGN_OR_RETURN_UNWRAP(&stmt, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(
@@ -4318,8 +4314,8 @@ void StatementSync::Get(const FunctionCallbackInfo<Value>& args) {
}
}
-void StatementSync::Run(const FunctionCallbackInfo<Value>& args) {
- StatementSync* stmt;
+void Statement::Run(const FunctionCallbackInfo<Value>& args) {
+ Statement* stmt;
ASSIGN_OR_RETURN_UNWRAP(&stmt, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(
@@ -4340,8 +4336,8 @@ void StatementSync::Run(const FunctionCallbackInfo<Value>& args) {
}
}
-void StatementSync::Columns(const FunctionCallbackInfo<Value>& args) {
- StatementSync* stmt;
+void Statement::Columns(const FunctionCallbackInfo<Value>& args) {
+ Statement* stmt;
ASSIGN_OR_RETURN_UNWRAP(&stmt, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(
@@ -4383,8 +4379,8 @@ void StatementSync::Columns(const FunctionCallbackInfo<Value>& args) {
args.GetReturnValue().Set(Array::New(isolate, cols.data(), cols.size()));
}
-void StatementSync::SourceSQLGetter(const FunctionCallbackInfo<Value>& args) {
- StatementSync* stmt;
+void Statement::SourceSQLGetter(const FunctionCallbackInfo<Value>& args) {
+ Statement* stmt;
ASSIGN_OR_RETURN_UNWRAP(&stmt, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(
@@ -4397,8 +4393,8 @@ void StatementSync::SourceSQLGetter(const FunctionCallbackInfo<Value>& args) {
args.GetReturnValue().Set(sql);
}
-void StatementSync::ExpandedSQLGetter(const FunctionCallbackInfo<Value>& args) {
- StatementSync* stmt;
+void Statement::ExpandedSQLGetter(const FunctionCallbackInfo<Value>& args) {
+ Statement* stmt;
ASSIGN_OR_RETURN_UNWRAP(&stmt, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(
@@ -4419,8 +4415,8 @@ void StatementSync::ExpandedSQLGetter(const FunctionCallbackInfo<Value>& args) {
args.GetReturnValue().Set(result);
}
-void StatementSync::Stat(const FunctionCallbackInfo<Value>& args) {
- StatementSync* stmt;
+void Statement::Stat(const FunctionCallbackInfo<Value>& args) {
+ Statement* stmt;
ASSIGN_OR_RETURN_UNWRAP(&stmt, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(
@@ -4448,8 +4444,8 @@ void StatementSync::Stat(const FunctionCallbackInfo<Value>& args) {
args.GetReturnValue().Set(Integer::New(isolate, value));
}
-void StatementSync::ResetStats(const FunctionCallbackInfo<Value>& args) {
- StatementSync* stmt;
+void Statement::ResetStats(const FunctionCallbackInfo<Value>& args) {
+ Statement* stmt;
ASSIGN_OR_RETURN_UNWRAP(&stmt, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(
@@ -4473,9 +4469,9 @@ void StatementSync::ResetStats(const FunctionCallbackInfo<Value>& args) {
stmt->InvalidateColumnNameCache();
}
-void StatementSync::SetAllowBareNamedParameters(
+void Statement::SetAllowBareNamedParameters(
const FunctionCallbackInfo<Value>& args) {
- StatementSync* stmt;
+ Statement* stmt;
ASSIGN_OR_RETURN_UNWRAP(&stmt, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(
@@ -4491,9 +4487,9 @@ void StatementSync::SetAllowBareNamedParameters(
stmt->allow_bare_named_params_ = args[0]->IsTrue();
}
-void StatementSync::SetAllowUnknownNamedParameters(
+void Statement::SetAllowUnknownNamedParameters(
const FunctionCallbackInfo<Value>& args) {
- StatementSync* stmt;
+ Statement* stmt;
ASSIGN_OR_RETURN_UNWRAP(&stmt, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(
@@ -4508,8 +4504,8 @@ void StatementSync::SetAllowUnknownNamedParameters(
stmt->allow_unknown_named_params_ = args[0]->IsTrue();
}
-void StatementSync::SetReadBigInts(const FunctionCallbackInfo<Value>& args) {
- StatementSync* stmt;
+void Statement::SetReadBigInts(const FunctionCallbackInfo<Value>& args) {
+ Statement* stmt;
ASSIGN_OR_RETURN_UNWRAP(&stmt, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(
@@ -4524,8 +4520,8 @@ void StatementSync::SetReadBigInts(const FunctionCallbackInfo<Value>& args) {
stmt->use_big_ints_ = args[0]->IsTrue();
}
-void StatementSync::SetReturnArrays(const FunctionCallbackInfo<Value>& args) {
- StatementSync* stmt;
+void Statement::SetReturnArrays(const FunctionCallbackInfo<Value>& args) {
+ Statement* stmt;
ASSIGN_OR_RETURN_UNWRAP(&stmt, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(
@@ -4546,7 +4542,7 @@ void IllegalConstructor(const FunctionCallbackInfo<Value>& args) {
SQLTagStore::SQLTagStore(Environment* env,
Local<Object> object,
- BaseObjectWeakPtr<DatabaseSync> database,
+ BaseObjectWeakPtr<Database> database,
int capacity)
: BaseObject(env, object),
database_(std::move(database)),
@@ -4596,7 +4592,7 @@ Local<FunctionTemplate> SQLTagStore::GetConstructorTemplate(Environment* env) {
}
BaseObjectPtr<SQLTagStore> SQLTagStore::Create(
- Environment* env, BaseObjectWeakPtr<DatabaseSync> database, int capacity) {
+ Environment* env, BaseObjectWeakPtr<Database> database, int capacity) {
Local<Object> obj;
if (!GetConstructorTemplate(env)
->InstanceTemplate()
@@ -4627,7 +4623,7 @@ void SQLTagStore::SizeGetter(const FunctionCallbackInfo<Value>& args) {
bool SQLTagStore::ResetAndBindStatement(
Environment* env,
- StatementSync* stmt,
+ Statement* stmt,
const FunctionCallbackInfo<Value>& args) {
Isolate* isolate = env->isolate();
int r = stmt->ResetStatement();
@@ -4663,7 +4659,7 @@ void SQLTagStore::Run(const FunctionCallbackInfo<Value>& args) {
env, !session->database_->IsOpen(), "database is not open");
THROW_AND_RETURN_IF_IN_AUTHORIZER(env, session->database_.get());
- BaseObjectPtr<StatementSync> stmt = PrepareStatement(args);
+ BaseObjectPtr<Statement> stmt = PrepareStatement(args);
if (!stmt) {
return;
@@ -4690,7 +4686,7 @@ void SQLTagStore::Iterate(const FunctionCallbackInfo<Value>& args) {
env, !session->database_->IsOpen(), "database is not open");
THROW_AND_RETURN_IF_IN_AUTHORIZER(env, session->database_.get());
- BaseObjectPtr<StatementSync> stmt = PrepareStatement(args);
+ BaseObjectPtr<Statement> stmt = PrepareStatement(args);
if (!stmt) {
return;
@@ -4702,8 +4698,8 @@ void SQLTagStore::Iterate(const FunctionCallbackInfo<Value>& args) {
return;
}
- BaseObjectPtr<StatementSyncIterator> iter = StatementExecutionHelper::Iterate(
- env, BaseObjectPtr<StatementSync>(stmt));
+ BaseObjectPtr<StatementIterator> iter =
+ StatementExecutionHelper::Iterate(env, BaseObjectPtr<Statement>(stmt));
if (!iter) {
return;
@@ -4721,7 +4717,7 @@ void SQLTagStore::Get(const FunctionCallbackInfo<Value>& args) {
env, !session->database_->IsOpen(), "database is not open");
THROW_AND_RETURN_IF_IN_AUTHORIZER(env, session->database_.get());
- BaseObjectPtr<StatementSync> stmt = PrepareStatement(args);
+ BaseObjectPtr<Statement> stmt = PrepareStatement(args);
if (!stmt) {
return;
@@ -4748,7 +4744,7 @@ void SQLTagStore::All(const FunctionCallbackInfo<Value>& args) {
env, !session->database_->IsOpen(), "database is not open");
THROW_AND_RETURN_IF_IN_AUTHORIZER(env, session->database_.get());
- BaseObjectPtr<StatementSync> stmt = PrepareStatement(args);
+ BaseObjectPtr<Statement> stmt = PrepareStatement(args);
if (!stmt) {
return;
@@ -4783,14 +4779,14 @@ void SQLTagStore::Clear(const FunctionCallbackInfo<Value>& args) {
store->sql_tags_.Clear();
}
-BaseObjectPtr<StatementSync> SQLTagStore::PrepareStatement(
+BaseObjectPtr<Statement> SQLTagStore::PrepareStatement(
const FunctionCallbackInfo<Value>& args) {
SQLTagStore* session = BaseObject::FromJSObject<SQLTagStore>(args.This());
if (!session) {
THROW_ERR_INVALID_ARG_TYPE(
Environment::GetCurrent(args)->isolate(),
"This method can only be called on SQLTagStore instances.");
- return BaseObjectPtr<StatementSync>();
+ return BaseObjectPtr<Statement>();
}
Environment* env = Environment::GetCurrent(args);
Isolate* isolate = env->isolate();
@@ -4800,7 +4796,7 @@ BaseObjectPtr<StatementSync> SQLTagStore::PrepareStatement(
THROW_ERR_INVALID_ARG_TYPE(
isolate,
"First argument must be an array of strings (template literal).");
- return BaseObjectPtr<StatementSync>();
+ return BaseObjectPtr<Statement>();
}
Local<Array> strings = args[0].As<Array>();
@@ -4813,7 +4809,7 @@ BaseObjectPtr<StatementSync> SQLTagStore::PrepareStatement(
if (!strings->Get(context, i).ToLocal(&str_val) || !str_val->IsString()) {
THROW_ERR_INVALID_ARG_TYPE(isolate,
"Template literal parts must be strings.");
- return BaseObjectPtr<StatementSync>();
+ return BaseObjectPtr<Statement>();
}
Utf8Value part(isolate, str_val);
sql += part.ToStringView();
@@ -4822,7 +4818,7 @@ BaseObjectPtr<StatementSync> SQLTagStore::PrepareStatement(
}
}
- BaseObjectPtr<StatementSync> stmt = nullptr;
+ BaseObjectPtr<Statement> stmt = nullptr;
if (session->sql_tags_.Exists(sql)) {
stmt = session->sql_tags_.Get(sql);
if (stmt->IsFinalized()) {
@@ -4843,24 +4839,22 @@ BaseObjectPtr<StatementSync> SQLTagStore::PrepareStatement(
if (r != SQLITE_OK) {
THROW_ERR_SQLITE_ERROR(isolate, session->database_.get());
- return BaseObjectPtr<StatementSync>();
+ return BaseObjectPtr<Statement>();
}
- // As in DatabaseSync::Prepare(), reject input that holds no SQL rather
+ // As in Database::Prepare(), reject input that holds no SQL rather
// than caching a statement that can never be bound or stepped.
if (s == nullptr) {
THROW_ERR_INVALID_ARG_VALUE(env, "The SQL query contains no statements.");
- return BaseObjectPtr<StatementSync>();
+ return BaseObjectPtr<Statement>();
}
- BaseObjectPtr<StatementSync> stmt_obj =
- StatementSync::Create(env,
- BaseObjectPtr<DatabaseSync>(session->database_),
- std::move(stmt_ptr));
+ BaseObjectPtr<Statement> stmt_obj = Statement::Create(
+ env, BaseObjectPtr<Database>(session->database_), std::move(stmt_ptr));
if (!stmt_obj) {
- THROW_ERR_SQLITE_ERROR(isolate, "Failed to create StatementSync");
- return BaseObjectPtr<StatementSync>();
+ THROW_ERR_SQLITE_ERROR(isolate, "Failed to create Statement");
+ return BaseObjectPtr<Statement>();
}
session->database_->statements_.insert(stmt_obj.get());
@@ -4882,53 +4876,51 @@ void SQLTagStore::MemoryInfo(MemoryTracker* tracker) const {
tracker->TrackFieldWithSize("sql_tags_cache", cache_content_size);
}
-Local<FunctionTemplate> StatementSync::GetConstructorTemplate(
- Environment* env) {
+Local<FunctionTemplate> Statement::GetConstructorTemplate(Environment* env) {
Local<FunctionTemplate> tmpl =
env->sqlite_statement_sync_constructor_template();
if (tmpl.IsEmpty()) {
Isolate* isolate = env->isolate();
tmpl = NewFunctionTemplate(isolate, IllegalConstructor);
- tmpl->SetClassName(FIXED_ONE_BYTE_STRING(isolate, "StatementSync"));
+ tmpl->SetClassName(FIXED_ONE_BYTE_STRING(isolate, "Statement"));
tmpl->InstanceTemplate()->SetInternalFieldCount(
- StatementSync::kInternalFieldCount);
- SetProtoMethod(isolate, tmpl, "iterate", StatementSync::Iterate);
- SetProtoMethod(isolate, tmpl, "all", StatementSync::All);
- SetProtoMethod(isolate, tmpl, "get", StatementSync::Get);
- SetProtoMethod(isolate, tmpl, "run", StatementSync::Run);
- SetProtoMethodNoSideEffect(
- isolate, tmpl, "columns", StatementSync::Columns);
+ Statement::kInternalFieldCount);
+ SetProtoMethod(isolate, tmpl, "iterate", Statement::Iterate);
+ SetProtoMethod(isolate, tmpl, "all", Statement::All);
+ SetProtoMethod(isolate, tmpl, "get", Statement::Get);
+ SetProtoMethod(isolate, tmpl, "run", Statement::Run);
+ SetProtoMethodNoSideEffect(isolate, tmpl, "columns", Statement::Columns);
SetSideEffectFreeGetter(isolate,
tmpl,
FIXED_ONE_BYTE_STRING(isolate, "sourceSQL"),
- StatementSync::SourceSQLGetter);
+ Statement::SourceSQLGetter);
SetSideEffectFreeGetter(isolate,
tmpl,
FIXED_ONE_BYTE_STRING(isolate, "expandedSQL"),
- StatementSync::ExpandedSQLGetter);
- SetProtoMethodNoSideEffect(isolate, tmpl, "stat", StatementSync::Stat);
- SetProtoMethod(isolate, tmpl, "resetStats", StatementSync::ResetStats);
+ Statement::ExpandedSQLGetter);
+ SetProtoMethodNoSideEffect(isolate, tmpl, "stat", Statement::Stat);
+ SetProtoMethod(isolate, tmpl, "resetStats", Statement::ResetStats);
SetProtoMethod(isolate,
tmpl,
"setAllowBareNamedParameters",
- StatementSync::SetAllowBareNamedParameters);
+ Statement::SetAllowBareNamedParameters);
SetProtoMethod(isolate,
tmpl,
"setAllowUnknownNamedParameters",
- StatementSync::SetAllowUnknownNamedParameters);
+ Statement::SetAllowUnknownNamedParameters);
+ SetProtoMethod(isolate, tmpl, "setReadBigInts", Statement::SetReadBigInts);
SetProtoMethod(
- isolate, tmpl, "setReadBigInts", StatementSync::SetReadBigInts);
- SetProtoMethod(
- isolate, tmpl, "setReturnArrays", StatementSync::SetReturnArrays);
- SetProtoMethod(isolate, tmpl, "close", StatementSync::Close);
- SetProtoDispose(isolate, tmpl, StatementSync::Dispose);
+ isolate, tmpl, "setReturnArrays", Statement::SetReturnArrays);
+ SetProtoMethod(isolate, tmpl, "close", Statement::Close);
+ SetProtoDispose(isolate, tmpl, Statement::Dispose);
env->set_sqlite_statement_sync_constructor_template(tmpl);
}
return tmpl;
}
-BaseObjectPtr<StatementSync> StatementSync::Create(
- Environment* env, BaseObjectPtr<DatabaseSync> db, StatementPtr stmt) {
+BaseObjectPtr<Statement> Statement::Create(Environment* env,
+ BaseObjectPtr<Database> db,
+ StatementPtr stmt) {
Local<Object> obj;
if (!GetConstructorTemplate(env)
->InstanceTemplate()
@@ -4937,54 +4929,53 @@ BaseObjectPtr<StatementSync> StatementSync::Create(
return nullptr;
}
- return MakeBaseObject<StatementSync>(
- env, obj, std::move(db), std::move(stmt));
+ return MakeBaseObject<Statement>(env, obj, std::move(db), std::move(stmt));
}
-StatementSyncIterator::StatementSyncIterator(Environment* env,
- Local<Object> object,
- BaseObjectPtr<StatementSync> stmt)
+StatementIterator::StatementIterator(Environment* env,
+ Local<Object> object,
+ BaseObjectPtr<Statement> stmt)
: BaseObject(env, object), stmt_(std::move(stmt)) {
MakeWeak();
done_ = false;
statement_reset_generation_ = stmt_->reset_generation_;
}
-StatementSyncIterator::~StatementSyncIterator() {}
-void StatementSyncIterator::MemoryInfo(MemoryTracker* tracker) const {}
+StatementIterator::~StatementIterator() {}
+void StatementIterator::MemoryInfo(MemoryTracker* tracker) const {}
-Local<FunctionTemplate> StatementSyncIterator::GetConstructorTemplate(
+Local<FunctionTemplate> StatementIterator::GetConstructorTemplate(
Environment* env) {
Local<FunctionTemplate> tmpl =
env->sqlite_statement_sync_iterator_constructor_template();
if (tmpl.IsEmpty()) {
Isolate* isolate = env->isolate();
tmpl = NewFunctionTemplate(isolate, IllegalConstructor);
- tmpl->SetClassName(FIXED_ONE_BYTE_STRING(isolate, "StatementSyncIterator"));
+ tmpl->SetClassName(FIXED_ONE_BYTE_STRING(isolate, "StatementIterator"));
tmpl->InstanceTemplate()->SetInternalFieldCount(
- StatementSyncIterator::kInternalFieldCount);
- SetProtoMethod(isolate, tmpl, "next", StatementSyncIterator::Next);
- SetProtoMethod(isolate, tmpl, "return", StatementSyncIterator::Return);
+ StatementIterator::kInternalFieldCount);
+ SetProtoMethod(isolate, tmpl, "next", StatementIterator::Next);
+ SetProtoMethod(isolate, tmpl, "return", StatementIterator::Return);
env->set_sqlite_statement_sync_iterator_constructor_template(tmpl);
}
return tmpl;
}
-BaseObjectPtr<StatementSyncIterator> StatementSyncIterator::Create(
- Environment* env, BaseObjectPtr<StatementSync> stmt) {
+BaseObjectPtr<StatementIterator> StatementIterator::Create(
+ Environment* env, BaseObjectPtr<Statement> stmt) {
Local<Object> obj;
if (!GetConstructorTemplate(env)
->InstanceTemplate()
->NewInstance(env->context())
.ToLocal(&obj)) {
- return BaseObjectPtr<StatementSyncIterator>();
+ return BaseObjectPtr<StatementIterator>();
}
- return MakeBaseObject<StatementSyncIterator>(env, obj, std::move(stmt));
+ return MakeBaseObject<StatementIterator>(env, obj, std::move(stmt));
}
-void StatementSyncIterator::Next(const FunctionCallbackInfo<Value>& args) {
- StatementSyncIterator* iter;
+void StatementIterator::Next(const FunctionCallbackInfo<Value>& args) {
+ StatementIterator* iter;
ASSIGN_OR_RETURN_UNWRAP(&iter, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(
@@ -5072,8 +5063,8 @@ void StatementSyncIterator::Next(const FunctionCallbackInfo<Value>& args) {
}
}
-void StatementSyncIterator::Return(const FunctionCallbackInfo<Value>& args) {
- StatementSyncIterator* iter;
+void StatementIterator::Return(const FunctionCallbackInfo<Value>& args) {
+ StatementIterator* iter;
ASSIGN_OR_RETURN_UNWRAP(&iter, args.This());
Environment* env = Environment::GetCurrent(args);
THROW_AND_RETURN_ON_BAD_STATE(
@@ -5106,7 +5097,7 @@ void StatementSyncIterator::Return(const FunctionCallbackInfo<Value>& args) {
Session::Session(Environment* env,
Local<Object> object,
- BaseObjectPtr<DatabaseSync> database,
+ BaseObjectPtr<Database> database,
sqlite3_session* session)
: BaseObject(env, object),
session_(std::unique_ptr<sqlite3_session, SessionDeleter>(session)),
@@ -5120,7 +5111,7 @@ Session::~Session() {
}
BaseObjectPtr<Session> Session::Create(Environment* env,
- BaseObjectPtr<DatabaseSync> database,
+ BaseObjectPtr<Database> database,
sqlite3_session* session) {
Local<Object> obj;
if (!GetConstructorTemplate(env)
@@ -5304,7 +5295,7 @@ static void Initialize(Local<Object> target,
diag_binding->SetChannelStatusCallback(idx, [bd_ptr](bool is_active) {
BindingData* bd = bd_ptr.get();
if (bd == nullptr) return;
- for (DatabaseSync* db : bd->open_databases) {
+ for (Database* db : bd->open_databases) {
if (is_active)
db->EnableTracing();
else
@@ -5312,55 +5303,45 @@ static void Initialize(Local<Object> target,
}
});
}
- Local<FunctionTemplate> db_tmpl =
- NewFunctionTemplate(isolate, DatabaseSync::New);
+ Local<FunctionTemplate> db_tmpl = NewFunctionTemplate(isolate, Database::New);
db_tmpl->InstanceTemplate()->SetInternalFieldCount(
- DatabaseSync::kInternalFieldCount);
+ Database::kInternalFieldCount);
Local<Object> constants = Object::New(isolate);
DefineConstants(constants);
- SetProtoMethod(isolate, db_tmpl, "open", DatabaseSync::Open);
- SetProtoMethod(isolate, db_tmpl, "close", DatabaseSync::Close);
- SetProtoDispose(isolate, db_tmpl, DatabaseSync::Dispose);
- SetProtoMethod(isolate, db_tmpl, "prepare", DatabaseSync::Prepare);
- SetProtoMethod(isolate, db_tmpl, "exec", DatabaseSync::Exec);
- SetProtoMethod(isolate, db_tmpl, "function", DatabaseSync::CustomFunction);
- SetProtoMethod(
- isolate, db_tmpl, "createTagStore", DatabaseSync::CreateTagStore);
- SetProtoMethodNoSideEffect(
- isolate, db_tmpl, "location", DatabaseSync::Location);
- SetProtoMethod(
- isolate, db_tmpl, "aggregate", DatabaseSync::AggregateFunction);
- SetProtoMethod(
- isolate, db_tmpl, "createSession", DatabaseSync::CreateSession);
- SetProtoMethod(
- isolate, db_tmpl, "applyChangeset", DatabaseSync::ApplyChangeset);
- SetProtoMethod(isolate,
- db_tmpl,
- "enableLoadExtension",
- DatabaseSync::EnableLoadExtension);
- SetProtoMethod(
- isolate, db_tmpl, "enableDefensive", DatabaseSync::EnableDefensive);
+ SetProtoMethod(isolate, db_tmpl, "open", Database::Open);
+ SetProtoMethod(isolate, db_tmpl, "close", Database::Close);
+ SetProtoDispose(isolate, db_tmpl, Database::Dispose);
+ SetProtoMethod(isolate, db_tmpl, "prepare", Database::Prepare);
+ SetProtoMethod(isolate, db_tmpl, "exec", Database::Exec);
+ SetProtoMethod(isolate, db_tmpl, "function", Database::CustomFunction);
+ SetProtoMethod(isolate, db_tmpl, "createTagStore", Database::CreateTagStore);
+ SetProtoMethodNoSideEffect(isolate, db_tmpl, "location", Database::Location);
+ SetProtoMethod(isolate, db_tmpl, "aggregate", Database::AggregateFunction);
+ SetProtoMethod(isolate, db_tmpl, "createSession", Database::CreateSession);
+ SetProtoMethod(isolate, db_tmpl, "applyChangeset", Database::ApplyChangeset);
SetProtoMethod(
- isolate, db_tmpl, "loadExtension", DatabaseSync::LoadExtension);
- SetProtoMethod(isolate, db_tmpl, "serialize", DatabaseSync::Serialize);
- SetProtoMethod(isolate, db_tmpl, "deserialize", DatabaseSync::Deserialize);
+ isolate, db_tmpl, "enableLoadExtension", Database::EnableLoadExtension);
SetProtoMethod(
- isolate, db_tmpl, "setAuthorizer", DatabaseSync::SetAuthorizer);
- SetProtoMethod(isolate, db_tmpl, "createModule", DatabaseSync::CreateModule);
+ isolate, db_tmpl, "enableDefensive", Database::EnableDefensive);
+ SetProtoMethod(isolate, db_tmpl, "loadExtension", Database::LoadExtension);
+ SetProtoMethod(isolate, db_tmpl, "serialize", Database::Serialize);
+ SetProtoMethod(isolate, db_tmpl, "deserialize", Database::Deserialize);
+ SetProtoMethod(isolate, db_tmpl, "setAuthorizer", Database::SetAuthorizer);
+ SetProtoMethod(isolate, db_tmpl, "createModule", Database::CreateModule);
SetSideEffectFreeGetter(isolate,
db_tmpl,
FIXED_ONE_BYTE_STRING(isolate, "isOpen"),
- DatabaseSync::IsOpenGetter);
+ Database::IsOpenGetter);
SetSideEffectFreeGetter(isolate,
db_tmpl,
FIXED_ONE_BYTE_STRING(isolate, "isTransaction"),
- DatabaseSync::IsTransactionGetter);
+ Database::IsTransactionGetter);
SetSideEffectFreeGetter(isolate,
db_tmpl,
FIXED_ONE_BYTE_STRING(isolate, "limits"),
- DatabaseSync::LimitsGetter);
+ Database::LimitsGetter);
Local<String> sqlite_type_key = FIXED_ONE_BYTE_STRING(isolate, "sqlite-type");
Local<v8::Symbol> sqlite_type_symbol =
v8::Symbol::For(isolate, sqlite_type_key);
@@ -5368,11 +5349,11 @@ static void Initialize(Local<Object> target,
FIXED_ONE_BYTE_STRING(isolate, "node:sqlite");
db_tmpl->InstanceTemplate()->Set(sqlite_type_symbol, database_sync_string);
- SetConstructorFunction(context, target, "DatabaseSync", db_tmpl);
+ SetConstructorFunction(context, target, "Database", db_tmpl);
SetConstructorFunction(context,
target,
- "StatementSync",
- StatementSync::GetConstructorTemplate(env),
+ "Statement",
+ Statement::GetConstructorTemplate(env),
SetConstructorFunctionFlag::NONE);
SetConstructorFunction(context,
target,
diff --git a/src/node_sqlite.h b/src/node_sqlite.h
index 27a8034b7a7..fc2f6cc1518 100644
--- a/src/node_sqlite.h
+++ b/src/node_sqlite.h
@@ -162,10 +162,10 @@ class DatabaseOpenConfiguration {
std::array<std::optional<int>, kLimitMapping.size()> initial_limits_{};
};
-class DatabaseSync;
-class DatabaseSyncLimits;
-class StatementSyncIterator;
-class StatementSync;
+class Database;
+class DatabaseLimits;
+class StatementIterator;
+class Statement;
class BackupJob;
class Session;
@@ -177,21 +177,18 @@ using StatementPtr = DeleteFnPtr<sqlite3_stmt, FinalizeStatement>;
class StatementExecutionHelper {
public:
- static v8::MaybeLocal<v8::Value> All(Environment* env,
- StatementSync* statement);
- static v8::MaybeLocal<v8::Object> Run(Environment* env,
- StatementSync* statement);
- static BaseObjectPtr<StatementSyncIterator> Iterate(
- Environment* env, BaseObjectPtr<StatementSync> stmt);
+ static v8::MaybeLocal<v8::Value> All(Environment* env, Statement* statement);
+ static v8::MaybeLocal<v8::Object> Run(Environment* env, Statement* statement);
+ static BaseObjectPtr<StatementIterator> Iterate(
+ Environment* env, BaseObjectPtr<Statement> stmt);
static v8::MaybeLocal<v8::Value> ColumnToValue(Environment* env,
sqlite3_stmt* stmt,
const int column,
bool use_big_ints);
- static v8::MaybeLocal<v8::Value> Get(Environment* env,
- StatementSync* statement);
+ static v8::MaybeLocal<v8::Value> Get(Environment* env, Statement* statement);
};
-class DatabaseSync;
+class Database;
class BindingData : public BaseObject {
public:
@@ -203,7 +200,7 @@ class BindingData : public BaseObject {
SET_MEMORY_INFO_NAME(BindingData)
SET_SELF_SIZE(BindingData)
- std::unordered_set<DatabaseSync*> open_databases;
+ std::unordered_set<Database*> open_databases;
static void CreatePerContextProperties(v8::Local<v8::Object> target,
v8::Local<v8::Value> unused,
@@ -212,7 +209,7 @@ class BindingData : public BaseObject {
static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
};
-class DatabaseSync : public BaseObject {
+class Database : public BaseObject {
public:
enum InternalFields {
kAuthorizerCallback = BaseObject::kInternalFieldCount,
@@ -220,11 +217,11 @@ class DatabaseSync : public BaseObject {
kInternalFieldCount
};
- DatabaseSync(Environment* env,
- v8::Local<v8::Object> object,
- DatabaseOpenConfiguration&& open_config,
- bool open,
- bool allow_load_extension);
+ Database(Environment* env,
+ v8::Local<v8::Object> object,
+ DatabaseOpenConfiguration&& open_config,
+ bool open,
+ bool allow_load_extension);
void MemoryInfo(MemoryTracker* tracker) const override;
static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Open(const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -265,7 +262,7 @@ class DatabaseSync : public BaseObject {
void RemoveBackup(BackupJob* backup);
void AddBackup(BackupJob* backup);
void FinalizeBackups();
- void UntrackStatement(StatementSync* statement);
+ void UntrackStatement(Statement* statement);
bool IsOpen();
// SQL functions are one of several paths by which SQLite can invoke JS.
size_t GetUserDefinedFunctionCount() const {
@@ -328,14 +325,14 @@ class DatabaseSync : public BaseObject {
void DecrementTraceSuppressionDepth() { --trace_suppression_depth_; }
bool AreTraceEventsSuppressed() const { return trace_suppression_depth_ > 0; }
- SET_MEMORY_INFO_NAME(DatabaseSync)
- SET_SELF_SIZE(DatabaseSync)
+ SET_MEMORY_INFO_NAME(Database)
+ SET_SELF_SIZE(Database)
private:
bool Open();
void DeleteSessions();
- ~DatabaseSync() override;
+ ~Database() override;
DatabaseOpenConfiguration open_config_;
bool allow_load_extension_;
bool enable_load_extension_;
@@ -355,30 +352,30 @@ class DatabaseSync : public BaseObject {
std::unordered_set<const void*> user_defined_functions_;
std::set<BackupJob*> backups_;
std::unordered_set<Session*> sessions_;
- std::unordered_set<StatementSync*> statements_;
+ std::unordered_set<Statement*> statements_;
BaseObjectPtr<diagnostics_channel::Channel> trace_channel_;
friend class UserDefinedFunction;
friend class CustomAggregate;
- friend class DatabaseSyncLimits;
+ friend class DatabaseLimits;
friend class Session;
friend class SQLTagStore;
friend class StatementExecutionHelper;
friend class VirtualTableModule;
};
-class StatementSync : public BaseObject {
+class Statement : public BaseObject {
public:
- StatementSync(Environment* env,
- v8::Local<v8::Object> object,
- BaseObjectPtr<DatabaseSync> db,
- StatementPtr stmt);
+ Statement(Environment* env,
+ v8::Local<v8::Object> object,
+ BaseObjectPtr<Database> db,
+ StatementPtr stmt);
void MemoryInfo(MemoryTracker* tracker) const override;
static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
Environment* env);
- static BaseObjectPtr<StatementSync> Create(Environment* env,
- BaseObjectPtr<DatabaseSync> db,
- StatementPtr stmt);
+ static BaseObjectPtr<Statement> Create(Environment* env,
+ BaseObjectPtr<Database> db,
+ StatementPtr stmt);
static void All(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Iterate(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Get(const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -403,13 +400,13 @@ class StatementSync : public BaseObject {
void Finalize();
bool IsFinalized();
- SET_MEMORY_INFO_NAME(StatementSync)
- SET_SELF_SIZE(StatementSync)
+ SET_MEMORY_INFO_NAME(Statement)
+ SET_SELF_SIZE(Statement)
private:
- ~StatementSync() override;
+ ~Statement() override;
void Close();
- BaseObjectPtr<DatabaseSync> db_;
+ BaseObjectPtr<Database> db_;
StatementPtr statement_;
bool return_arrays_ = false;
bool use_big_ints_;
@@ -424,31 +421,31 @@ class StatementSync : public BaseObject {
bool BindParams(const v8::FunctionCallbackInfo<v8::Value>& args);
bool BindValue(const v8::Local<v8::Value>& value, const int index);
- friend class DatabaseSync;
- friend class StatementSyncIterator;
+ friend class Database;
+ friend class StatementIterator;
friend class SQLTagStore;
friend class StatementExecutionHelper;
};
-class StatementSyncIterator : public BaseObject {
+class StatementIterator : public BaseObject {
public:
- StatementSyncIterator(Environment* env,
- v8::Local<v8::Object> object,
- BaseObjectPtr<StatementSync> stmt);
+ StatementIterator(Environment* env,
+ v8::Local<v8::Object> object,
+ BaseObjectPtr<Statement> stmt);
void MemoryInfo(MemoryTracker* tracker) const override;
static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
Environment* env);
- static BaseObjectPtr<StatementSyncIterator> Create(
- Environment* env, BaseObjectPtr<StatementSync> stmt);
+ static BaseObjectPtr<StatementIterator> Create(Environment* env,
+ BaseObjectPtr<Statement> stmt);
static void Next(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Return(const v8::FunctionCallbackInfo<v8::Value>& args);
- SET_MEMORY_INFO_NAME(StatementSyncIterator)
- SET_SELF_SIZE(StatementSyncIterator)
+ SET_MEMORY_INFO_NAME(StatementIterator)
+ SET_SELF_SIZE(StatementIterator)
private:
- ~StatementSyncIterator() override;
- BaseObjectPtr<StatementSync> stmt_;
+ ~StatementIterator() override;
+ BaseObjectPtr<Statement> stmt_;
bool done_;
uint64_t statement_reset_generation_;
};
@@ -459,7 +456,7 @@ class Session : public BaseObject {
public:
Session(Environment* env,
v8::Local<v8::Object> object,
- BaseObjectPtr<DatabaseSync> database,
+ BaseObjectPtr<Database> database,
sqlite3_session* session);
~Session() override;
template <Sqlite3ChangesetGenFunc sqliteChangesetFunc>
@@ -469,7 +466,7 @@ class Session : public BaseObject {
static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
Environment* env);
static BaseObjectPtr<Session> Create(Environment* env,
- BaseObjectPtr<DatabaseSync> database,
+ BaseObjectPtr<Database> database,
sqlite3_session* session);
void MemoryInfo(MemoryTracker* tracker) const override;
@@ -482,10 +479,10 @@ class Session : public BaseObject {
void operator()(sqlite3_session* s) const { sqlite3session_delete(s); }
};
std::unique_ptr<sqlite3_session, SessionDeleter> session_;
- BaseObjectPtr<DatabaseSync> database_; // The Parent Database
+ BaseObjectPtr<Database> database_; // The Parent Database
bool is_generating_changeset_ = false;
- friend class DatabaseSync;
+ friend class Database;
};
class SQLTagStore : public BaseObject {
@@ -497,11 +494,12 @@ class SQLTagStore : public BaseObject {
SQLTagStore(Environment* env,
v8::Local<v8::Object> object,
- BaseObjectWeakPtr<DatabaseSync> database,
+ BaseObjectWeakPtr<Database> database,
int capacity);
~SQLTagStore() override;
- static BaseObjectPtr<SQLTagStore> Create(
- Environment* env, BaseObjectWeakPtr<DatabaseSync> database, int capacity);
+ static BaseObjectPtr<SQLTagStore> Create(Environment* env,
+ BaseObjectWeakPtr<Database> database,
+ int capacity);
static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
Environment* env);
static void All(const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -517,14 +515,14 @@ class SQLTagStore : public BaseObject {
SET_SELF_SIZE(SQLTagStore)
private:
- static BaseObjectPtr<StatementSync> PrepareStatement(
+ static BaseObjectPtr<Statement> PrepareStatement(
const v8::FunctionCallbackInfo<v8::Value>& args);
static bool ResetAndBindStatement(
Environment* env,
- StatementSync* stmt,
+ Statement* stmt,
const v8::FunctionCallbackInfo<v8::Value>& args);
- BaseObjectWeakPtr<DatabaseSync> database_;
- LRUCache<std::string, BaseObjectPtr<StatementSync>> sql_tags_;
+ BaseObjectWeakPtr<Database> database_;
+ LRUCache<std::string, BaseObjectPtr<Statement>> sql_tags_;
friend class StatementExecutionHelper;
};
@@ -533,7 +531,7 @@ class SQLTagStore : public BaseObject {
// below are what keep a garbage collection during that window safe.
class CallbackDepthGuard {
public:
- explicit CallbackDepthGuard(DatabaseSync* db)
+ explicit CallbackDepthGuard(Database* db)
: db_(db), pinned_sessions_(db->PinSessions()) {
db_->IncrementCallbackDepth();
}
@@ -542,7 +540,7 @@ class CallbackDepthGuard {
CallbackDepthGuard& operator=(const CallbackDepthGuard&) = delete;
private:
- DatabaseSync* db_;
+ Database* db_;
std::vector<BaseObjectPtr<Session>> pinned_sessions_;
};
@@ -552,7 +550,7 @@ class CallbackDepthGuard {
// into JavaScript.
class DestructorScope {
public:
- explicit DestructorScope(DatabaseSync* db) : db_(db) {
+ explicit DestructorScope(Database* db) : db_(db) {
db_->IncrementDestructorDepth();
}
~DestructorScope() { db_->DecrementDestructorDepth(); }
@@ -560,12 +558,12 @@ class DestructorScope {
DestructorScope& operator=(const DestructorScope&) = delete;
private:
- DatabaseSync* db_;
+ Database* db_;
};
class TraceEventSuppressionGuard {
public:
- explicit TraceEventSuppressionGuard(DatabaseSync* db) : db_(db) {
+ explicit TraceEventSuppressionGuard(Database* db) : db_(db) {
db_->IncrementTraceSuppressionDepth();
}
~TraceEventSuppressionGuard() { db_->DecrementTraceSuppressionDepth(); }
@@ -574,12 +572,12 @@ class TraceEventSuppressionGuard {
delete;
private:
- DatabaseSync* db_;
+ Database* db_;
};
class SteppingStatementGuard {
public:
- SteppingStatementGuard(DatabaseSync* db, sqlite3_stmt* stmt) : db_(db) {
+ SteppingStatementGuard(Database* db, sqlite3_stmt* stmt) : db_(db) {
db_->PushSteppingStatement(stmt);
}
~SteppingStatementGuard() { db_->PopSteppingStatement(); }
@@ -587,12 +585,12 @@ class SteppingStatementGuard {
SteppingStatementGuard& operator=(const SteppingStatementGuard&) = delete;
private:
- DatabaseSync* db_;
+ Database* db_;
};
class AuthorizerDepthGuard {
public:
- explicit AuthorizerDepthGuard(DatabaseSync* db) : db_(db) {
+ explicit AuthorizerDepthGuard(Database* db) : db_(db) {
db_->IncrementAuthorizerDepth();
}
~AuthorizerDepthGuard() { db_->DecrementAuthorizerDepth(); }
@@ -600,14 +598,14 @@ class AuthorizerDepthGuard {
AuthorizerDepthGuard& operator=(const AuthorizerDepthGuard&) = delete;
private:
- DatabaseSync* db_;
+ Database* db_;
};
class UserDefinedFunction {
public:
UserDefinedFunction(Environment* env,
v8::Local<v8::Function> fn,
- BaseObjectWeakPtr<DatabaseSync> db,
+ BaseObjectWeakPtr<Database> db,
bool use_bigint_args);
~UserDefinedFunction();
static void xFunc(sqlite3_context* ctx, int argc, sqlite3_value** argv);
@@ -616,21 +614,21 @@ class UserDefinedFunction {
private:
Environment* env_;
v8::Global<v8::Function> fn_;
- BaseObjectWeakPtr<DatabaseSync> db_;
+ BaseObjectWeakPtr<Database> db_;
bool use_bigint_args_;
};
-class DatabaseSyncLimits : public BaseObject {
+class DatabaseLimits : public BaseObject {
public:
- DatabaseSyncLimits(Environment* env,
- v8::Local<v8::Object> object,
- BaseObjectWeakPtr<DatabaseSync> database);
- ~DatabaseSyncLimits() override;
+ DatabaseLimits(Environment* env,
+ v8::Local<v8::Object> object,
+ BaseObjectWeakPtr<Database> database);
+ ~DatabaseLimits() override;
void MemoryInfo(MemoryTracker* tracker) const override;
static v8::Local<v8::ObjectTemplate> GetTemplate(Environment* env);
- static BaseObjectPtr<DatabaseSyncLimits> Create(
- Environment* env, BaseObjectWeakPtr<DatabaseSync> database);
+ static BaseObjectPtr<DatabaseLimits> Create(
+ Environment* env, BaseObjectWeakPtr<Database> database);
static v8::Intercepted LimitsGetter(
v8::Local<v8::Name> property,
@@ -644,11 +642,11 @@ class DatabaseSyncLimits : public BaseObject {
const v8::PropertyCallbackInfo<v8::Integer>& info);
static void LimitsEnumerator(const v8::PropertyCallbackInfo<v8::Array>& info);
- SET_MEMORY_INFO_NAME(DatabaseSyncLimits)
- SET_SELF_SIZE(DatabaseSyncLimits)
+ SET_MEMORY_INFO_NAME(DatabaseLimits)
+ SET_SELF_SIZE(DatabaseLimits)
private:
- BaseObjectWeakPtr<DatabaseSync> database_;
+ BaseObjectWeakPtr<Database> database_;
};
struct NodeVTab {
@@ -672,7 +670,7 @@ struct NodeVTabCursor {
class VirtualTableModule {
public:
VirtualTableModule(Environment* env,
- BaseObjectWeakPtr<DatabaseSync> db,
+ BaseObjectWeakPtr<Database> db,
v8::Local<v8::Function> rows_fn,
std::string&& schema_sql,
int num_columns,
@@ -725,7 +723,7 @@ class VirtualTableModule {
static void ReleaseHiddenValues(NodeVTabCursor* cursor);
Environment* env_;
- BaseObjectWeakPtr<DatabaseSync> db_;
+ BaseObjectWeakPtr<Database> db_;
v8::Global<v8::Function> rows_fn_;
std::string schema_sql_;
int num_columns_;
@@ -737,7 +735,7 @@ class VirtualTableModule {
bool direct_only_;
sqlite3_module module_def_;
- friend class DatabaseSync;
+ friend class Database;
};
} // namespace sqlite
diff --git a/test/fixtures/sqlite/backup-last-request.mjs b/test/fixtures/sqlite/backup-last-request.mjs
index 91ad84e77ed..a68adf30234 100644
--- a/test/fixtures/sqlite/backup-last-request.mjs
+++ b/test/fixtures/sqlite/backup-last-request.mjs
@@ -1,6 +1,6 @@
-import { backup, DatabaseSync } from 'node:sqlite';
+import { backup, Database } from 'node:sqlite';
-const source = new DatabaseSync(':memory:');
+const source = new Database(':memory:');
source.exec(`
CREATE TABLE data(value);
INSERT INTO data VALUES (zeroblob(1048576));
diff --git a/test/parallel/test-permission-sqlite-load-extension.js b/test/parallel/test-permission-sqlite-load-extension.js
index def6f3d1269..e87849ffb2d 100644
--- a/test/parallel/test-permission-sqlite-load-extension.js
+++ b/test/parallel/test-permission-sqlite-load-extension.js
@@ -4,7 +4,7 @@ common.skipIfSQLiteMissing();
const assert = require('node:assert');
const code = `const sqlite = require('node:sqlite');
-const db = new sqlite.DatabaseSync(':memory:', { allowExtension: true });
+const db = new sqlite.Database(':memory:', { allowExtension: true });
db.loadExtension('nonexistent');`.replace(/\n/g, ' ');
common.spawnPromisified(
diff --git a/test/parallel/test-sqlite-aggregate-function.mjs b/test/parallel/test-sqlite-aggregate-function.mjs
index 6c921b866cb..f588cc3ee68 100644
--- a/test/parallel/test-sqlite-aggregate-function.mjs
+++ b/test/parallel/test-sqlite-aggregate-function.mjs
@@ -1,11 +1,11 @@
import { skipIfSQLiteMissing } from '../common/index.mjs';
import { describe, test } from 'node:test';
skipIfSQLiteMissing();
-const { DatabaseSync } = await import('node:sqlite');
+const { Database } = await import('node:sqlite');
-describe('DatabaseSync.prototype.aggregate()', () => {
+describe('Database.prototype.aggregate()', () => {
describe('input validation', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
// The length property is configurable, so any type can reach the
// conversion that derives the aggregate's arity from it.
@@ -130,7 +130,7 @@ describe('DatabaseSync.prototype.aggregate()', () => {
describe('varargs', () => {
test('supports variable number of arguments when true', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => db.close());
db.exec('CREATE TABLE data (value INTEGER)');
db.exec('INSERT INTO data VALUES (1), (2), (3)');
@@ -148,7 +148,7 @@ describe('varargs', () => {
});
test('uses the max between step.length and inverse.length when false', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => db.close());
db.exec(`
CREATE TABLE t3(x, y);
@@ -195,7 +195,7 @@ describe('varargs', () => {
});
test('throws if an incorrect number of arguments is provided when false', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => db.close());
db.aggregate('sum_int', {
start: 0,
@@ -216,7 +216,7 @@ describe('varargs', () => {
describe('directOnly', () => {
test('is false by default', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => db.close());
db.aggregate('func', {
start: 0,
@@ -243,7 +243,7 @@ describe('directOnly', () => {
});
test('set SQLITE_DIRECT_ONLY flag when true', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => db.close());
db.aggregate('func', {
start: 0,
@@ -277,7 +277,7 @@ describe('directOnly', () => {
describe('start', () => {
test('start option as a value', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => db.close());
db.exec('CREATE TABLE data (value INTEGER)');
db.exec('INSERT INTO data VALUES (1), (2), (3)');
@@ -292,7 +292,7 @@ describe('start', () => {
});
test('start option as a function', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => db.close());
db.exec('CREATE TABLE data (value INTEGER)');
db.exec('INSERT INTO data VALUES (1), (2), (3)');
@@ -307,7 +307,7 @@ describe('start', () => {
});
test('start option can hold any js value', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => db.close());
db.exec('CREATE TABLE data (value INTEGER)');
db.exec('INSERT INTO data VALUES (1), (2), (3)');
@@ -325,7 +325,7 @@ describe('start', () => {
});
test('throws if start throws an error', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => db.close());
db.exec('CREATE TABLE data (value INTEGER)');
db.exec('INSERT INTO data VALUES (1), (2), (3)');
@@ -346,7 +346,7 @@ describe('start', () => {
describe('step', () => {
test('throws if step throws an error', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => db.close());
db.exec('CREATE TABLE data (value INTEGER)');
db.exec('INSERT INTO data VALUES (1), (2), (3)');
@@ -367,7 +367,7 @@ describe('step', () => {
describe('result', () => {
test('throws if result throws an error', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => db.close());
db.exec('CREATE TABLE data (value INTEGER)');
db.exec('INSERT INTO data VALUES (1), (2), (3)');
@@ -388,7 +388,7 @@ describe('result', () => {
});
test('executes once when options.inverse is not present', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => db.close());
const mockFn = t.mock.fn(() => 'overridden');
db.exec('CREATE TABLE data (value INTEGER)');
@@ -409,7 +409,7 @@ describe('result', () => {
});
test('executes once per row when options.inverse is present', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => db.close());
const mockFn = t.mock.fn((acc) => acc);
db.exec(`
@@ -444,7 +444,7 @@ describe('result', () => {
});
test('throws an error when trying to use as windown function but didn\'t provide options.inverse', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => db.close());
db.exec(`
CREATE TABLE t3(x, y);
diff --git a/test/parallel/test-sqlite-authz.js b/test/parallel/test-sqlite-authz.js
index eda923e258b..db241dd951f 100644
--- a/test/parallel/test-sqlite-authz.js
+++ b/test/parallel/test-sqlite-authz.js
@@ -4,12 +4,12 @@ const common = require('../common');
common.skipIfSQLiteMissing();
const assert = require('node:assert');
-const { DatabaseSync, constants } = require('node:sqlite');
+const { Database, constants } = require('node:sqlite');
const { suite, it } = require('node:test');
-suite('DatabaseSync.prototype.setAuthorizer()', () => {
+suite('Database.prototype.setAuthorizer()', () => {
const createTestDatabase = () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec('CREATE TABLE users (id INTEGER, name TEXT)');
return db;
};
@@ -50,7 +50,7 @@ suite('DatabaseSync.prototype.setAuthorizer()', () => {
});
it('allows operations when authorizer returns SQLITE_OK', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.setAuthorizer(() => constants.SQLITE_OK);
db.exec('CREATE TABLE users (id INTEGER, name TEXT)');
@@ -60,7 +60,7 @@ suite('DatabaseSync.prototype.setAuthorizer()', () => {
});
it('blocks operations when authorizer returns SQLITE_DENY', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.setAuthorizer(() => constants.SQLITE_DENY);
assert.throws(() => {
@@ -155,7 +155,7 @@ suite('DatabaseSync.prototype.setAuthorizer()', () => {
});
it('rethrows error when authorizer throws error', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.setAuthorizer(() => {
throw new Error('Unknown error');
});
@@ -168,7 +168,7 @@ suite('DatabaseSync.prototype.setAuthorizer()', () => {
});
it('throws error when authorizer returns nothing', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.setAuthorizer(() => {
});
@@ -180,7 +180,7 @@ suite('DatabaseSync.prototype.setAuthorizer()', () => {
});
it('throws error when authorizer returns NaN', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.setAuthorizer(() => {
return '1';
});
@@ -193,7 +193,7 @@ suite('DatabaseSync.prototype.setAuthorizer()', () => {
});
it('throws error when authorizer returns a invalid code', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.setAuthorizer(() => {
return 3;
});
@@ -207,7 +207,7 @@ suite('DatabaseSync.prototype.setAuthorizer()', () => {
it('clears authorizer when set to null', (t) => {
const authorizer = t.mock.fn(() => constants.SQLITE_OK);
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
const statement = db.prepare('SELECT 1');
// Set authorizer and verify it's called
@@ -222,7 +222,7 @@ suite('DatabaseSync.prototype.setAuthorizer()', () => {
});
it('throws when callback is a string', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
assert.throws(() => {
db.setAuthorizer('not a function');
@@ -233,7 +233,7 @@ suite('DatabaseSync.prototype.setAuthorizer()', () => {
});
it('throws when callback is a number', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
assert.throws(() => {
db.setAuthorizer(1);
@@ -244,7 +244,7 @@ suite('DatabaseSync.prototype.setAuthorizer()', () => {
});
it('throws when callback is an object', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
assert.throws(() => {
db.setAuthorizer({});
@@ -255,7 +255,7 @@ suite('DatabaseSync.prototype.setAuthorizer()', () => {
});
it('throws when callback is an array', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
assert.throws(() => {
db.setAuthorizer([]);
@@ -266,7 +266,7 @@ suite('DatabaseSync.prototype.setAuthorizer()', () => {
});
it('throws when callback is undefined', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
assert.throws(() => {
db.setAuthorizer();
@@ -277,7 +277,7 @@ suite('DatabaseSync.prototype.setAuthorizer()', () => {
});
it('throws if database is not open', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.close();
assert.throws(() => {
@@ -331,7 +331,7 @@ suite('authorizer callback reentrancy', () => {
);
it('rejects database methods', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec('CREATE TABLE t (x INTEGER)');
const cases = {
prepare: () => db.prepare('SELECT 1'),
@@ -354,7 +354,7 @@ suite('authorizer callback reentrancy', () => {
// loadExtension() checks that extension loading is enabled before reaching
// the authorizer guard, so it needs a database opened with allowExtension.
it('rejects loadExtension', () => {
- const db = new DatabaseSync(':memory:', { allowExtension: true });
+ const db = new Database(':memory:', { allowExtension: true });
db.enableLoadExtension(true);
db.exec('CREATE TABLE t (x INTEGER)');
const cases = {
@@ -367,7 +367,7 @@ suite('authorizer callback reentrancy', () => {
// close() and deserialize() tear down the connection, so the pre-existing
// callback depth guard already rejects them with its own message.
it('rejects methods the callback depth guard already covers', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec('CREATE TABLE t (x INTEGER)');
const snapshot = db.serialize();
const cases = {
@@ -383,7 +383,7 @@ suite('authorizer callback reentrancy', () => {
});
it('rejects statement methods', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec('CREATE TABLE t (x INTEGER)');
db.exec('INSERT INTO t VALUES (1)');
const stmt = db.prepare('SELECT x FROM t');
@@ -399,7 +399,7 @@ suite('authorizer callback reentrancy', () => {
// An idle statement has no virtual-machine state or locks to release.
it('allows finalizing an idle statement', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec('CREATE TABLE t (x INTEGER)');
db.exec('INSERT INTO t VALUES (1)');
const closeStmt = db.prepare('SELECT x FROM t');
@@ -418,7 +418,7 @@ suite('authorizer callback reentrancy', () => {
// A paused iterator is busy and may hold locks between sqlite3_step() calls.
it('rejects finalizing another active statement', () => {
for (const method of ['close', 'dispose']) {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec('CREATE TABLE t (x INTEGER)');
db.exec('INSERT INTO t VALUES (1), (2), (3)');
const stmt = db.prepare('SELECT x FROM t');
@@ -456,7 +456,7 @@ suite('authorizer callback reentrancy', () => {
// a no-op even inside a callback. Throwing here would turn a `using` scope's
// real exception into a SuppressedError.
it('allows disposing an already-finalized statement', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec('CREATE TABLE t (x INTEGER)');
const stmt = db.prepare('SELECT x FROM t');
stmt.close();
@@ -468,7 +468,7 @@ suite('authorizer callback reentrancy', () => {
});
it('rejects session changeset methods', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec('CREATE TABLE t (x INTEGER PRIMARY KEY, y TEXT)');
const session = db.createSession({ table: 't' });
db.exec("INSERT INTO t VALUES (1, 'a')");
@@ -483,7 +483,7 @@ suite('authorizer callback reentrancy', () => {
// A statement being re-prepared inside sqlite3_step() is the case that
// actually crashes, because that statement's VM is mid-execution.
it('rejects finalizing the statement being stepped', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec('CREATE TABLE t (x INTEGER)');
db.exec('INSERT INTO t VALUES (1)');
const stmt = db.prepare('SELECT x FROM t');
@@ -513,7 +513,7 @@ suite('authorizer callback reentrancy', () => {
// Unlike an already-finalized statement, disposing the one being stepped
// would free the running virtual machine, so it throws.
it('rejects disposing the statement being stepped', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec('CREATE TABLE t (x INTEGER)');
db.exec('INSERT INTO t VALUES (1)');
const stmt = db.prepare('SELECT x FROM t');
@@ -541,7 +541,7 @@ suite('authorizer callback reentrancy', () => {
});
it('rejects iterator methods', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec('CREATE TABLE t (x INTEGER)');
db.exec('INSERT INTO t VALUES (1), (2)');
const iter = db.prepare('SELECT x FROM t').iterate();
@@ -557,7 +557,7 @@ suite('authorizer callback reentrancy', () => {
// A drained iterator holds no SQLite state, so next() and return() stay
// available and remain idempotent inside a callback.
it('allows iterator methods on a drained iterator', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec('CREATE TABLE t (x INTEGER)');
db.exec('INSERT INTO t VALUES (1)');
const iter = db.prepare('SELECT x FROM t').iterate();
@@ -578,7 +578,7 @@ suite('authorizer callback reentrancy', () => {
});
it('rejects tag store methods', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec('CREATE TABLE t (x INTEGER)');
const sql = db.createTagStore(10);
const cases = {
@@ -594,7 +594,7 @@ suite('authorizer callback reentrancy', () => {
// clear() only drops cached statements, so invalidating the cache after a
// schema change is allowed from the callback.
it('allows clearing a tag store', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec('CREATE TABLE t (x INTEGER)');
db.exec('INSERT INTO t VALUES (1)');
const sql = db.createTagStore(10);
@@ -611,7 +611,7 @@ suite('authorizer callback reentrancy', () => {
// A statement may be re-prepared during sqlite3_step() after a schema
// change, which invokes the authorizer without an explicit prepare() call.
it('rejects reentry when the authorizer runs during a re-prepare', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec('CREATE TABLE t (x INTEGER)');
db.exec('INSERT INTO t VALUES (1)');
const stmt = db.prepare('SELECT x FROM t');
@@ -639,7 +639,7 @@ suite('authorizer callback reentrancy', () => {
});
it('allows access again after the authorizer returns', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec('CREATE TABLE t (x INTEGER)');
const cases = { prepare: () => db.prepare('SELECT 1') };
diff --git a/test/parallel/test-sqlite-backup.mjs b/test/parallel/test-sqlite-backup.mjs
index ee5f54fd909..cae097aa92e 100644
--- a/test/parallel/test-sqlite-backup.mjs
+++ b/test/parallel/test-sqlite-backup.mjs
@@ -11,7 +11,7 @@ import { describe, test } from 'node:test';
import { writeFileSync } from 'node:fs';
import { pathToFileURL } from 'node:url';
skipIfSQLiteMissing();
-const { backup, DatabaseSync } = await import('node:sqlite');
+const { backup, Database } = await import('node:sqlite');
const isRoot = !isWindows && process.getuid() === 0;
@@ -24,7 +24,7 @@ function nextDb() {
}
function makeSourceDb(dbPath = ':memory:') {
- const database = new DatabaseSync(dbPath);
+ const database = new Database(dbPath);
database.exec(`
CREATE TABLE data(
@@ -159,7 +159,7 @@ test('database backup', async (t) => {
progress: progressFn,
});
- const backupDb = new DatabaseSync(destDb);
+ const backupDb = new Database(destDb);
const rows = backupDb.prepare('SELECT * FROM data').all();
// The source database has two pages - using the default page size -,
@@ -186,7 +186,7 @@ test('backup database using location as URL', async (t) => {
await backup(database, destDb);
- const backupDb = new DatabaseSync(destDb);
+ const backupDb = new Database(destDb);
t.after(() => { backupDb.close(); });
@@ -206,7 +206,7 @@ test('backup database using location as Buffer', async (t) => {
await backup(database, destDb);
- const backupDb = new DatabaseSync(destDb);
+ const backupDb = new Database(destDb);
t.after(() => { backupDb.close(); });
@@ -228,7 +228,7 @@ test('database backup in a single call', async (t) => {
progress: progressFn,
});
- const backupDb = new DatabaseSync(destDb);
+ const backupDb = new Database(destDb);
const rows = backupDb.prepare('SELECT * FROM data').all();
t.assert.strictEqual(progressFn.mock.calls.length, 0);
@@ -245,7 +245,7 @@ test('database backup in a single call', async (t) => {
test('throws exception when trying to start backup from a closed database', (t) => {
t.assert.throws(() => {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
database.close();
@@ -257,7 +257,7 @@ test('throws exception when trying to start backup from a closed database', (t)
});
test('throws if URL is not file: scheme', (t) => {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
t.after(() => { database.close(); });
@@ -270,7 +270,7 @@ test('throws if URL is not file: scheme', (t) => {
});
test('throws if the URL-like path has an unparsable href', (t) => {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
t.after(() => { database.close(); });
@@ -341,7 +341,7 @@ test('backup has correct name and length', (t) => {
});
test('source database is kept alive while a backup is in flight', async (t) => {
- // Regression test: previously, BackupJob stored a raw DatabaseSync* and the
+ // Regression test: previously, BackupJob stored a raw Database* and the
// source could be garbage-collected while the backup was still running,
// leading to a use-after-free when BackupJob::Finalize() dereferenced the
// stale pointer via source_->RemoveBackup(this).
@@ -359,12 +359,12 @@ test('source database is kept alive while a backup is in flight', async (t) => {
progress() {},
});
// Drop the last strong JS reference to the source database. With the bug,
- // the DatabaseSync could be collected here and the in-flight backup would
+ // the Database could be collected here and the in-flight backup would
// later crash while accessing the freed source.
database = null;
// Nudge the GC aggressively, but the backup must keep the source alive
- // regardless. Without the fix, the source DatabaseSync would be collected
+ // regardless. Without the fix, the source Database would be collected
// and BackupJob::Finalize() would crash the process.
for (let i = 0; i < 5; i++) {
global.gc();
@@ -374,7 +374,7 @@ test('source database is kept alive while a backup is in flight', async (t) => {
const totalPages = await p;
t.assert.ok(totalPages > 0);
- const backupDb = new DatabaseSync(destDb);
+ const backupDb = new Database(destDb);
t.after(() => { backupDb.close(); });
const rows = backupDb.prepare('SELECT COUNT(*) AS n FROM data').get();
t.assert.strictEqual(rows.n, 500);
diff --git a/test/parallel/test-sqlite-config.js b/test/parallel/test-sqlite-config.js
index d1a6cae2d74..0988bdb14a3 100644
--- a/test/parallel/test-sqlite-config.js
+++ b/test/parallel/test-sqlite-config.js
@@ -3,7 +3,7 @@ const { skipIfSQLiteMissing } = require('../common/index.mjs');
const { test } = require('node:test');
const assert = require('node:assert');
skipIfSQLiteMissing();
-const { DatabaseSync } = require('node:sqlite');
+const { Database } = require('node:sqlite');
function checkDefensiveMode(db) {
function journalMode() {
@@ -21,32 +21,32 @@ function checkDefensiveMode(db) {
}
test('by default, defensive mode is on', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.assert.strictEqual(checkDefensiveMode(db), true);
});
test('when passing { defensive: true } as config, defensive mode is on', (t) => {
- const db = new DatabaseSync(':memory:', {
+ const db = new Database(':memory:', {
defensive: true
});
t.assert.strictEqual(checkDefensiveMode(db), true);
});
test('when passing { defensive: false } as config, defensive mode is off', (t) => {
- const db = new DatabaseSync(':memory:', {
+ const db = new Database(':memory:', {
defensive: false
});
t.assert.strictEqual(checkDefensiveMode(db), false);
});
test('defensive mode on after calling db.enableDefensive(true)', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.enableDefensive(true);
t.assert.strictEqual(checkDefensiveMode(db), true);
});
test('defensive mode off after calling db.enableDefensive(false)', (t) => {
- const db = new DatabaseSync(':memory:', {
+ const db = new Database(':memory:', {
defensive: true
});
db.enableDefensive(false);
@@ -55,7 +55,7 @@ test('defensive mode off after calling db.enableDefensive(false)', (t) => {
test('throws if options.defensive is provided but is not a boolean', (t) => {
t.assert.throws(() => {
- new DatabaseSync(':memory:', { defensive: 42 });
+ new Database(':memory:', { defensive: 42 });
}, {
code: 'ERR_INVALID_ARG_TYPE',
message: 'The "options.defensive" argument must be a boolean.',
@@ -63,7 +63,7 @@ test('throws if options.defensive is provided but is not a boolean', (t) => {
});
test('enableLoadExtension() throws if database is not open', (t) => {
- const db = new DatabaseSync(':memory:', { allowExtension: true });
+ const db = new Database(':memory:', { allowExtension: true });
db.close();
t.assert.throws(() => {
diff --git a/test/parallel/test-sqlite-custom-functions.js b/test/parallel/test-sqlite-custom-functions.js
index 0b783ce9bcf..20b16138813 100644
--- a/test/parallel/test-sqlite-custom-functions.js
+++ b/test/parallel/test-sqlite-custom-functions.js
@@ -2,12 +2,12 @@
const { skipIfSQLiteMissing, mustCall } = require('../common');
skipIfSQLiteMissing();
const assert = require('node:assert');
-const { DatabaseSync } = require('node:sqlite');
+const { Database } = require('node:sqlite');
const { suite, test } = require('node:test');
-suite('DatabaseSync.prototype.function()', () => {
+suite('Database.prototype.function()', () => {
suite('input validation', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
test('throws if name is not a string', () => {
assert.throws(() => {
@@ -97,7 +97,7 @@ suite('DatabaseSync.prototype.function()', () => {
suite('useBigIntArguments', () => {
test('converts arguments to BigInts when true', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
let value;
const r = db.function('custom', { useBigIntArguments: true }, (arg) => {
value = arg;
@@ -108,7 +108,7 @@ suite('DatabaseSync.prototype.function()', () => {
});
test('uses number primitives when false', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
let value;
const r = db.function('custom', { useBigIntArguments: false }, (arg) => {
value = arg;
@@ -119,7 +119,7 @@ suite('DatabaseSync.prototype.function()', () => {
});
test('defaults to false', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
let value;
const r = db.function('custom', (arg) => {
value = arg;
@@ -130,7 +130,7 @@ suite('DatabaseSync.prototype.function()', () => {
});
test('throws if value cannot fit in a number', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
const value = Number.MAX_SAFE_INTEGER + 1;
db.function('custom', (arg) => {});
assert.throws(() => {
@@ -144,7 +144,7 @@ suite('DatabaseSync.prototype.function()', () => {
suite('varargs', () => {
test('supports variable number of arguments when true', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
let value;
const r = db.function('custom', { varargs: true }, (...args) => {
value = args;
@@ -155,7 +155,7 @@ suite('DatabaseSync.prototype.function()', () => {
});
test('uses function.length when false', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
let value;
const r = db.function('custom', { varargs: false }, (a, b, c) => {
value = [a, b, c];
@@ -166,7 +166,7 @@ suite('DatabaseSync.prototype.function()', () => {
});
test('defaults to false', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
let value;
const r = db.function('custom', (a, b, c) => {
value = [a, b, c];
@@ -177,7 +177,7 @@ suite('DatabaseSync.prototype.function()', () => {
});
test('throws if an incorrect number of arguments is provided', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.function('custom', (a, b, c, d) => {});
assert.throws(() => {
db.prepare('SELECT custom(1, 2, 3) AS custom').get();
@@ -190,7 +190,7 @@ suite('DatabaseSync.prototype.function()', () => {
suite('deterministic', () => {
test('creates a deterministic function when true', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.function('isDeterministic', { deterministic: true }, () => {
return 42;
});
@@ -204,7 +204,7 @@ suite('DatabaseSync.prototype.function()', () => {
});
test('creates a non-deterministic function when false', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.function('isNonDeterministic', { deterministic: false }, () => {
return 42;
});
@@ -222,7 +222,7 @@ suite('DatabaseSync.prototype.function()', () => {
});
test('deterministic defaults to false', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.function('isNonDeterministic', () => {
return 42;
});
@@ -242,7 +242,7 @@ suite('DatabaseSync.prototype.function()', () => {
suite('directOnly', () => {
test('sets SQLite direct only flag when true', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.function('fn', { deterministic: true, directOnly: true }, () => {
return 42;
});
@@ -260,7 +260,7 @@ suite('DatabaseSync.prototype.function()', () => {
});
test('does not set SQLite direct only flag when false', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.function('fn', { deterministic: true, directOnly: false }, () => {
return 42;
});
@@ -274,7 +274,7 @@ suite('DatabaseSync.prototype.function()', () => {
});
test('directOnly defaults to false', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.function('fn', { deterministic: true }, () => {
return 42;
});
@@ -290,7 +290,7 @@ suite('DatabaseSync.prototype.function()', () => {
suite('return types', () => {
test('supported return types', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.function('retUndefined', () => {});
db.function('retNull', () => { return null; });
db.function('retNumber', () => { return 3; });
@@ -323,7 +323,7 @@ suite('DatabaseSync.prototype.function()', () => {
});
test('throws if returned BigInt is too large for SQLite', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.function('retBigInt', () => {
return BigInt(Number.MAX_SAFE_INTEGER + 1);
});
@@ -336,7 +336,7 @@ suite('DatabaseSync.prototype.function()', () => {
});
test('does not support Promise return values', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.function('retPromise', async () => {});
const stmt = db.prepare('SELECT retPromise() AS retPromise');
assert.throws(() => {
@@ -348,7 +348,7 @@ suite('DatabaseSync.prototype.function()', () => {
});
test('throws on unsupported return types', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.function('retFunction', () => {
return () => {};
});
@@ -364,7 +364,7 @@ suite('DatabaseSync.prototype.function()', () => {
suite('handles conflicting errors from SQLite and JavaScript', () => {
test('throws if value cannot fit in a number', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
const expected = { __proto__: null, id: 5, data: 'foo' };
db.function('custom', (arg) => {});
db.exec('CREATE TABLE test (id NUMBER NOT NULL PRIMARY KEY, data TEXT)');
@@ -380,7 +380,7 @@ suite('DatabaseSync.prototype.function()', () => {
});
test('propagates JavaScript errors', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
const expected = { __proto__: null, id: 5, data: 'foo' };
const err = new Error('boom');
db.function('throws', () => {
@@ -397,7 +397,7 @@ suite('DatabaseSync.prototype.function()', () => {
});
test('supported argument types', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.function('arguments', mustCall((i, f, s, n, b) => {
assert.strictEqual(i, 5);
assert.strictEqual(f, 3.14);
@@ -413,7 +413,7 @@ suite('DatabaseSync.prototype.function()', () => {
});
test('propagates thrown errors', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
const err = new Error('boom');
db.function('throws', () => {
throw err;
@@ -425,7 +425,7 @@ suite('DatabaseSync.prototype.function()', () => {
});
test('throws if database is not open', () => {
- const db = new DatabaseSync(':memory:', { open: false });
+ const db = new Database(':memory:', { open: false });
assert.throws(() => {
db.function('foo', () => {});
}, {
diff --git a/test/parallel/test-sqlite-data-types.js b/test/parallel/test-sqlite-data-types.js
index 516233fcb0e..473e504ead2 100644
--- a/test/parallel/test-sqlite-data-types.js
+++ b/test/parallel/test-sqlite-data-types.js
@@ -1,13 +1,13 @@
'use strict';
const { skipIfSQLiteMissing } = require('../common');
skipIfSQLiteMissing();
-const { DatabaseSync } = require('node:sqlite');
+const { Database } = require('node:sqlite');
const { suite, test } = require('node:test');
suite('data binding and mapping', () => {
test('supported data types', (t) => {
const u8a = new TextEncoder().encode('a☃b☃c');
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => { db.close(); });
const setup = db.exec(`
CREATE TABLE types(
@@ -92,7 +92,7 @@ suite('data binding and mapping', () => {
});
test('undefined is bound as NULL', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => { db.close(); });
const setup = db.exec(
'CREATE TABLE types(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
@@ -126,7 +126,7 @@ suite('data binding and mapping', () => {
});
test('undefined is not treated as the named parameters argument', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => { db.close(); });
// `undefined` is not an object, so it is bound as an anonymous parameter
@@ -147,7 +147,7 @@ suite('data binding and mapping', () => {
});
test('large strings are bound correctly', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => { db.close(); });
const setup = db.exec(
'CREATE TABLE data(key INTEGER PRIMARY KEY, text TEXT) STRICT;'
@@ -182,7 +182,7 @@ suite('data binding and mapping', () => {
});
test('unsupported data types', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => { db.close(); });
const setup = db.exec(
'CREATE TABLE types(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
@@ -216,7 +216,7 @@ suite('data binding and mapping', () => {
test('throws when binding a BigInt that is too large', (t) => {
const max = 9223372036854775807n; // Largest 64-bit signed integer value.
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => { db.close(); });
const setup = db.exec(
'CREATE TABLE types(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
@@ -236,7 +236,7 @@ suite('data binding and mapping', () => {
});
test('statements are unbound on each call', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => { db.close(); });
const setup = db.exec(
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
diff --git a/test/parallel/test-sqlite-database-sync.js b/test/parallel/test-sqlite-database.js
similarity index 82%
rename from test/parallel/test-sqlite-database-sync.js
rename to test/parallel/test-sqlite-database.js
index e570ffde779..79e1fe35d43 100644
--- a/test/parallel/test-sqlite-database-sync.js
+++ b/test/parallel/test-sqlite-database.js
@@ -4,7 +4,7 @@ skipIfSQLiteMissing();
const tmpdir = require('../common/tmpdir');
const { existsSync, mkdirSync } = require('node:fs');
const { join } = require('node:path');
-const { DatabaseSync, StatementSync } = require('node:sqlite');
+const { Database, Statement } = require('node:sqlite');
const { suite, test } = require('node:test');
let cnt = 0;
@@ -14,10 +14,10 @@ function nextDb() {
return join(tmpdir.path, `database-${cnt++}.db`);
}
-suite('DatabaseSync() constructor', () => {
+suite('Database() constructor', () => {
test('throws if called without new', (t) => {
t.assert.throws(() => {
- DatabaseSync();
+ Database();
}, {
code: 'ERR_CONSTRUCT_CALL_REQUIRED',
message: /Cannot call constructor without `new`/,
@@ -26,7 +26,7 @@ suite('DatabaseSync() constructor', () => {
test('throws if database path is not a string, Uint8Array, or URL', (t) => {
t.assert.throws(() => {
- new DatabaseSync();
+ new Database();
}, {
code: 'ERR_INVALID_ARG_TYPE',
message: /The "path" argument must be a string, Uint8Array, or URL without null bytes/,
@@ -35,7 +35,7 @@ suite('DatabaseSync() constructor', () => {
test('throws if the database location as Buffer contains null bytes', (t) => {
t.assert.throws(() => {
- new DatabaseSync(Buffer.from('l\0cation'));
+ new Database(Buffer.from('l\0cation'));
}, {
code: 'ERR_INVALID_ARG_TYPE',
message: 'The "path" argument must be a string, Uint8Array, or URL without null bytes.',
@@ -44,7 +44,7 @@ suite('DatabaseSync() constructor', () => {
test('throws if the database location as string contains null bytes', (t) => {
t.assert.throws(() => {
- new DatabaseSync('l\0cation');
+ new Database('l\0cation');
}, {
code: 'ERR_INVALID_ARG_TYPE',
message: 'The "path" argument must be a string, Uint8Array, or URL without null bytes.',
@@ -53,13 +53,13 @@ suite('DatabaseSync() constructor', () => {
test('throws if the URL-like path has an unparsable href', (t) => {
t.assert.throws(() => {
- new DatabaseSync({ href: 'not a url' });
+ new Database({ href: 'not a url' });
}, { code: 'ERR_INVALID_URL' });
});
test('throws if options is provided but is not an object', (t) => {
t.assert.throws(() => {
- new DatabaseSync('foo', null);
+ new Database('foo', null);
}, {
code: 'ERR_INVALID_ARG_TYPE',
message: /The "options" argument must be an object/,
@@ -68,7 +68,7 @@ suite('DatabaseSync() constructor', () => {
test('throws if options.open is provided but is not a boolean', (t) => {
t.assert.throws(() => {
- new DatabaseSync('foo', { open: 5 });
+ new Database('foo', { open: 5 });
}, {
code: 'ERR_INVALID_ARG_TYPE',
message: /The "options\.open" argument must be a boolean/,
@@ -77,7 +77,7 @@ suite('DatabaseSync() constructor', () => {
test('throws if options.readOnly is provided but is not a boolean', (t) => {
t.assert.throws(() => {
- new DatabaseSync('foo', { readOnly: 5 });
+ new Database('foo', { readOnly: 5 });
}, {
code: 'ERR_INVALID_ARG_TYPE',
message: /The "options\.readOnly" argument must be a boolean/,
@@ -86,7 +86,7 @@ suite('DatabaseSync() constructor', () => {
test('throws if options.timeout is provided but is not an integer', (t) => {
t.assert.throws(() => {
- new DatabaseSync('foo', { timeout: .99 });
+ new Database('foo', { timeout: .99 });
}, {
code: 'ERR_INVALID_ARG_TYPE',
message: /The "options\.timeout" argument must be an integer/,
@@ -95,18 +95,18 @@ suite('DatabaseSync() constructor', () => {
test('is not read-only by default', (t) => {
const dbPath = nextDb();
- using db = new DatabaseSync(dbPath);
+ using db = new Database(dbPath);
db.exec('CREATE TABLE foo (id INTEGER PRIMARY KEY)');
});
test('is read-only if readOnly is set', (t) => {
const dbPath = nextDb();
{
- using db = new DatabaseSync(dbPath);
+ using db = new Database(dbPath);
db.exec('CREATE TABLE foo (id INTEGER PRIMARY KEY)');
}
{
- using db = new DatabaseSync(dbPath, { readOnly: true });
+ using db = new Database(dbPath, { readOnly: true });
t.assert.throws(() => {
db.exec('CREATE TABLE bar (id INTEGER PRIMARY KEY)');
}, {
@@ -118,7 +118,7 @@ suite('DatabaseSync() constructor', () => {
test('throws if options.enableForeignKeyConstraints is provided but is not a boolean', (t) => {
t.assert.throws(() => {
- new DatabaseSync('foo', { enableForeignKeyConstraints: 5 });
+ new Database('foo', { enableForeignKeyConstraints: 5 });
}, {
code: 'ERR_INVALID_ARG_TYPE',
message: /The "options\.enableForeignKeyConstraints" argument must be a boolean/,
@@ -127,7 +127,7 @@ suite('DatabaseSync() constructor', () => {
test('enables foreign key constraints by default', (t) => {
const dbPath = nextDb();
- using db = new DatabaseSync(dbPath);
+ using db = new Database(dbPath);
db.exec(`
CREATE TABLE foo (id INTEGER PRIMARY KEY);
CREATE TABLE bar (foo_id INTEGER REFERENCES foo(id));
@@ -142,7 +142,7 @@ suite('DatabaseSync() constructor', () => {
test('allows disabling foreign key constraints', (t) => {
const dbPath = nextDb();
- using db = new DatabaseSync(dbPath, { enableForeignKeyConstraints: false });
+ using db = new Database(dbPath, { enableForeignKeyConstraints: false });
db.exec(`
CREATE TABLE foo (id INTEGER PRIMARY KEY);
CREATE TABLE bar (foo_id INTEGER REFERENCES foo(id));
@@ -152,7 +152,7 @@ suite('DatabaseSync() constructor', () => {
test('throws if options.enableDoubleQuotedStringLiterals is provided but is not a boolean', (t) => {
t.assert.throws(() => {
- new DatabaseSync('foo', { enableDoubleQuotedStringLiterals: 5 });
+ new Database('foo', { enableDoubleQuotedStringLiterals: 5 });
}, {
code: 'ERR_INVALID_ARG_TYPE',
message: /The "options\.enableDoubleQuotedStringLiterals" argument must be a boolean/,
@@ -161,7 +161,7 @@ suite('DatabaseSync() constructor', () => {
test('disables double-quoted string literals by default', (t) => {
const dbPath = nextDb();
- using db = new DatabaseSync(dbPath);
+ using db = new Database(dbPath);
t.assert.throws(() => {
db.exec('SELECT "foo";');
}, {
@@ -172,13 +172,13 @@ suite('DatabaseSync() constructor', () => {
test('allows enabling double-quoted string literals', (t) => {
const dbPath = nextDb();
- using db = new DatabaseSync(dbPath, { enableDoubleQuotedStringLiterals: true });
+ using db = new Database(dbPath, { enableDoubleQuotedStringLiterals: true });
db.exec('SELECT "foo";');
});
test('throws if options.readBigInts is provided but is not a boolean', (t) => {
t.assert.throws(() => {
- new DatabaseSync('foo', { readBigInts: 42 });
+ new Database('foo', { readBigInts: 42 });
}, {
code: 'ERR_INVALID_ARG_TYPE',
message: 'The "options.readBigInts" argument must be a boolean.',
@@ -187,7 +187,7 @@ suite('DatabaseSync() constructor', () => {
test('allows reading big integers', (t) => {
const dbPath = nextDb();
- using db = new DatabaseSync(dbPath, { readBigInts: true });
+ using db = new Database(dbPath, { readBigInts: true });
const setup = db.exec(`
CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;
@@ -207,7 +207,7 @@ suite('DatabaseSync() constructor', () => {
test('throws if options.returnArrays is provided but is not a boolean', (t) => {
t.assert.throws(() => {
- new DatabaseSync('foo', { returnArrays: 42 });
+ new Database('foo', { returnArrays: 42 });
}, {
code: 'ERR_INVALID_ARG_TYPE',
message: 'The "options.returnArrays" argument must be a boolean.',
@@ -216,7 +216,7 @@ suite('DatabaseSync() constructor', () => {
test('allows returning arrays', (t) => {
const dbPath = nextDb();
- using db = new DatabaseSync(dbPath, { returnArrays: true });
+ using db = new Database(dbPath, { returnArrays: true });
const setup = db.exec(`
CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;
INSERT INTO data (key, val) VALUES (1, 'one');
@@ -230,7 +230,7 @@ suite('DatabaseSync() constructor', () => {
test('throws if options.allowBareNamedParameters is provided but is not a boolean', (t) => {
t.assert.throws(() => {
- new DatabaseSync('foo', { allowBareNamedParameters: 42 });
+ new Database('foo', { allowBareNamedParameters: 42 });
}, {
code: 'ERR_INVALID_ARG_TYPE',
message: 'The "options.allowBareNamedParameters" argument must be a boolean.',
@@ -239,7 +239,7 @@ suite('DatabaseSync() constructor', () => {
test('throws if bare named parameters are used when option is false', (t) => {
const dbPath = nextDb();
- using db = new DatabaseSync(dbPath, { allowBareNamedParameters: false });
+ using db = new Database(dbPath, { allowBareNamedParameters: false });
const setup = db.exec(
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
);
@@ -256,7 +256,7 @@ suite('DatabaseSync() constructor', () => {
test('throws if options.allowUnknownNamedParameters is provided but is not a boolean', (t) => {
t.assert.throws(() => {
- new DatabaseSync('foo', { allowUnknownNamedParameters: 42 });
+ new Database('foo', { allowUnknownNamedParameters: 42 });
}, {
code: 'ERR_INVALID_ARG_TYPE',
message: 'The "options.allowUnknownNamedParameters" argument must be a boolean.',
@@ -265,7 +265,7 @@ suite('DatabaseSync() constructor', () => {
test('allows unknown named parameters', (t) => {
const dbPath = nextDb();
- using db = new DatabaseSync(dbPath, { allowUnknownNamedParameters: true });
+ using db = new Database(dbPath, { allowUnknownNamedParameters: true });
const setup = db.exec(
'CREATE TABLE data(key INTEGER, val INTEGER) STRICT;'
);
@@ -281,17 +281,17 @@ suite('DatabaseSync() constructor', () => {
test('has sqlite-type symbol property', (t) => {
const dbPath = nextDb();
- using db = new DatabaseSync(dbPath);
+ using db = new Database(dbPath);
const sqliteTypeSymbol = Symbol.for('sqlite-type');
t.assert.strictEqual(db[sqliteTypeSymbol], 'node:sqlite');
});
});
-suite('DatabaseSync.prototype.open()', () => {
+suite('Database.prototype.open()', () => {
test('opens a database connection', (t) => {
const dbPath = nextDb();
- using db = new DatabaseSync(dbPath, { open: false });
+ using db = new Database(dbPath, { open: false });
t.assert.strictEqual(db.isOpen, false);
t.assert.strictEqual(existsSync(dbPath), false);
@@ -301,7 +301,7 @@ suite('DatabaseSync.prototype.open()', () => {
});
test('throws if database is already open', (t) => {
- using db = new DatabaseSync(nextDb(), { open: false });
+ using db = new Database(nextDb(), { open: false });
t.assert.strictEqual(db.isOpen, false);
db.open();
@@ -319,7 +319,7 @@ suite('DatabaseSync.prototype.open()', () => {
// Regression test for https://github.com/nodejs/node/issues/63831
const dbDir = join(tmpdir.path, `database-dir-${cnt++}`);
const dbPath = join(dbDir, 'failed-open.db');
- using db = new DatabaseSync(dbPath, { open: false });
+ using db = new Database(dbPath, { open: false });
// The directory does not exist, so opening the database fails.
t.assert.throws(() => {
@@ -352,9 +352,9 @@ suite('DatabaseSync.prototype.open()', () => {
});
});
-suite('DatabaseSync.prototype.close()', () => {
+suite('Database.prototype.close()', () => {
test('closes an open database connection', (t) => {
- using db = new DatabaseSync(nextDb());
+ using db = new Database(nextDb());
t.assert.strictEqual(db.isOpen, true);
t.assert.strictEqual(db.close(), undefined);
@@ -362,7 +362,7 @@ suite('DatabaseSync.prototype.close()', () => {
});
test('throws if database is not open', (t) => {
- using db = new DatabaseSync(nextDb(), { open: false });
+ using db = new Database(nextDb(), { open: false });
t.assert.strictEqual(db.isOpen, false);
t.assert.throws(() => {
@@ -375,15 +375,15 @@ suite('DatabaseSync.prototype.close()', () => {
});
});
-suite('DatabaseSync.prototype.prepare()', () => {
+suite('Database.prototype.prepare()', () => {
test('returns a prepared statement', (t) => {
- using db = new DatabaseSync(nextDb());
+ using db = new Database(nextDb());
const stmt = db.prepare('CREATE TABLE webstorage(key TEXT)');
- t.assert.ok(stmt instanceof StatementSync);
+ t.assert.ok(stmt instanceof Statement);
});
test('throws if database is not open', (t) => {
- using db = new DatabaseSync(nextDb(), { open: false });
+ using db = new Database(nextDb(), { open: false });
t.assert.throws(() => {
db.prepare();
@@ -394,7 +394,7 @@ suite('DatabaseSync.prototype.prepare()', () => {
});
test('throws if sql is not a string', (t) => {
- using db = new DatabaseSync(nextDb());
+ using db = new Database(nextDb());
t.assert.throws(() => {
db.prepare();
@@ -405,7 +405,7 @@ suite('DatabaseSync.prototype.prepare()', () => {
});
test('throws if sql contains no statements', (t) => {
- using db = new DatabaseSync(nextDb());
+ using db = new Database(nextDb());
for (const sql of ['', ' ', ';', '-- comment', '/* comment */']) {
t.assert.throws(() => {
@@ -418,7 +418,7 @@ suite('DatabaseSync.prototype.prepare()', () => {
});
test('prepares statements that contain comments', (t) => {
- using db = new DatabaseSync(nextDb());
+ using db = new Database(nextDb());
const queries = [
'-- lead\nSELECT 1 AS v',
'SELECT 1 AS v -- trail',
@@ -431,9 +431,9 @@ suite('DatabaseSync.prototype.prepare()', () => {
});
});
-suite('DatabaseSync.prototype.exec()', () => {
+suite('Database.prototype.exec()', () => {
test('executes SQL', (t) => {
- using db = new DatabaseSync(nextDb());
+ using db = new Database(nextDb());
const result = db.exec(`
CREATE TABLE data(
key INTEGER PRIMARY KEY,
@@ -451,7 +451,7 @@ suite('DatabaseSync.prototype.exec()', () => {
});
test('reports errors from SQLite', (t) => {
- using db = new DatabaseSync(nextDb());
+ using db = new Database(nextDb());
t.assert.throws(() => {
db.exec('CREATE TABLEEEE');
@@ -463,7 +463,7 @@ suite('DatabaseSync.prototype.exec()', () => {
test('throws if the URL does not have the file: scheme', (t) => {
t.assert.throws(() => {
- new DatabaseSync(new URL('http://example.com'));
+ new Database(new URL('http://example.com'));
}, {
code: 'ERR_INVALID_URL_SCHEME',
message: 'The URL must be of scheme file:',
@@ -471,7 +471,7 @@ suite('DatabaseSync.prototype.exec()', () => {
});
test('throws if database is not open', (t) => {
- using db = new DatabaseSync(nextDb(), { open: false });
+ using db = new Database(nextDb(), { open: false });
t.assert.throws(() => {
db.exec();
@@ -482,7 +482,7 @@ suite('DatabaseSync.prototype.exec()', () => {
});
test('throws if sql is not a string', (t) => {
- using db = new DatabaseSync(nextDb());
+ using db = new Database(nextDb());
t.assert.throws(() => {
db.exec();
@@ -493,9 +493,9 @@ suite('DatabaseSync.prototype.exec()', () => {
});
});
-suite('DatabaseSync.prototype.isTransaction', () => {
+suite('Database.prototype.isTransaction', () => {
test('correctly detects a committed transaction', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
t.assert.strictEqual(db.isTransaction, false);
db.exec('BEGIN');
@@ -507,7 +507,7 @@ suite('DatabaseSync.prototype.isTransaction', () => {
});
test('correctly detects a rolled back transaction', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
t.assert.strictEqual(db.isTransaction, false);
db.exec('BEGIN');
@@ -519,7 +519,7 @@ suite('DatabaseSync.prototype.isTransaction', () => {
});
test('throws if database is not open', (t) => {
- using db = new DatabaseSync(nextDb(), { open: false });
+ using db = new Database(nextDb(), { open: false });
t.assert.throws(() => {
return db.isTransaction;
@@ -530,9 +530,9 @@ suite('DatabaseSync.prototype.isTransaction', () => {
});
});
-suite('DatabaseSync.prototype.location()', () => {
+suite('Database.prototype.location()', () => {
test('throws if database is not open', (t) => {
- using db = new DatabaseSync(nextDb(), { open: false });
+ using db = new Database(nextDb(), { open: false });
t.assert.throws(() => {
db.location();
@@ -543,7 +543,7 @@ suite('DatabaseSync.prototype.location()', () => {
});
test('throws if provided dbName is not string', (t) => {
- using db = new DatabaseSync(nextDb());
+ using db = new Database(nextDb());
t.assert.throws(() => {
db.location(null);
@@ -554,20 +554,20 @@ suite('DatabaseSync.prototype.location()', () => {
});
test('returns null when connected to in-memory database', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
t.assert.strictEqual(db.location(), null);
});
test('returns db path when connected to a persistent database', (t) => {
const dbPath = nextDb();
- using db = new DatabaseSync(dbPath);
+ using db = new Database(dbPath);
t.assert.strictEqual(db.location(), dbPath);
});
test('returns that specific db path when attached', (t) => {
const dbPath = nextDb();
const otherPath = nextDb();
- using db = new DatabaseSync(dbPath);
+ using db = new Database(dbPath);
// Adding this escape because the test with unusual chars have a single quote which breaks the query
const escapedPath = otherPath.replace("'", "''");
@@ -577,16 +577,16 @@ suite('DatabaseSync.prototype.location()', () => {
});
});
-suite('DatabaseSync.prototype[Symbol.dispose]', () => {
+suite('Database.prototype[Symbol.dispose]', () => {
test('closes an open database', (t) => {
- const db = new DatabaseSync(nextDb());
+ const db = new Database(nextDb());
t.assert.strictEqual(db.isOpen, true);
db[Symbol.dispose]();
t.assert.strictEqual(db.isOpen, false);
});
test('does not throw on databases that are not open', (t) => {
- const db = new DatabaseSync(nextDb(), { open: false });
+ const db = new Database(nextDb(), { open: false });
t.assert.strictEqual(db.isOpen, false);
db[Symbol.dispose]();
});
diff --git a/test/parallel/test-sqlite-diagnostic-channel.js b/test/parallel/test-sqlite-diagnostic-channel.js
index 8b0776c969d..eb9461f337d 100644
--- a/test/parallel/test-sqlite-diagnostic-channel.js
+++ b/test/parallel/test-sqlite-diagnostic-channel.js
@@ -6,14 +6,14 @@ skipIfSQLiteMissing();
const assert = require('node:assert');
const dc = require('node:diagnostics_channel');
-const { DatabaseSync } = require('node:sqlite');
+const { Database } = require('node:sqlite');
const { suite, it } = require('node:test');
const { gcUntil } = require('../common/gc');
suite('sqlite.db.query diagnostics channel', () => {
it('subscriber receives SQL string for exec() statements', (t) => {
const calls = [];
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const handler = (msg) => calls.push(msg);
dc.subscribe('sqlite.db.query', handler);
@@ -29,7 +29,7 @@ suite('sqlite.db.query diagnostics channel', () => {
it('subscriber receives SQL string for prepared INSERT statements', (t) => {
let calls = [];
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const handler = (msg) => calls.push(msg);
dc.subscribe('sqlite.db.query', handler);
@@ -47,7 +47,7 @@ suite('sqlite.db.query diagnostics channel', () => {
it('subscriber receives SQL string for prepared SELECT statements', (t) => {
let calls = [];
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const handler = (msg) => calls.push(msg);
dc.subscribe('sqlite.db.query', handler);
@@ -66,7 +66,7 @@ suite('sqlite.db.query diagnostics channel', () => {
it('subscriber receives SQL string for prepared UPDATE statements', (t) => {
let calls = [];
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const handler = (msg) => calls.push(msg);
dc.subscribe('sqlite.db.query', handler);
@@ -85,7 +85,7 @@ suite('sqlite.db.query diagnostics channel', () => {
it('subscriber receives SQL string for prepared DELETE statements', (t) => {
let calls = [];
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const handler = (msg) => calls.push(msg);
dc.subscribe('sqlite.db.query', handler);
@@ -104,7 +104,7 @@ suite('sqlite.db.query diagnostics channel', () => {
it('no calls received after unsubscribe', (t) => {
const calls = [];
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const handler = (msg) => calls.push(msg);
dc.subscribe('sqlite.db.query', handler);
@@ -119,7 +119,7 @@ suite('sqlite.db.query diagnostics channel', () => {
it('falls back to source SQL when expansion fails', (t) => {
let calls = [];
- using db = new DatabaseSync(':memory:', { limits: { length: 1000 } });
+ using db = new Database(':memory:', { limits: { length: 1000 } });
const handler = (msg) => calls.push(msg);
dc.subscribe('sqlite.db.query', handler);
@@ -140,8 +140,8 @@ suite('sqlite.db.query diagnostics channel', () => {
it('database property identifies the correct database', (t) => {
const calls = [];
- using db1 = new DatabaseSync(':memory:');
- using db2 = new DatabaseSync(':memory:');
+ using db1 = new Database(':memory:');
+ using db2 = new Database(':memory:');
const handler = (msg) => calls.push(msg);
dc.subscribe('sqlite.db.query', handler);
@@ -158,7 +158,7 @@ suite('sqlite.db.query diagnostics channel', () => {
it('duration is a number', (t) => {
const calls = [];
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const handler = (msg) => calls.push(msg);
dc.subscribe('sqlite.db.query', handler);
@@ -172,7 +172,7 @@ suite('sqlite.db.query diagnostics channel', () => {
it('duration is non-negative', (t) => {
const calls = [];
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const handler = (msg) => calls.push(msg);
dc.subscribe('sqlite.db.query', handler);
@@ -194,7 +194,7 @@ suite('sqlite.db.query diagnostics channel', () => {
const registry = new FinalizationRegistry(() => { collected = true; });
(() => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec('CREATE TABLE t (x INTEGER)');
for (let i = 0; i < 10; i++) {
db.exec(`INSERT INTO t VALUES (${i})`);
@@ -212,7 +212,7 @@ suite('sqlite.db.query diagnostics channel', () => {
});
it('subscriber cannot close the database or statement', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec('CREATE TABLE t (x INTEGER)');
using stmt = db.prepare('INSERT INTO t VALUES (?)');
diff --git a/test/parallel/test-sqlite-limits.js b/test/parallel/test-sqlite-limits.js
index 1a038df0544..c41cbf2e773 100644
--- a/test/parallel/test-sqlite-limits.js
+++ b/test/parallel/test-sqlite-limits.js
@@ -1,12 +1,12 @@
'use strict';
const { skipIfSQLiteMissing } = require('../common');
skipIfSQLiteMissing();
-const { DatabaseSync } = require('node:sqlite');
+const { Database } = require('node:sqlite');
const { suite, test } = require('node:test');
-suite('DatabaseSync limits', () => {
+suite('Database limits', () => {
test('limits object has expected properties with positive values', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
const expectedProperties = [
'length',
'sqlLength',
@@ -30,7 +30,7 @@ suite('DatabaseSync limits', () => {
});
test('constructor accepts limits option', (t) => {
- const db = new DatabaseSync(':memory:', {
+ const db = new Database(':memory:', {
limits: {
length: 500000,
sqlLength: 50000,
@@ -60,7 +60,7 @@ suite('DatabaseSync limits', () => {
});
test('getter returns current limit value', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.assert.strictEqual(typeof db.limits.length, 'number');
t.assert.ok(db.limits.length > 0);
t.assert.strictEqual(typeof db.limits.sqlLength, 'number');
@@ -68,7 +68,7 @@ suite('DatabaseSync limits', () => {
});
test('setter modifies limit value', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.limits.length = 100000;
t.assert.strictEqual(db.limits.length, 100000);
@@ -81,7 +81,7 @@ suite('DatabaseSync limits', () => {
});
test('Infinity resets limit to maximum', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
const originalLength = db.limits.length;
// Set to a lower value
@@ -94,7 +94,7 @@ suite('DatabaseSync limits', () => {
});
test('throws on invalid argument type', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.assert.throws(() => {
db.limits.length = 'invalid';
}, {
@@ -104,7 +104,7 @@ suite('DatabaseSync limits', () => {
});
test('throws on negative value', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.assert.throws(() => {
db.limits.length = -1;
}, {
@@ -114,7 +114,7 @@ suite('DatabaseSync limits', () => {
});
test('throws on null value', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.assert.throws(() => {
db.limits.length = null;
}, {
@@ -124,7 +124,7 @@ suite('DatabaseSync limits', () => {
});
test('throws on negative Infinity', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.assert.throws(() => {
db.limits.length = -Infinity;
}, {
@@ -134,7 +134,7 @@ suite('DatabaseSync limits', () => {
});
test('throws on getter access after close', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.close();
t.assert.throws(() => {
return db.limits.length;
@@ -145,7 +145,7 @@ suite('DatabaseSync limits', () => {
});
test('throws on setter access after close', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.close();
t.assert.throws(() => {
db.limits.length = 100;
@@ -156,7 +156,7 @@ suite('DatabaseSync limits', () => {
});
test('limits object is enumerable', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
const keys = Object.keys(db.limits);
t.assert.ok(keys.includes('length'));
t.assert.ok(keys.includes('sqlLength'));
@@ -173,7 +173,7 @@ suite('DatabaseSync limits', () => {
test('throws on invalid limits option type', (t) => {
t.assert.throws(() => {
- new DatabaseSync(':memory:', { limits: 'invalid' });
+ new Database(':memory:', { limits: 'invalid' });
}, {
name: 'TypeError',
message: /options\.limits.*must be an object/,
@@ -182,7 +182,7 @@ suite('DatabaseSync limits', () => {
test('throws on invalid limit value type in constructor', (t) => {
t.assert.throws(() => {
- new DatabaseSync(':memory:', { limits: { length: 'invalid' } });
+ new Database(':memory:', { limits: { length: 'invalid' } });
}, {
name: 'TypeError',
message: /options\.limits\.length.*must be an integer/,
@@ -191,7 +191,7 @@ suite('DatabaseSync limits', () => {
test('throws on negative limit value in constructor', (t) => {
t.assert.throws(() => {
- new DatabaseSync(':memory:', { limits: { length: -100 } });
+ new Database(':memory:', { limits: { length: -100 } });
}, {
name: 'RangeError',
message: /options\.limits\.length.*must be non-negative/,
@@ -200,7 +200,7 @@ suite('DatabaseSync limits', () => {
test('throws on Infinity limit value in constructor', (t) => {
t.assert.throws(() => {
- new DatabaseSync(':memory:', { limits: { length: Infinity } });
+ new Database(':memory:', { limits: { length: Infinity } });
}, {
name: 'TypeError',
message: /options\.limits\.length.*must be an integer/,
@@ -208,7 +208,7 @@ suite('DatabaseSync limits', () => {
});
test('partial limits in constructor', (t) => {
- const db = new DatabaseSync(':memory:', {
+ const db = new Database(':memory:', {
limits: {
length: 100000,
}
@@ -218,7 +218,7 @@ suite('DatabaseSync limits', () => {
});
test('throws when exceeding column limit', (t) => {
- const db = new DatabaseSync(':memory:', {
+ const db = new Database(':memory:', {
limits: {
column: 10,
}
@@ -234,7 +234,7 @@ suite('DatabaseSync limits', () => {
});
test('throws when exceeding attach limit', (t) => {
- const db = new DatabaseSync(':memory:', {
+ const db = new Database(':memory:', {
limits: {
attach: 0,
}
@@ -248,7 +248,7 @@ suite('DatabaseSync limits', () => {
});
test('throws when exceeding variable number limit', (t) => {
- const db = new DatabaseSync(':memory:', {
+ const db = new Database(':memory:', {
limits: {
variableNumber: 2,
}
@@ -263,7 +263,7 @@ suite('DatabaseSync limits', () => {
});
test('throws when exceeding compound select limit', (t) => {
- const db = new DatabaseSync(':memory:', {
+ const db = new Database(':memory:', {
limits: {
compoundSelect: 1,
}
@@ -277,7 +277,7 @@ suite('DatabaseSync limits', () => {
});
test('throws when exceeding function arg limit', (t) => {
- const db = new DatabaseSync(':memory:', {
+ const db = new Database(':memory:', {
limits: {
functionArg: 2,
}
@@ -291,7 +291,7 @@ suite('DatabaseSync limits', () => {
});
test('setter applies limit to SQLite immediately', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.limits.attach = 0;
diff --git a/test/parallel/test-sqlite-named-parameters.js b/test/parallel/test-sqlite-named-parameters.js
index fd0a209b6b0..30fb034c4f3 100644
--- a/test/parallel/test-sqlite-named-parameters.js
+++ b/test/parallel/test-sqlite-named-parameters.js
@@ -1,12 +1,12 @@
'use strict';
const { skipIfSQLiteMissing } = require('../common');
skipIfSQLiteMissing();
-const { DatabaseSync } = require('node:sqlite');
+const { Database } = require('node:sqlite');
const { suite, test } = require('node:test');
suite('named parameters', () => {
test('throws on unknown named parameters', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => { db.close(); });
const setup = db.exec(
'CREATE TABLE types(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
@@ -23,7 +23,7 @@ suite('named parameters', () => {
});
test('bare named parameters are supported', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => { db.close(); });
const setup = db.exec(
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
@@ -38,7 +38,7 @@ suite('named parameters', () => {
});
test('duplicate bare named parameters are supported', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => { db.close(); });
const setup = db.exec(
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
@@ -53,7 +53,7 @@ suite('named parameters', () => {
});
test('bare named parameters throw on ambiguous names', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => { db.close(); });
const setup = db.exec(
'CREATE TABLE types(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
@@ -70,9 +70,9 @@ suite('named parameters', () => {
});
});
-suite('StatementSync.prototype.setAllowUnknownNamedParameters()', () => {
+suite('Statement.prototype.setAllowUnknownNamedParameters()', () => {
test('unknown named parameter support can be toggled', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => { db.close(); });
const setup = db.exec(
'CREATE TABLE data(key INTEGER, val INTEGER) STRICT;'
@@ -95,7 +95,7 @@ suite('StatementSync.prototype.setAllowUnknownNamedParameters()', () => {
});
test('throws when input is not a boolean', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => { db.close(); });
const setup = db.exec(
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
@@ -111,7 +111,7 @@ suite('StatementSync.prototype.setAllowUnknownNamedParameters()', () => {
});
test('throws if the statement is already finalized', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
);
@@ -129,7 +129,7 @@ suite('StatementSync.prototype.setAllowUnknownNamedParameters()', () => {
suite('options.allowUnknownNamedParameters', () => {
test('unknown named parameters are allowed when input is true', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => { db.close(); });
const setup = db.exec(
'CREATE TABLE data(key INTEGER, val INTEGER) STRICT;'
@@ -147,7 +147,7 @@ suite('options.allowUnknownNamedParameters', () => {
});
test('unknown named parameters throw when input is false', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => { db.close(); });
const setup = db.exec(
'CREATE TABLE data(key INTEGER, val INTEGER) STRICT;'
@@ -167,7 +167,7 @@ suite('options.allowUnknownNamedParameters', () => {
});
test('unknown named parameters throws error by default', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => { db.close(); });
const setup = db.exec(
'CREATE TABLE data(key INTEGER, val INTEGER) STRICT;'
@@ -184,7 +184,7 @@ suite('options.allowUnknownNamedParameters', () => {
});
test('throws when option is not a boolean', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => { db.close(); });
const setup = db.exec(
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
@@ -202,7 +202,7 @@ suite('options.allowUnknownNamedParameters', () => {
});
test('setAllowUnknownNamedParameters can override prepare option', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => { db.close(); });
const setup = db.exec(
'CREATE TABLE data(key INTEGER, val INTEGER) STRICT;'
diff --git a/test/parallel/test-sqlite-options-getter-reentry.js b/test/parallel/test-sqlite-options-getter-reentry.js
index 99df02e4d2c..abb84535825 100644
--- a/test/parallel/test-sqlite-options-getter-reentry.js
+++ b/test/parallel/test-sqlite-options-getter-reentry.js
@@ -3,7 +3,7 @@ const { skipIfSQLiteMissing } = require('../common');
skipIfSQLiteMissing();
const tmpdir = require('../common/tmpdir');
const { join } = require('node:path');
-const { backup, DatabaseSync } = require('node:sqlite');
+const { backup, Database } = require('node:sqlite');
const { suite, test } = require('node:test');
tmpdir.refresh();
@@ -18,7 +18,7 @@ const invalidState = {
// the time it is used.
suite('closing the database from an options getter', () => {
test('prepare() throws instead of using a closed connection', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.assert.throws(() => {
db.prepare('SELECT 1', {
get returnArrays() {
@@ -30,7 +30,7 @@ suite('closing the database from an options getter', () => {
});
test('function() throws instead of using a closed connection', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.assert.throws(() => {
db.function('fn', {
get useBigIntArguments() {
@@ -42,7 +42,7 @@ suite('closing the database from an options getter', () => {
});
test('function() throws when the length getter closes the database', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
const fn = () => 1;
Object.defineProperty(fn, 'length', {
configurable: true,
@@ -57,7 +57,7 @@ suite('closing the database from an options getter', () => {
});
test('aggregate() throws instead of using a closed connection', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.assert.throws(() => {
db.aggregate('agg', {
get start() {
@@ -70,7 +70,7 @@ suite('closing the database from an options getter', () => {
});
test('aggregate() throws when the length getter closes the database', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
const step = (acc, value) => acc;
Object.defineProperty(step, 'length', {
configurable: true,
@@ -85,7 +85,7 @@ suite('closing the database from an options getter', () => {
});
test('createModule() throws instead of using a closed connection', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.assert.throws(() => {
db.createModule('mod', {
columns: [{ name: 'value', type: 'INTEGER' }],
@@ -101,7 +101,7 @@ suite('closing the database from an options getter', () => {
});
test('createModule() throws when a column getter closes the database', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.assert.throws(() => {
db.createModule('mod', {
columns: [{
@@ -119,11 +119,11 @@ suite('closing the database from an options getter', () => {
});
test('deserialize() throws instead of using a closed connection', (t) => {
- const source = new DatabaseSync(':memory:');
+ const source = new Database(':memory:');
source.exec('CREATE TABLE data(value TEXT)');
const image = source.serialize();
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.assert.throws(() => {
db.deserialize(image, {
get dbName() {
@@ -135,7 +135,7 @@ suite('closing the database from an options getter', () => {
});
test('createSession() throws instead of using a closed connection', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.assert.throws(() => {
db.createSession({
get db() {
@@ -147,7 +147,7 @@ suite('closing the database from an options getter', () => {
});
test('applyChangeset() throws instead of using a closed connection', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec('CREATE TABLE data(key INTEGER PRIMARY KEY)');
const session = db.createSession();
db.exec('INSERT INTO data (key) VALUES (1)');
@@ -164,7 +164,7 @@ suite('closing the database from an options getter', () => {
});
test('backup() throws instead of using a closed connection', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.assert.throws(() => {
backup(db, join(tmpdir.path, 'getter-backup.db'), {
get rate() {
@@ -179,7 +179,7 @@ suite('closing the database from an options getter', () => {
// The state check runs before the options bag is read, so a call that is
// already doomed must not execute any of the caller's getters.
test('options getters do not run on an already-closed database', (t) => {
- const source = new DatabaseSync(':memory:');
+ const source = new Database(':memory:');
source.exec('CREATE TABLE data(key INTEGER PRIMARY KEY)');
const image = source.serialize();
const session = source.createSession();
@@ -211,7 +211,7 @@ test('options getters do not run on an already-closed database', (t) => {
};
for (const [name, invoke] of Object.entries(cases)) {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.close();
const [key, value] = probes[name];
@@ -230,7 +230,7 @@ test('options getters do not run on an already-closed database', (t) => {
suite('resizing a deserialize() buffer from an options getter', () => {
test('throws rather than handing uninitialized memory to SQLite', (t) => {
- const source = new DatabaseSync(':memory:');
+ const source = new Database(':memory:');
source.exec('CREATE TABLE data(value TEXT)');
source.prepare('INSERT INTO data (value) VALUES (?)').run('hello');
const image = source.serialize();
@@ -240,7 +240,7 @@ suite('resizing a deserialize() buffer from an options getter', () => {
});
new Uint8Array(buffer).set(image);
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.assert.throws(() => {
db.deserialize(new Uint8Array(buffer), {
get dbName() {
@@ -255,14 +255,14 @@ suite('resizing a deserialize() buffer from an options getter', () => {
});
test('throws when the buffer is detached', (t) => {
- const source = new DatabaseSync(':memory:');
+ const source = new Database(':memory:');
source.exec('CREATE TABLE data(value TEXT)');
const image = source.serialize();
const buffer = new ArrayBuffer(image.byteLength);
new Uint8Array(buffer).set(image);
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.assert.throws(() => {
db.deserialize(new Uint8Array(buffer), {
get dbName() {
diff --git a/test/parallel/test-sqlite-serialize.js b/test/parallel/test-sqlite-serialize.js
index e54cfa3c6a7..29e02699cb0 100644
--- a/test/parallel/test-sqlite-serialize.js
+++ b/test/parallel/test-sqlite-serialize.js
@@ -1,12 +1,12 @@
'use strict';
const { skipIfSQLiteMissing } = require('../common');
skipIfSQLiteMissing();
-const { DatabaseSync } = require('node:sqlite');
+const { Database } = require('node:sqlite');
const { suite, test } = require('node:test');
-suite('DatabaseSync.prototype.serialize()', () => {
+suite('Database.prototype.serialize()', () => {
test('returns a Uint8Array with the SQLite header', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
const buf = db.serialize();
t.assert.ok(buf instanceof Uint8Array);
t.assert.ok(buf.length > 0);
@@ -16,7 +16,7 @@ suite('DatabaseSync.prototype.serialize()', () => {
});
test('serializes an empty database', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
const buf = db.serialize();
t.assert.ok(buf instanceof Uint8Array);
t.assert.ok(buf.length > 0);
@@ -24,7 +24,7 @@ suite('DatabaseSync.prototype.serialize()', () => {
});
test('serializes a database with data', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec('CREATE TABLE t(id INTEGER PRIMARY KEY, name TEXT)');
db.exec("INSERT INTO t VALUES (1, 'hello')");
db.exec("INSERT INTO t VALUES (2, 'world')");
@@ -34,7 +34,7 @@ suite('DatabaseSync.prototype.serialize()', () => {
});
test('throws if the database is not open', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.close();
t.assert.throws(() => {
db.serialize();
@@ -45,7 +45,7 @@ suite('DatabaseSync.prototype.serialize()', () => {
});
test('throws if dbName is not a string', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.assert.throws(() => {
db.serialize(123);
}, {
@@ -56,7 +56,7 @@ suite('DatabaseSync.prototype.serialize()', () => {
});
test('accepts a schema name argument', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
const buf = db.serialize('main');
t.assert.ok(buf instanceof Uint8Array);
t.assert.ok(buf.length > 0);
@@ -64,7 +64,7 @@ suite('DatabaseSync.prototype.serialize()', () => {
});
test('serializes an attached schema when dbName is provided', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec("ATTACH DATABASE ':memory:' AS aux");
db.exec('CREATE TABLE aux.t(value TEXT)');
db.exec("INSERT INTO aux.t VALUES ('from aux')");
@@ -72,7 +72,7 @@ suite('DatabaseSync.prototype.serialize()', () => {
const buf = db.serialize('aux');
db.close();
- const clone = new DatabaseSync(':memory:');
+ const clone = new Database(':memory:');
clone.deserialize(buf);
const row = clone.prepare('SELECT value FROM t').get();
@@ -81,16 +81,16 @@ suite('DatabaseSync.prototype.serialize()', () => {
});
});
-suite('DatabaseSync.prototype.deserialize()', () => {
+suite('Database.prototype.deserialize()', () => {
test('loads a serialized database', (t) => {
- const db1 = new DatabaseSync(':memory:');
+ const db1 = new Database(':memory:');
db1.exec('CREATE TABLE t(id INTEGER PRIMARY KEY, name TEXT)');
db1.exec("INSERT INTO t VALUES (1, 'hello')");
db1.exec("INSERT INTO t VALUES (2, 'world')");
const buf = db1.serialize();
db1.close();
- const db2 = new DatabaseSync(':memory:');
+ const db2 = new Database(':memory:');
db2.deserialize(buf);
const rows = db2.prepare('SELECT * FROM t ORDER BY id').all();
t.assert.strictEqual(rows.length, 2);
@@ -100,13 +100,13 @@ suite('DatabaseSync.prototype.deserialize()', () => {
});
test('replaces existing data in the connection', (t) => {
- const db1 = new DatabaseSync(':memory:');
+ const db1 = new Database(':memory:');
db1.exec('CREATE TABLE src(val TEXT)');
db1.exec("INSERT INTO src VALUES ('from source')");
const buf = db1.serialize();
db1.close();
- const db2 = new DatabaseSync(':memory:');
+ const db2 = new Database(':memory:');
db2.exec('CREATE TABLE old(x INTEGER)');
db2.exec('INSERT INTO old VALUES (999)');
db2.deserialize(buf);
@@ -123,13 +123,13 @@ suite('DatabaseSync.prototype.deserialize()', () => {
test('finalizes existing prepared statements before replacing the database',
(t) => {
- const db1 = new DatabaseSync(':memory:');
+ const db1 = new Database(':memory:');
db1.exec('CREATE TABLE replacement(value TEXT)');
db1.exec("INSERT INTO replacement VALUES ('new')");
const buf = db1.serialize();
db1.close();
- const db2 = new DatabaseSync(':memory:');
+ const db2 = new Database(':memory:');
db2.exec('CREATE TABLE original(value TEXT)');
db2.exec("INSERT INTO original VALUES ('old')");
const stmt = db2.prepare('SELECT value FROM original');
@@ -148,12 +148,12 @@ suite('DatabaseSync.prototype.deserialize()', () => {
});
test('deserialized database is writable by default', (t) => {
- const db1 = new DatabaseSync(':memory:');
+ const db1 = new Database(':memory:');
db1.exec('CREATE TABLE t(id INTEGER PRIMARY KEY)');
const buf = db1.serialize();
db1.close();
- const db2 = new DatabaseSync(':memory:');
+ const db2 = new Database(':memory:');
db2.deserialize(buf);
db2.exec('INSERT INTO t VALUES (1)');
const rows = db2.prepare('SELECT * FROM t').all();
@@ -162,14 +162,14 @@ suite('DatabaseSync.prototype.deserialize()', () => {
});
test('round-trip serialize then deserialize preserves data', (t) => {
- const db1 = new DatabaseSync(':memory:');
+ const db1 = new Database(':memory:');
db1.exec('CREATE TABLE t(a TEXT, b REAL, c BLOB)');
db1.prepare('INSERT INTO t VALUES (?, ?, ?)').run(
'text', 3.14, new Uint8Array([1, 2, 3])
);
const buf = db1.serialize();
- const db2 = new DatabaseSync(':memory:');
+ const db2 = new Database(':memory:');
db2.deserialize(buf);
const row = db2.prepare('SELECT * FROM t').get();
t.assert.strictEqual(row.a, 'text');
@@ -180,7 +180,7 @@ suite('DatabaseSync.prototype.deserialize()', () => {
});
test('throws if the database is not open', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.close();
t.assert.throws(() => {
db.deserialize(new Uint8Array(0));
@@ -191,11 +191,11 @@ suite('DatabaseSync.prototype.deserialize()', () => {
});
test('throws if called while in a callback', (t) => {
- const source = new DatabaseSync(':memory:');
+ const source = new Database(':memory:');
const serialized = source.serialize();
source.close();
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => db.close());
db.function('deserialize_database', () => db.deserialize(serialized));
const stmt = db.prepare('SELECT deserialize_database()');
@@ -208,7 +208,7 @@ suite('DatabaseSync.prototype.deserialize()', () => {
});
test('throws if buffer argument is not a Uint8Array', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.assert.throws(() => {
db.deserialize('not a buffer');
}, {
@@ -219,7 +219,7 @@ suite('DatabaseSync.prototype.deserialize()', () => {
});
test('throws if buffer is empty', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.assert.throws(() => {
db.deserialize(new Uint8Array(0));
}, {
@@ -230,7 +230,7 @@ suite('DatabaseSync.prototype.deserialize()', () => {
});
test('throws if options is not an object', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.assert.throws(() => {
db.deserialize(new Uint8Array(1), 'bad');
}, {
@@ -241,7 +241,7 @@ suite('DatabaseSync.prototype.deserialize()', () => {
});
test('throws if options.dbName is not a string', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.assert.throws(() => {
db.deserialize(new Uint8Array(1), { dbName: 1 });
}, {
@@ -252,13 +252,13 @@ suite('DatabaseSync.prototype.deserialize()', () => {
});
test('accepts a Buffer as input', (t) => {
- const db1 = new DatabaseSync(':memory:');
+ const db1 = new Database(':memory:');
db1.exec('CREATE TABLE t(x INTEGER)');
db1.exec('INSERT INTO t VALUES (42)');
const buf = Buffer.from(db1.serialize());
db1.close();
- const db2 = new DatabaseSync(':memory:');
+ const db2 = new Database(':memory:');
db2.deserialize(buf);
const row = db2.prepare('SELECT * FROM t').get();
t.assert.strictEqual(row.x, 42);
@@ -266,19 +266,19 @@ suite('DatabaseSync.prototype.deserialize()', () => {
});
test('multiple deserialize calls on the same connection', (t) => {
- const db1 = new DatabaseSync(':memory:');
+ const db1 = new Database(':memory:');
db1.exec('CREATE TABLE a(x)');
db1.exec("INSERT INTO a VALUES ('first')");
const buf1 = db1.serialize();
db1.close();
- const db2 = new DatabaseSync(':memory:');
+ const db2 = new Database(':memory:');
db2.exec('CREATE TABLE b(x)');
db2.exec("INSERT INTO b VALUES ('second')");
const buf2 = db2.serialize();
db2.close();
- const db3 = new DatabaseSync(':memory:');
+ const db3 = new Database(':memory:');
db3.deserialize(buf1);
t.assert.strictEqual(
db3.prepare('SELECT x FROM a').get().x, 'first'
@@ -295,14 +295,14 @@ suite('DatabaseSync.prototype.deserialize()', () => {
});
test('loads into an attached schema when options.dbName is provided', (t) => {
- const db1 = new DatabaseSync(':memory:');
+ const db1 = new Database(':memory:');
db1.exec("ATTACH DATABASE ':memory:' AS aux");
db1.exec('CREATE TABLE aux.t(value TEXT)');
db1.exec("INSERT INTO aux.t VALUES ('from aux')");
const buf = db1.serialize('aux');
db1.close();
- const db2 = new DatabaseSync(':memory:');
+ const db2 = new Database(':memory:');
db2.exec('CREATE TABLE main_t(value TEXT)');
db2.exec("INSERT INTO main_t VALUES ('from main')");
db2.exec("ATTACH DATABASE ':memory:' AS aux");
diff --git a/test/parallel/test-sqlite-session.js b/test/parallel/test-sqlite-session.js
index 40da13c4bb7..e5a478e1706 100644
--- a/test/parallel/test-sqlite-session.js
+++ b/test/parallel/test-sqlite-session.js
@@ -3,7 +3,7 @@
const { skipIfSQLiteMissing } = require('../common');
skipIfSQLiteMissing();
const {
- DatabaseSync,
+ Database,
constants,
} = require('node:sqlite');
const { it, test, suite } = require('node:test');
@@ -36,7 +36,7 @@ test('creating and applying a changeset', (t) => {
) STRICT`;
const createDatabase = () => {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
database.exec(createDataTableSql);
return database;
};
@@ -60,7 +60,7 @@ test('creating and applying a changeset', (t) => {
});
test('database.createSession() - closed database results in exception', (t) => {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
database.close();
t.assert.throws(() => {
database.createSession();
@@ -71,7 +71,7 @@ test('database.createSession() - closed database results in exception', (t) => {
});
test('session.changeset() - closed database results in exception', (t) => {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
const session = database.createSession();
database.close();
t.assert.throws(() => {
@@ -84,7 +84,7 @@ test('session.changeset() - closed database results in exception', (t) => {
test('session methods - reopened database results in exception', (t) => {
for (const method of ['changeset', 'close']) {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
const session = database.createSession();
database.close();
database.open();
@@ -99,7 +99,7 @@ test('session methods - reopened database results in exception', (t) => {
});
test('database.applyChangeset() - closed database results in exception', (t) => {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
const session = database.createSession();
const changeset = session.changeset();
database.close();
@@ -112,8 +112,8 @@ test('database.applyChangeset() - closed database results in exception', (t) =>
});
test('database.createSession() - use table option to track specific table', (t) => {
- const database1 = new DatabaseSync(':memory:');
- const database2 = new DatabaseSync(':memory:');
+ const database1 = new Database(':memory:');
+ const database2 = new Database(':memory:');
const createData1TableSql = `CREATE TABLE data1 (
key INTEGER PRIMARY KEY,
@@ -156,8 +156,8 @@ suite('conflict resolution', () => {
) STRICT`;
const prepareConflict = () => {
- const database1 = new DatabaseSync(':memory:');
- const database2 = new DatabaseSync(':memory:');
+ const database1 = new Database(':memory:');
+ const database2 = new Database(':memory:');
database1.exec(createDataTableSql);
database2.exec(createDataTableSql);
@@ -174,8 +174,8 @@ suite('conflict resolution', () => {
};
const prepareDataConflict = () => {
- const database1 = new DatabaseSync(':memory:');
- const database2 = new DatabaseSync(':memory:');
+ const database1 = new Database(':memory:');
+ const database2 = new Database(':memory:');
database1.exec(createDataTableSql);
database2.exec(createDataTableSql);
@@ -192,8 +192,8 @@ suite('conflict resolution', () => {
};
const prepareNotFoundConflict = () => {
- const database1 = new DatabaseSync(':memory:');
- const database2 = new DatabaseSync(':memory:');
+ const database1 = new Database(':memory:');
+ const database2 = new Database(':memory:');
database1.exec(createDataTableSql);
database2.exec(createDataTableSql);
@@ -209,8 +209,8 @@ suite('conflict resolution', () => {
};
const prepareFkConflict = () => {
- const database1 = new DatabaseSync(':memory:');
- const database2 = new DatabaseSync(':memory:');
+ const database1 = new Database(':memory:');
+ const database2 = new Database(':memory:');
database1.exec(createDataTableSql);
database2.exec(createDataTableSql);
@@ -240,8 +240,8 @@ suite('conflict resolution', () => {
};
const prepareConstraintConflict = () => {
- const database1 = new DatabaseSync(':memory:');
- const database2 = new DatabaseSync(':memory:');
+ const database1 = new Database(':memory:');
+ const database2 = new Database(':memory:');
database1.exec(createDataTableSql);
database2.exec(createDataTableSql);
@@ -403,8 +403,8 @@ suite('conflict resolution', () => {
});
test('filter handler throws', (t) => {
- const database1 = new DatabaseSync(':memory:');
- const database2 = new DatabaseSync(':memory:');
+ const database1 = new Database(':memory:');
+ const database2 = new Database(':memory:');
const createTableSql = 'CREATE TABLE data1(key INTEGER PRIMARY KEY); CREATE TABLE data2(key INTEGER PRIMARY KEY);';
database1.exec(createTableSql);
database2.exec(createTableSql);
@@ -434,8 +434,8 @@ test('filter handler throws', (t) => {
});
test('database.applyChangeset() - changeset detached by filter', (t) => {
- const database1 = new DatabaseSync(':memory:');
- const database2 = new DatabaseSync(':memory:');
+ const database1 = new Database(':memory:');
+ const database2 = new Database(':memory:');
database1.exec('CREATE TABLE data(key INTEGER PRIMARY KEY)');
database2.exec('CREATE TABLE data(key INTEGER PRIMARY KEY)');
@@ -463,8 +463,8 @@ test('database.applyChangeset() - changeset detached by filter', (t) => {
});
test('database.applyChangeset() - changeset detached by SQL function', (t) => {
- const database1 = new DatabaseSync(':memory:');
- const database2 = new DatabaseSync(':memory:');
+ const database1 = new Database(':memory:');
+ const database2 = new Database(':memory:');
let changeset;
let detached = false;
@@ -499,8 +499,8 @@ test('database.applyChangeset() - changeset detached by SQL function', (t) => {
});
test('database.createSession() - filter changes', (t) => {
- const database1 = new DatabaseSync(':memory:');
- const database2 = new DatabaseSync(':memory:');
+ const database1 = new Database(':memory:');
+ const database2 = new Database(':memory:');
const createTableSql = 'CREATE TABLE data1(key INTEGER PRIMARY KEY); CREATE TABLE data2(key INTEGER PRIMARY KEY);';
database1.exec(createTableSql);
database2.exec(createTableSql);
@@ -524,7 +524,7 @@ test('database.createSession() - filter changes', (t) => {
});
test('database.createSession() - specify other database', (t) => {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
const session = database.createSession();
const sessionMain = database.createSession({
db: 'main'
@@ -541,7 +541,7 @@ test('database.createSession() - specify other database', (t) => {
});
test('database.createSession() - wrong arguments', (t) => {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
t.assert.throws(() => {
database.createSession(null);
}, {
@@ -569,7 +569,7 @@ test('database.createSession() - wrong arguments', (t) => {
});
test('database.applyChangeset() - wrong arguments', (t) => {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
const session = database.createSession();
t.assert.throws(() => {
database.applyChangeset(null);
@@ -608,7 +608,7 @@ test('database.applyChangeset() - malformed changeset returns SQLITE_CORRUPT', {
skip: process.config.variables.node_shared_sqlite ?
'requires the bundled SQLite session fix' : false,
}, (t) => {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
database.exec('CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c, d)');
const changeset = Buffer.from(
@@ -626,7 +626,7 @@ test('database.applyChangeset() - malformed changeset returns SQLITE_CORRUPT', {
});
test('session.patchset()', (t) => {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
database.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
database.exec("INSERT INTO data VALUES ('1', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.')");
@@ -649,7 +649,7 @@ test('session.patchset()', (t) => {
});
test('session.close() - using session after close throws exception', (t) => {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
database.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
database.exec("INSERT INTO data VALUES ('1', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.')");
@@ -668,7 +668,7 @@ test('session.close() - using session after close throws exception', (t) => {
});
test('session.close() - after closing database throws exception', (t) => {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
database.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
database.exec("INSERT INTO data VALUES ('1', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.')");
@@ -685,7 +685,7 @@ test('session.close() - after closing database throws exception', (t) => {
});
test('session.close() - closing twice', (t) => {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
const session = database.createSession();
session.close();
@@ -700,7 +700,7 @@ test('session.close() - closing twice', (t) => {
test('session close and dispose - while generating changes throws exception', (t) => {
for (const close of ['close', Symbol.dispose]) {
for (const method of ['changeset', 'patchset']) {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
database.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
const session = database.createSession({ table: 'data' });
@@ -722,7 +722,7 @@ test('session close and dispose - while generating changes throws exception', (t
});
test('session[Symbol.dispose]() - closed session is a no-op', () => {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
const session = database.createSession();
session.close();
@@ -730,7 +730,7 @@ test('session[Symbol.dispose]() - closed session is a no-op', () => {
});
test('session[Symbol.dispose]() - after closing database is a no-op', () => {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
const session = database.createSession();
database.close();
@@ -755,7 +755,7 @@ suite('session.close() - from a callback', () => {
};
it(`rejects ${method} from an authorizer callback`, (t) => {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
database.exec('CREATE TABLE data(key INTEGER PRIMARY KEY)');
const session = database.createSession();
let outcome = 'callback did not run';
@@ -782,7 +782,7 @@ suite('session.close() - from a callback', () => {
});
it(`rejects ${method} from a 'sqlite.db.query' subscriber`, (t) => {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
database.exec('CREATE TABLE data(key INTEGER PRIMARY KEY)');
const session = database.createSession();
let outcome = 'callback did not run';
@@ -813,7 +813,7 @@ suite('session.close() - from a callback', () => {
// is inside that hook, so every callback is rejected. This pins the
// trade-off rather than leaving it to be discovered as a regression.
it(`rejects ${method} from a user-defined function`, (t) => {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
database.exec('CREATE TABLE data(key INTEGER PRIMARY KEY)');
const session = database.createSession();
let outcome = 'callback did not run';
@@ -839,10 +839,10 @@ suite('session.close() - from a callback', () => {
// Rejecting disposal has a cost: a `using` declaration inside a callback
// demotes the block's own error to SuppressedError. Accepted for symmetry
- // with StatementSync's disposal, which throws for a busy statement the same
+ // with Statement's disposal, which throws for a busy statement the same
// way. Pinned here so the trade-off is visible rather than surprising.
it('demotes a callback error when disposal is rejected', (t) => {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
database.exec('CREATE TABLE data(key INTEGER PRIMARY KEY)');
let caught;
@@ -867,7 +867,7 @@ suite('session.close() - from a callback', () => {
});
it('leaves an already closed session disposable from a callback', (t) => {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
database.exec('CREATE TABLE data(key INTEGER PRIMARY KEY)');
const session = database.createSession();
session.close();
@@ -891,11 +891,11 @@ suite('session.close() - from a callback', () => {
test('session - keeps its database alive after the db handle is dropped', async (t) => {
const { gcUntil, onGC } = require('../common/gc');
- // The DatabaseSync handle is created in a nested scope and never referenced
+ // The Database handle is created in a nested scope and never referenced
// again, so the returned session is the only thing keeping it reachable.
let dbCollected = false;
const session = (() => {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
database.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
onGC(database, { ongc: () => { dbCollected = true; } });
const s = database.createSession();
@@ -923,7 +923,7 @@ test('session - keeps its database alive after the db handle is dropped', async
// GC during a callback that the PRAGMA triggers could collect a session that
// JavaScript no longer references and free memory the walk is still using.
test('session - survives GC during an authorizer callback', (t) => {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
database.exec('CREATE TABLE data(key INTEGER PRIMARY KEY)');
database.createSession(); // Never referenced again, so it is collectable.
@@ -943,7 +943,7 @@ test('session - survives GC during an authorizer callback', (t) => {
test("session - survives GC during a 'sqlite.db.query' subscriber", (t) => {
const dc = require('node:diagnostics_channel');
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
database.exec('CREATE TABLE data(key INTEGER PRIMARY KEY)');
database.createSession(); // Never referenced again, so it is collectable.
@@ -963,7 +963,7 @@ test("session - survives GC during a 'sqlite.db.query' subscriber", (t) => {
});
test('session supports ERM', (t) => {
- const database = new DatabaseSync(':memory:');
+ const database = new Database(':memory:');
let afterDisposeSession;
{
using session = database.createSession();
@@ -988,8 +988,8 @@ test('concurrent applyChangeset with workers', async (t) => {
}
const dbPath = nextDb();
- const db1 = new DatabaseSync(dbPath);
- const db2 = new DatabaseSync(':memory:');
+ const db1 = new Database(dbPath);
+ const db2 = new Database(':memory:');
const createTable = `
CREATE TABLE data(
key INTEGER PRIMARY KEY,
diff --git a/test/parallel/test-sqlite-statement-binding-reentry.js b/test/parallel/test-sqlite-statement-binding-reentry.js
index 052803e72a8..2ac911d5b19 100644
--- a/test/parallel/test-sqlite-statement-binding-reentry.js
+++ b/test/parallel/test-sqlite-statement-binding-reentry.js
@@ -4,7 +4,7 @@ const { skipIfSQLiteMissing, mustCall } = require('../common');
skipIfSQLiteMissing();
const assert = require('node:assert');
const { test } = require('node:test');
-const { DatabaseSync } = require('node:sqlite');
+const { Database } = require('node:sqlite');
const reentryError = {
code: 'ERR_INVALID_STATE',
@@ -17,7 +17,7 @@ const reentryError = {
// hands out a second iterator over one virtual machine.
for (const method of ['all', 'get', 'run', 'iterate']) {
test(`${method}() reentry during parameter binding is rejected`, () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec(`
CREATE TABLE data (value INTEGER);
INSERT INTO data VALUES (1), (2), (3);
@@ -39,7 +39,7 @@ for (const method of ['all', 'get', 'run', 'iterate']) {
}
test('two iterators cannot share one virtual machine', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec(`
CREATE TABLE data (value INTEGER);
INSERT INTO data VALUES (1), (2), (3);
diff --git a/test/parallel/test-sqlite-statement-sync-columns.js b/test/parallel/test-sqlite-statement-columns.js
similarity index 90%
rename from test/parallel/test-sqlite-statement-sync-columns.js
rename to test/parallel/test-sqlite-statement-columns.js
index a0c3fbd7434..886e3aba9a8 100644
--- a/test/parallel/test-sqlite-statement-sync-columns.js
+++ b/test/parallel/test-sqlite-statement-columns.js
@@ -2,12 +2,12 @@
const { skipIfSQLiteMissing } = require('../common');
skipIfSQLiteMissing();
const assert = require('node:assert');
-const { DatabaseSync } = require('node:sqlite');
+const { Database } = require('node:sqlite');
const { suite, test } = require('node:test');
-suite('StatementSync.prototype.columns()', () => {
+suite('Statement.prototype.columns()', () => {
test('returns column metadata for core SQLite types', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec(`CREATE TABLE test (
col1 INTEGER,
col2 REAL,
@@ -61,7 +61,7 @@ suite('StatementSync.prototype.columns()', () => {
});
test('supports statements using multiple tables', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec(`
CREATE TABLE test1 (value1 INTEGER);
CREATE TABLE test2 (value2 INTEGER);
@@ -88,7 +88,7 @@ suite('StatementSync.prototype.columns()', () => {
});
test('supports column aliases', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec(`CREATE TABLE test (value INTEGER)`);
const stmt = db.prepare('SELECT value AS foo FROM test');
assert.deepStrictEqual(stmt.columns(), [
@@ -104,7 +104,7 @@ suite('StatementSync.prototype.columns()', () => {
});
test('supports column expressions', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec(`CREATE TABLE test (value INTEGER)`);
const stmt = db.prepare('SELECT value + 1, value FROM test');
assert.deepStrictEqual(stmt.columns(), [
@@ -128,7 +128,7 @@ suite('StatementSync.prototype.columns()', () => {
});
test('supports subqueries', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec(`CREATE TABLE test (value INTEGER)`);
const stmt = db.prepare('SELECT * FROM (SELECT * FROM test)');
assert.deepStrictEqual(stmt.columns(), [
@@ -144,14 +144,14 @@ suite('StatementSync.prototype.columns()', () => {
});
test('supports statements that do not return data', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec('CREATE TABLE test (value INTEGER)');
const stmt = db.prepare('INSERT INTO test (value) VALUES (?)');
assert.deepStrictEqual(stmt.columns(), []);
});
test('throws if the statement is finalized', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec('CREATE TABLE test (value INTEGER)');
const stmt = db.prepare('SELECT value FROM test');
db.close();
diff --git a/test/parallel/test-sqlite-statement-sync.js b/test/parallel/test-sqlite-statement.js
similarity index 89%
rename from test/parallel/test-sqlite-statement-sync.js
rename to test/parallel/test-sqlite-statement.js
index 44eb482f9bd..8fac6f4ff50 100644
--- a/test/parallel/test-sqlite-statement-sync.js
+++ b/test/parallel/test-sqlite-statement.js
@@ -2,13 +2,13 @@
'use strict';
const { skipIfSQLiteMissing } = require('../common');
skipIfSQLiteMissing();
-const { DatabaseSync, StatementSync } = require('node:sqlite');
+const { Database, Statement } = require('node:sqlite');
const { suite, test } = require('node:test');
-suite('StatementSync() constructor', () => {
- test('StatementSync cannot be constructed directly', (t) => {
+suite('Statement() constructor', () => {
+ test('Statement cannot be constructed directly', (t) => {
t.assert.throws(() => {
- new StatementSync();
+ new Statement();
}, {
code: 'ERR_ILLEGAL_CONSTRUCTOR',
message: /Illegal constructor/,
@@ -16,9 +16,9 @@ suite('StatementSync() constructor', () => {
});
});
-suite('StatementSync.prototype.get()', () => {
+suite('Statement.prototype.get()', () => {
test('executes a query and returns undefined on no results', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
let stmt = db.prepare('CREATE TABLE storage(key TEXT, val TEXT)');
t.assert.strictEqual(stmt.get(), undefined);
stmt = db.prepare('SELECT * FROM storage');
@@ -26,7 +26,7 @@ suite('StatementSync.prototype.get()', () => {
});
test('executes a query and returns the first result', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
let stmt = db.prepare('CREATE TABLE storage(key TEXT, val TEXT)');
t.assert.strictEqual(stmt.get(), undefined);
stmt = db.prepare('INSERT INTO storage (key, val) VALUES (?, ?)');
@@ -37,13 +37,13 @@ suite('StatementSync.prototype.get()', () => {
});
test('executes a query that returns special columns', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const stmt = db.prepare('SELECT 1 as __proto__, 2 as constructor, 3 as toString');
t.assert.deepStrictEqual(stmt.get(), { __proto__: null, ['__proto__']: 1, constructor: 2, toString: 3 });
});
test('reflects an added column after the schema changes', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec('CREATE TABLE storage(key TEXT, val TEXT)');
db.prepare('INSERT INTO storage (key, val) VALUES (?, ?)').run('key1', 'val1');
const stmt = db.prepare('SELECT * FROM storage ORDER BY key');
@@ -54,7 +54,7 @@ suite('StatementSync.prototype.get()', () => {
});
test('reflects a dropped column after the schema changes', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec('CREATE TABLE storage(key TEXT, val TEXT, extra TEXT)');
db.prepare('INSERT INTO storage (key, val, extra) VALUES (?, ?, ?)')
.run('key1', 'val1', 'x');
@@ -66,7 +66,7 @@ suite('StatementSync.prototype.get()', () => {
});
test('throws if the statement is already finalized', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const stmt = db.prepare('CREATE TABLE storage(key TEXT, val TEXT)');
stmt.close();
t.assert.throws(() => {
@@ -78,7 +78,7 @@ suite('StatementSync.prototype.get()', () => {
});
test('surfaces a deferred SQLite error from reset() even though a row was already built', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec(`
PRAGMA foreign_keys = ON;
PRAGMA defer_foreign_keys = ON;
@@ -100,15 +100,15 @@ suite('StatementSync.prototype.get()', () => {
});
});
-suite('StatementSync.prototype.all()', () => {
+suite('Statement.prototype.all()', () => {
test('executes a query and returns an empty array on no results', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const stmt = db.prepare('CREATE TABLE storage(key TEXT, val TEXT)');
t.assert.deepStrictEqual(stmt.all(), []);
});
test('executes a query and returns all results', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
let stmt = db.prepare('CREATE TABLE storage(key TEXT, val TEXT)');
t.assert.deepStrictEqual(stmt.run(), { changes: 0, lastInsertRowid: 0 });
stmt = db.prepare('INSERT INTO storage (key, val) VALUES (?, ?)');
@@ -128,7 +128,7 @@ suite('StatementSync.prototype.all()', () => {
});
test('reflects an added column after the schema changes', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec('CREATE TABLE storage(key TEXT, val TEXT)');
db.prepare('INSERT INTO storage (key, val) VALUES (?, ?)').run('key1', 'val1');
const stmt = db.prepare('SELECT * FROM storage ORDER BY key');
@@ -139,7 +139,7 @@ suite('StatementSync.prototype.all()', () => {
});
test('reflects a dropped column after the schema changes', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec('CREATE TABLE storage(key TEXT, val TEXT, extra TEXT)');
db.prepare('INSERT INTO storage (key, val, extra) VALUES (?, ?, ?)')
.run('key1', 'val1', 'x');
@@ -151,7 +151,7 @@ suite('StatementSync.prototype.all()', () => {
});
test('throws if the statement is already finalized', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const stmt = db.prepare('CREATE TABLE storage(key TEXT, val TEXT)');
stmt.close();
t.assert.throws(() => {
@@ -163,7 +163,7 @@ suite('StatementSync.prototype.all()', () => {
});
test('surfaces a deferred SQLite error from reset() even though the array was already built', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec(`
PRAGMA foreign_keys = ON;
PRAGMA defer_foreign_keys = ON;
@@ -182,9 +182,9 @@ suite('StatementSync.prototype.all()', () => {
});
});
-suite('StatementSync.prototype.iterate()', () => {
+suite('Statement.prototype.iterate()', () => {
test('executes a query and returns an empty iterator on no results', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const stmt = db.prepare('CREATE TABLE storage(key TEXT, val TEXT)');
const iter = stmt.iterate();
t.assert.strictEqual(iter instanceof globalThis.Iterator, true);
@@ -193,7 +193,7 @@ suite('StatementSync.prototype.iterate()', () => {
});
test('executes a query and returns all results', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
let stmt = db.prepare('CREATE TABLE storage(key TEXT, val TEXT)');
t.assert.deepStrictEqual(stmt.run(), { changes: 0, lastInsertRowid: 0 });
stmt = db.prepare('INSERT INTO storage (key, val) VALUES (?, ?)');
@@ -221,7 +221,7 @@ suite('StatementSync.prototype.iterate()', () => {
});
test('reflects an added column after the schema changes', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec('CREATE TABLE storage(key TEXT, val TEXT)');
db.prepare('INSERT INTO storage (key, val) VALUES (?, ?)').run('key1', 'val1');
const stmt = db.prepare('SELECT * FROM storage ORDER BY key');
@@ -232,7 +232,7 @@ suite('StatementSync.prototype.iterate()', () => {
});
test('reflects a dropped column after the schema changes', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec('CREATE TABLE storage(key TEXT, val TEXT, extra TEXT)');
db.prepare('INSERT INTO storage (key, val, extra) VALUES (?, ?, ?)')
.run('key1', 'val1', 'x');
@@ -244,7 +244,7 @@ suite('StatementSync.prototype.iterate()', () => {
});
test('iterator keeps the prepared statement from being collected', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec(`
CREATE TABLE test(key TEXT, val TEXT);
INSERT INTO test (key, val) VALUES ('key1', 'val1');
@@ -267,7 +267,7 @@ suite('StatementSync.prototype.iterate()', () => {
});
test('iterator can be exited early', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec(`
CREATE TABLE test(key TEXT, val TEXT);
INSERT INTO test (key, val) VALUES ('key1', 'val1');
@@ -291,7 +291,7 @@ suite('StatementSync.prototype.iterate()', () => {
});
test('iterator is invalidated when statement is reset by get/all/run/iterate', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec('CREATE TABLE test (value INTEGER NOT NULL)');
for (let i = 0; i < 5; i++) {
db.prepare('INSERT INTO test (value) VALUES (?)').run(i);
@@ -346,7 +346,7 @@ suite('StatementSync.prototype.iterate()', () => {
});
test('throws if the statement is already finalized', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const stmt = db.prepare('CREATE TABLE storage(key TEXT, val TEXT)');
stmt.close();
t.assert.throws(() => {
@@ -358,7 +358,7 @@ suite('StatementSync.prototype.iterate()', () => {
});
test('does not replay results after the iterator is naturally exhausted', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec(`
CREATE TABLE test(key TEXT);
INSERT INTO test (key) VALUES ('key1');
@@ -376,7 +376,7 @@ suite('StatementSync.prototype.iterate()', () => {
});
test('propagates a pending exception when the loop body throws mid-iteration', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec(`
CREATE TABLE test(key TEXT);
INSERT INTO test (key) VALUES ('key1');
@@ -393,9 +393,9 @@ suite('StatementSync.prototype.iterate()', () => {
});
});
-suite('StatementSync.prototype.run()', () => {
+suite('Statement.prototype.run()', () => {
test('executes a query and returns change metadata', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(`
CREATE TABLE storage(key TEXT, val TEXT);
INSERT INTO storage (key, val) VALUES ('foo', 'bar');
@@ -406,7 +406,7 @@ suite('StatementSync.prototype.run()', () => {
});
test('SQLite throws when trying to bind too many parameters', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
);
@@ -423,7 +423,7 @@ suite('StatementSync.prototype.run()', () => {
});
test('SQLite defaults to NULL for unbound parameters', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER NOT NULL) STRICT;'
);
@@ -440,7 +440,7 @@ suite('StatementSync.prototype.run()', () => {
});
test('returns correct metadata when using RETURNING', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
const setup = db.exec(
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER NOT NULL) STRICT;'
);
@@ -459,7 +459,7 @@ suite('StatementSync.prototype.run()', () => {
});
test('SQLite defaults unbound ?NNN parameters', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER NOT NULL) STRICT;'
);
@@ -477,7 +477,7 @@ suite('StatementSync.prototype.run()', () => {
});
test('binds ?NNN params by position', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER NOT NULL) STRICT;'
);
@@ -487,7 +487,7 @@ suite('StatementSync.prototype.run()', () => {
});
test('throws if the statement is already finalized', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const stmt = db.prepare('CREATE TABLE storage(key TEXT, val TEXT)');
stmt.close();
t.assert.throws(() => {
@@ -499,9 +499,9 @@ suite('StatementSync.prototype.run()', () => {
});
});
-suite('StatementSync.prototype.sourceSQL', () => {
+suite('Statement.prototype.sourceSQL', () => {
test('equals input SQL', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(
'CREATE TABLE types(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
);
@@ -512,7 +512,7 @@ suite('StatementSync.prototype.sourceSQL', () => {
});
test('throws if the statement is already finalized', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const stmt = db.prepare('CREATE TABLE storage(key TEXT, val TEXT)');
stmt.close();
t.assert.throws(() => stmt.sourceSQL, {
@@ -522,9 +522,9 @@ suite('StatementSync.prototype.sourceSQL', () => {
});
});
-suite('StatementSync.prototype.expandedSQL', () => {
+suite('Statement.prototype.expandedSQL', () => {
test('equals expanded SQL', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(
'CREATE TABLE types(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
);
@@ -540,7 +540,7 @@ suite('StatementSync.prototype.expandedSQL', () => {
});
test('throws if the statement is already finalized', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const stmt = db.prepare('CREATE TABLE storage(key TEXT, val TEXT)');
stmt.close();
t.assert.throws(() => stmt.expandedSQL, {
@@ -550,7 +550,7 @@ suite('StatementSync.prototype.expandedSQL', () => {
});
});
-suite('StatementSync.prototype.stat()', () => {
+suite('Statement.prototype.stat()', () => {
const counters = [
'fullscanStep', 'sort', 'autoindex', 'vmStep', 'reprepare',
'run', 'memused',
@@ -567,7 +567,7 @@ suite('StatementSync.prototype.stat()', () => {
}
test('returns a number for every valid counter', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;');
const stmt = db.prepare('SELECT * FROM data');
for (const counter of counters) {
@@ -576,7 +576,7 @@ suite('StatementSync.prototype.stat()', () => {
});
test('counts virtual machine steps and runs after execution', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;');
const insert = db.prepare('INSERT INTO data (key, val) VALUES (?, ?)');
for (let i = 1; i <= 5; i++) {
@@ -592,7 +592,7 @@ suite('StatementSync.prototype.stat()', () => {
});
test('detects full table scans', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;');
const insert = db.prepare('INSERT INTO data (key, val) VALUES (?, ?)');
for (let i = 1; i <= 10; i++) {
@@ -611,7 +611,7 @@ suite('StatementSync.prototype.stat()', () => {
});
test('reading a counter does not reset it', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;');
const stmt = db.prepare('SELECT * FROM data');
stmt.all();
@@ -620,7 +620,7 @@ suite('StatementSync.prototype.stat()', () => {
});
test('throws if the counter argument is not a string', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const stmt = db.prepare('SELECT 1');
t.assert.throws(() => stmt.stat(), {
code: 'ERR_INVALID_ARG_TYPE',
@@ -633,7 +633,7 @@ suite('StatementSync.prototype.stat()', () => {
});
test('throws if the counter name is unknown', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const stmt = db.prepare('SELECT 1');
t.assert.throws(() => stmt.stat('nope'), {
code: 'ERR_INVALID_ARG_VALUE',
@@ -642,7 +642,7 @@ suite('StatementSync.prototype.stat()', () => {
});
test('throws if the statement is finalized', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
const stmt = db.prepare('SELECT 1');
db.close();
t.assert.throws(() => stmt.stat('run'), {
@@ -652,9 +652,9 @@ suite('StatementSync.prototype.stat()', () => {
});
});
-suite('StatementSync.prototype.resetStats()', () => {
+suite('Statement.prototype.resetStats()', () => {
test('returns undefined', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const stmt = db.prepare('SELECT 1');
t.assert.strictEqual(stmt.resetStats(), undefined);
});
@@ -663,7 +663,7 @@ suite('StatementSync.prototype.resetStats()', () => {
// resetStats() zeroes. A later re-prepare must not be able to make the
// counter match the cached generation again and reuse stale names.
test('invalidates cached iterator column names', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec('CREATE TABLE data(a); INSERT INTO data VALUES (1)');
const stmt = db.prepare('SELECT * FROM data');
@@ -678,7 +678,7 @@ suite('StatementSync.prototype.resetStats()', () => {
});
test('invalidates the cache when the column count grows', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec('CREATE TABLE t(a); INSERT INTO t VALUES (1)');
const stmt = db.prepare('SELECT * FROM t');
@@ -693,7 +693,7 @@ suite('StatementSync.prototype.resetStats()', () => {
});
test('does not reset memused', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec('CREATE TABLE t(a); INSERT INTO t VALUES (1),(2),(3)');
const stmt = db.prepare('SELECT * FROM t ORDER BY a');
stmt.all();
@@ -707,7 +707,7 @@ suite('StatementSync.prototype.resetStats()', () => {
});
test('clears every counter', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;');
const insert = db.prepare('INSERT INTO data (key, val) VALUES (?, ?)');
for (let i = 1; i <= 5; i++) {
@@ -728,7 +728,7 @@ suite('StatementSync.prototype.resetStats()', () => {
});
test('counters accumulate again after a reset', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;');
const stmt = db.prepare('SELECT * FROM data');
stmt.all();
@@ -739,14 +739,14 @@ suite('StatementSync.prototype.resetStats()', () => {
});
test('is a no-op when no counters have been incremented', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const stmt = db.prepare('SELECT 1');
stmt.resetStats();
t.assert.strictEqual(stmt.stat('run'), 0);
});
test('throws if the statement is finalized', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
const stmt = db.prepare('SELECT 1');
db.close();
t.assert.throws(() => stmt.resetStats(), {
@@ -756,9 +756,9 @@ suite('StatementSync.prototype.resetStats()', () => {
});
});
-suite('StatementSync.prototype.setReadBigInts()', () => {
+suite('Statement.prototype.setReadBigInts()', () => {
test('BigInts support can be toggled', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(`
CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;
INSERT INTO data (key, val) VALUES (1, 42);
@@ -790,7 +790,7 @@ suite('StatementSync.prototype.setReadBigInts()', () => {
});
test('throws when input is not a boolean', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(
'CREATE TABLE types(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
);
@@ -805,7 +805,7 @@ suite('StatementSync.prototype.setReadBigInts()', () => {
});
test('BigInt is required for reading large integers', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const bad = db.prepare(`SELECT ${Number.MAX_SAFE_INTEGER} + 1`);
t.assert.throws(() => {
bad.get();
@@ -822,7 +822,7 @@ suite('StatementSync.prototype.setReadBigInts()', () => {
});
test('BigInt is required for reading large last insert row IDs', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec('CREATE TABLE data(key INTEGER PRIMARY KEY) STRICT');
const insert = db.prepare('INSERT INTO data VALUES (?)');
@@ -841,7 +841,7 @@ suite('StatementSync.prototype.setReadBigInts()', () => {
});
test('throws if the statement is already finalized', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const stmt = db.prepare('CREATE TABLE storage(key TEXT, val TEXT)');
stmt.close();
t.assert.throws(() => {
@@ -853,9 +853,9 @@ suite('StatementSync.prototype.setReadBigInts()', () => {
});
});
-suite('StatementSync.prototype.setReturnArrays()', () => {
+suite('Statement.prototype.setReturnArrays()', () => {
test('throws when input is not a boolean', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
);
@@ -870,7 +870,7 @@ suite('StatementSync.prototype.setReturnArrays()', () => {
});
test('throws if the statement is already finalized', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const stmt = db.prepare('CREATE TABLE storage(key TEXT, val TEXT)');
stmt.close();
t.assert.throws(() => {
@@ -882,9 +882,9 @@ suite('StatementSync.prototype.setReturnArrays()', () => {
});
});
-suite('StatementSync.prototype.get() with array output', () => {
+suite('Statement.prototype.get() with array output', () => {
test('returns array row when setReturnArrays is true', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(`
CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;
INSERT INTO data (key, val) VALUES (1, 'one');
@@ -903,7 +903,7 @@ suite('StatementSync.prototype.get() with array output', () => {
test('returns array rows with BigInts when both flags are set', (t) => {
const expected = [1n, 9007199254740992n];
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(`
CREATE TABLE big_data(id INTEGER, big_num INTEGER);
INSERT INTO big_data VALUES (1, 9007199254740992);
@@ -919,9 +919,9 @@ suite('StatementSync.prototype.get() with array output', () => {
});
});
-suite('StatementSync.prototype.all() with array output', () => {
+suite('Statement.prototype.all() with array output', () => {
test('returns array rows when setReturnArrays is true', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(`
CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;
INSERT INTO data (key, val) VALUES (1, 'one');
@@ -961,7 +961,7 @@ suite('StatementSync.prototype.all() with array output', () => {
9,
'text3',
];
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(`
CREATE TABLE wide_table(
col1 INTEGER, col2 TEXT, col3 REAL, col4 BLOB, col5 INTEGER,
@@ -983,9 +983,9 @@ suite('StatementSync.prototype.all() with array output', () => {
});
});
-suite('StatementSync.prototype.iterate() with array output', () => {
+suite('Statement.prototype.iterate() with array output', () => {
test('iterates array rows when setReturnArrays is true', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(`
CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;
INSERT INTO data (key, val) VALUES (1, 'one');
@@ -1024,7 +1024,7 @@ suite('StatementSync.prototype.iterate() with array output', () => {
});
test('iterator can be exited early with array rows', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec(`
CREATE TABLE test(key TEXT, val TEXT);
INSERT INTO test (key, val) VALUES ('key1', 'val1');
@@ -1051,9 +1051,9 @@ suite('StatementSync.prototype.iterate() with array output', () => {
});
});
-suite('StatementSync.prototype.setAllowBareNamedParameters()', () => {
+suite('Statement.prototype.setAllowBareNamedParameters()', () => {
test('bare named parameter support can be toggled', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
);
@@ -1078,7 +1078,7 @@ suite('StatementSync.prototype.setAllowBareNamedParameters()', () => {
});
test('throws when input is not a boolean', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
);
@@ -1093,7 +1093,7 @@ suite('StatementSync.prototype.setAllowBareNamedParameters()', () => {
});
test('throws if the statement is already finalized', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const stmt = db.prepare('CREATE TABLE storage(key TEXT, val TEXT)');
stmt.close();
t.assert.throws(() => {
@@ -1107,7 +1107,7 @@ suite('StatementSync.prototype.setAllowBareNamedParameters()', () => {
suite('options.readBigInts', () => {
test('BigInts are returned when input is true', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(`
CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;
INSERT INTO data (key, val) VALUES (1, 42);
@@ -1119,7 +1119,7 @@ suite('options.readBigInts', () => {
});
test('numbers are returned when input is false', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(`
CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;
INSERT INTO data (key, val) VALUES (1, 42);
@@ -1131,7 +1131,7 @@ suite('options.readBigInts', () => {
});
test('throws when input is not a boolean', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
);
@@ -1145,7 +1145,7 @@ suite('options.readBigInts', () => {
});
test('setReadBigInts can override prepare option', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(`
CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;
INSERT INTO data (key, val) VALUES (1, 42);
@@ -1161,7 +1161,7 @@ suite('options.readBigInts', () => {
suite('options.returnArrays', () => {
test('arrays are returned when input is true', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(`
CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;
INSERT INTO data (key, val) VALUES (1, 'one');
@@ -1176,7 +1176,7 @@ suite('options.returnArrays', () => {
});
test('objects are returned when input is false', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(`
CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;
INSERT INTO data (key, val) VALUES (1, 'one');
@@ -1191,7 +1191,7 @@ suite('options.returnArrays', () => {
});
test('throws when input is not a boolean', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(
'CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;'
);
@@ -1205,7 +1205,7 @@ suite('options.returnArrays', () => {
});
test('setReturnArrays can override prepare option', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(`
CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;
INSERT INTO data (key, val) VALUES (1, 'one');
@@ -1222,7 +1222,7 @@ suite('options.returnArrays', () => {
});
test('all() returns arrays when input is true', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(`
CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;
INSERT INTO data (key, val) VALUES (1, 'one');
@@ -1241,7 +1241,7 @@ suite('options.returnArrays', () => {
});
test('iterate() returns arrays when input is true', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(`
CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;
INSERT INTO data (key, val) VALUES (1, 'one');
@@ -1262,7 +1262,7 @@ suite('options.returnArrays', () => {
suite('options.allowBareNamedParameters', () => {
test('bare named parameters are allowed when input is true', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
);
@@ -1278,7 +1278,7 @@ suite('options.allowBareNamedParameters', () => {
});
test('bare named parameters throw when input is false', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
);
@@ -1296,7 +1296,7 @@ suite('options.allowBareNamedParameters', () => {
});
test('throws when input is not a boolean', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
);
@@ -1313,7 +1313,7 @@ suite('options.allowBareNamedParameters', () => {
});
test('setAllowBareNamedParameters can override prepare option', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const setup = db.exec(
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
);
@@ -1337,9 +1337,9 @@ suite('options.allowBareNamedParameters', () => {
});
-suite('StatementSync.prototype.close()', () => {
+suite('Statement.prototype.close()', () => {
test('finalizes an open statement', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec('CREATE TABLE storage(key TEXT, val TEXT)');
const stmt = db.prepare('SELECT * FROM storage');
t.assert.strictEqual(stmt.close(), undefined);
@@ -1350,7 +1350,7 @@ suite('StatementSync.prototype.close()', () => {
});
test('throws if the statement is already finalized', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const stmt = db.prepare('CREATE TABLE storage(key TEXT, val TEXT)');
stmt.close();
t.assert.throws(() => {
@@ -1362,9 +1362,9 @@ suite('StatementSync.prototype.close()', () => {
});
});
-suite('StatementSync.prototype[Symbol.dispose]()', () => {
+suite('Statement.prototype[Symbol.dispose]()', () => {
test('finalizes an open statement', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec('CREATE TABLE storage(key TEXT, val TEXT)');
const stmt = db.prepare('SELECT * FROM storage');
stmt[Symbol.dispose]();
@@ -1375,14 +1375,14 @@ suite('StatementSync.prototype[Symbol.dispose]()', () => {
});
test('does not throw on an already-finalized statement', () => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const stmt = db.prepare('CREATE TABLE storage(key TEXT, val TEXT)');
stmt[Symbol.dispose]();
stmt[Symbol.dispose]();
});
test('works with a using declaration', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec('CREATE TABLE storage(key TEXT, val TEXT)');
let captured;
{
@@ -1397,7 +1397,7 @@ suite('StatementSync.prototype[Symbol.dispose]()', () => {
});
test('closing the database after dispose does not double-finalize', () => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
const stmt = db.prepare('CREATE TABLE storage(key TEXT, val TEXT)');
stmt[Symbol.dispose]();
db.close();
@@ -1406,7 +1406,7 @@ suite('StatementSync.prototype[Symbol.dispose]()', () => {
suite('options.persistent', () => {
test('statement executes correctly when persistent is true', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;');
db.exec('INSERT INTO data (key, val) VALUES (1, 42);');
using stmt = db.prepare('SELECT val FROM data', { persistent: true });
@@ -1414,7 +1414,7 @@ suite('options.persistent', () => {
});
test('statement executes correctly when persistent is false', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;');
db.exec('INSERT INTO data (key, val) VALUES (1, 42);');
using stmt = db.prepare('SELECT val FROM data', { persistent: false });
@@ -1422,7 +1422,7 @@ suite('options.persistent', () => {
});
test('throws when input is not a boolean', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
t.assert.throws(() => {
db.prepare('SELECT 1', { persistent: 'yes' });
}, {
@@ -1432,7 +1432,7 @@ suite('options.persistent', () => {
});
test('can be combined with other options', (t) => {
- using db = new DatabaseSync(':memory:');
+ using db = new Database(':memory:');
db.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;');
db.exec('INSERT INTO data (key, val) VALUES (1, 42);');
using stmt = db.prepare(
diff --git a/test/parallel/test-sqlite-template-tag.js b/test/parallel/test-sqlite-template-tag.js
index eaa6d19fc7c..f7a5053a330 100644
--- a/test/parallel/test-sqlite-template-tag.js
+++ b/test/parallel/test-sqlite-template-tag.js
@@ -5,10 +5,10 @@ const { skipIfSQLiteMissing } = require('../common');
skipIfSQLiteMissing();
const assert = require('assert');
-const { DatabaseSync } = require('node:sqlite');
+const { Database } = require('node:sqlite');
const { test, beforeEach } = require('node:test');
-const db = new DatabaseSync(':memory:');
+const db = new Database(':memory:');
const sql = db.createTagStore(10);
beforeEach(() => {
@@ -18,7 +18,7 @@ beforeEach(() => {
});
test('throws error if database is not open', () => {
- const db = new DatabaseSync(':memory:', { open: false });
+ const db = new Database(':memory:', { open: false });
assert.throws(() => {
db.createTagStore(10);
@@ -91,7 +91,7 @@ test('queries with no results', () => {
});
test('rejects parameters outside of template expressions', () => {
- const ldb = new DatabaseSync(':memory:');
+ const ldb = new Database(':memory:');
const lsql = ldb.createTagStore();
ldb.exec(`
CREATE TABLE secrets(owner TEXT, token TEXT);
@@ -150,7 +150,7 @@ test('TagStore capacity, size, and clear', () => {
});
test('iterator is invalidated when the cached statement is reset', () => {
- const ldb = new DatabaseSync(':memory:');
+ const ldb = new Database(':memory:');
const lsql = ldb.createTagStore();
ldb.exec('CREATE TABLE foo (id INTEGER PRIMARY KEY, text TEXT)');
for (let i = 0; i < 5; i++) {
@@ -204,7 +204,7 @@ test('iterator is invalidated when the cached statement is reset', () => {
});
test('a stale iterator cannot replay a victim-bound write', () => {
- const bank = new DatabaseSync(':memory:');
+ const bank = new Database(':memory:');
const tx = bank.createTagStore();
bank.exec(`
CREATE TABLE acct(user TEXT PRIMARY KEY, balance INTEGER);
@@ -258,7 +258,7 @@ test('a finished iterator stays done and does not restart', () => {
});
test('createTagStore throws on invalid maxSize', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
assert.throws(() => db.createTagStore(0), {
code: 'ERR_OUT_OF_RANGE',
@@ -291,7 +291,7 @@ test('createTagStore throws on invalid maxSize', () => {
});
});
-test('sql.db returns the associated DatabaseSync instance', () => {
+test('sql.db returns the associated Database instance', () => {
assert.strictEqual(sql.db, db);
});
@@ -341,7 +341,7 @@ test('rejects SQL that contains no statements', () => {
});
test('a tag store keeps the database alive by itself', () => {
- const sql = new DatabaseSync(':memory:').createTagStore();
+ const sql = new Database(':memory:').createTagStore();
sql.db.exec('CREATE TABLE test (data INTEGER)');
@@ -356,9 +356,9 @@ test('tag store prevents circular reference leaks', async () => {
const before = process.memoryUsage().heapUsed;
- // Create many SQLTagStore + DatabaseSync pairs with circular references
+ // Create many SQLTagStore + Database pairs with circular references
for (let i = 0; i < 1000; i++) {
- const sql = new DatabaseSync(':memory:').createTagStore();
+ const sql = new Database(':memory:').createTagStore();
sql.db.exec('CREATE TABLE test (data INTEGER)');
// eslint-disable-next-line no-void
sql.db.setAuthorizer(() => void sql.db);
@@ -373,7 +373,7 @@ test('tag store prevents circular reference leaks', async () => {
});
test('cached statements are finalized when the database is closed', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
const sql = db.createTagStore();
db.exec('CREATE TABLE foo (id INTEGER PRIMARY KEY)');
diff --git a/test/parallel/test-sqlite-timeout.js b/test/parallel/test-sqlite-timeout.js
index aa3fdae6760..97d40bffc73 100644
--- a/test/parallel/test-sqlite-timeout.js
+++ b/test/parallel/test-sqlite-timeout.js
@@ -3,7 +3,7 @@ const { skipIfSQLiteMissing } = require('../common');
skipIfSQLiteMissing();
const tmpdir = require('../common/tmpdir');
const { join } = require('node:path');
-const { DatabaseSync } = require('node:sqlite');
+const { Database } = require('node:sqlite');
const { test } = require('node:test');
const { once } = require('node:events');
const { Worker } = require('node:worker_threads');
@@ -17,7 +17,7 @@ function nextDb() {
test('waits to acquire lock', async (t) => {
const DB_PATH = nextDb();
- const conn = new DatabaseSync(DB_PATH);
+ const conn = new Database(DB_PATH);
t.after(() => {
try {
conn.close();
@@ -30,9 +30,9 @@ test('waits to acquire lock', async (t) => {
conn.exec('BEGIN EXCLUSIVE;');
const worker = new Worker(`
'use strict';
- const { DatabaseSync } = require('node:sqlite');
+ const { Database } = require('node:sqlite');
const { workerData } = require('node:worker_threads');
- const conn = new DatabaseSync(workerData.database, { timeout: 30000 });
+ const conn = new Database(workerData.database, { timeout: 30000 });
conn.exec('SELECT * FROM data');
conn.close();
`, {
@@ -48,7 +48,7 @@ test('waits to acquire lock', async (t) => {
test('throws if the lock cannot be acquired before timeout', (t) => {
const DB_PATH = nextDb();
- const conn1 = new DatabaseSync(DB_PATH);
+ const conn1 = new Database(DB_PATH);
t.after(() => {
try {
conn1.close();
@@ -56,7 +56,7 @@ test('throws if the lock cannot be acquired before timeout', (t) => {
// Ignore.
}
});
- const conn2 = new DatabaseSync(DB_PATH, { timeout: 1 });
+ const conn2 = new Database(DB_PATH, { timeout: 1 });
t.after(() => {
try {
conn2.close();
diff --git a/test/parallel/test-sqlite-transactions.js b/test/parallel/test-sqlite-transactions.js
index 963e7126a10..3a37a05b330 100644
--- a/test/parallel/test-sqlite-transactions.js
+++ b/test/parallel/test-sqlite-transactions.js
@@ -1,12 +1,12 @@
'use strict';
const { skipIfSQLiteMissing } = require('../common');
skipIfSQLiteMissing();
-const { DatabaseSync } = require('node:sqlite');
+const { Database } = require('node:sqlite');
const { suite, test } = require('node:test');
suite('manual transactions', () => {
test('a transaction is committed', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => { db.close(); });
const setup = db.exec(`
CREATE TABLE data(
@@ -33,7 +33,7 @@ suite('manual transactions', () => {
});
test('a transaction is rolled back', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => { db.close(); });
const setup = db.exec(`
CREATE TABLE data(
diff --git a/test/parallel/test-sqlite-typed-array-and-data-view.js b/test/parallel/test-sqlite-typed-array-and-data-view.js
index 5236c182e06..e13b8b33daa 100644
--- a/test/parallel/test-sqlite-typed-array-and-data-view.js
+++ b/test/parallel/test-sqlite-typed-array-and-data-view.js
@@ -1,7 +1,7 @@
'use strict';
const { skipIfSQLiteMissing } = require('../common');
skipIfSQLiteMissing();
-const { DatabaseSync } = require('node:sqlite');
+const { Database } = require('node:sqlite');
const { suite, test } = require('node:test');
const arrayBuffer = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]).buffer;
@@ -24,10 +24,10 @@ const TypedArrays = [
['DataView', DataView],
];
-suite('StatementSync with TypedArray/DataView', () => {
+suite('Statement with TypedArray/DataView', () => {
for (const [displayName, TypedArray] of TypedArrays) {
test(displayName, (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => { db.close(); });
db.exec('CREATE TABLE test (data BLOB)');
// insert
@@ -56,7 +56,7 @@ suite('StatementSync with TypedArray/DataView', () => {
}
});
-suite('StatementSync with ArrayBuffer and SharedArrayBuffer', () => {
+suite('Statement with ArrayBuffer and SharedArrayBuffer', () => {
const buffers = [
['ArrayBuffer', arrayBuffer],
['SharedArrayBuffer', sharedArrayBuffer],
@@ -64,7 +64,7 @@ suite('StatementSync with ArrayBuffer and SharedArrayBuffer', () => {
for (const [displayName, buffer] of buffers) {
test(`${displayName} - anonymous binding`, (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => { db.close(); });
db.exec('CREATE TABLE test (data BLOB)');
// insert
@@ -92,7 +92,7 @@ suite('StatementSync with ArrayBuffer and SharedArrayBuffer', () => {
});
test(`${displayName} - named binding (object)`, (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => { db.close(); });
db.exec('CREATE TABLE test (data BLOB)');
// insert
diff --git a/test/parallel/test-sqlite-udf-close.js b/test/parallel/test-sqlite-udf-close.js
index cb11e50a7f7..5a9454d8140 100644
--- a/test/parallel/test-sqlite-udf-close.js
+++ b/test/parallel/test-sqlite-udf-close.js
@@ -4,11 +4,11 @@ const { skipIfSQLiteMissing } = require('../common');
skipIfSQLiteMissing();
const assert = require('node:assert');
const { test } = require('node:test');
-const { DatabaseSync } = require('node:sqlite');
+const { Database } = require('node:sqlite');
for (const method of ['all', 'get', 'run', 'iterate']) {
test(`database.close() from a UDF during statement.${method}()`, () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec(`
CREATE TABLE data (value INTEGER);
INSERT INTO data VALUES (1), (2), (3);
@@ -40,7 +40,7 @@ for (const method of ['all', 'get', 'run', 'iterate']) {
// Finalizing the statement being stepped frees the virtual machine that
// sqlite3_step() is still running, so this must throw rather than crash.
test(`statement.close() from a UDF during statement.${method}()`, () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec(`
CREATE TABLE data (value INTEGER);
INSERT INTO data VALUES (1), (2), (3);
@@ -74,7 +74,7 @@ for (const method of ['all', 'get', 'run', 'iterate']) {
for (const reentrant of ['run', 'get', 'all', 'iterate']) {
test(`statement.${reentrant}() from a UDF during ` +
`statement.${method}()`, () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec(`
CREATE TABLE data (value INTEGER, padding TEXT);
INSERT INTO data VALUES (1, '${'x'.repeat(400)}'),
@@ -118,7 +118,7 @@ for (const method of ['all', 'get', 'run', 'iterate']) {
// four are exercised.
for (const reentrant of ['run', 'get', 'all', 'iterate']) {
test(`tag store ${reentrant} reentry during statement.${method}()`, () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
const sql = db.createTagStore(10);
db.exec(`
CREATE TABLE data (value INTEGER, padding TEXT);
@@ -165,7 +165,7 @@ for (const method of ['all', 'get', 'run', 'iterate']) {
// A UDF may prepare and finalize its own helper statements. Only the
// statement being stepped is off limits.
test(`UDF finalizes its own statement during statement.${method}()`, () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec(`
CREATE TABLE data (value INTEGER);
INSERT INTO data VALUES (1), (2), (3);
@@ -204,7 +204,7 @@ for (const method of ['all', 'get', 'run', 'iterate']) {
// again, so both reach the virtual machine that is mid-execution.
for (const op of ['next', 'return']) {
test(`iterator.${op}() from a UDF during iteration`, () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec(`
CREATE TABLE data (value INTEGER, padding TEXT);
INSERT INTO data VALUES (1, '${'x'.repeat(400)}'),
diff --git a/test/parallel/test-sqlite-virtual-table.js b/test/parallel/test-sqlite-virtual-table.js
index c7fffda2f38..c7607beba14 100644
--- a/test/parallel/test-sqlite-virtual-table.js
+++ b/test/parallel/test-sqlite-virtual-table.js
@@ -3,12 +3,12 @@
const { skipIfSQLiteMissing } = require('../common');
skipIfSQLiteMissing();
const assert = require('node:assert');
-const { DatabaseSync } = require('node:sqlite');
+const { Database } = require('node:sqlite');
const { suite, test } = require('node:test');
-suite('DatabaseSync.prototype.createModule()', () => {
+suite('Database.prototype.createModule()', () => {
suite('input validation', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
test('throws if name is not a string', () => {
assert.throws(() => {
@@ -133,7 +133,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
});
test('throws if database is not open', () => {
- const closedDb = new DatabaseSync(':memory:');
+ const closedDb = new Database(':memory:');
closedDb.close();
assert.throws(() => {
closedDb.createModule('mod', {
@@ -149,7 +149,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
suite('basic virtual table', () => {
test('creates a simple read-only virtual table', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.createModule('simple', {
columns: [
@@ -173,7 +173,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
});
test('works as eponymous table (without CREATE VIRTUAL TABLE)', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.createModule('eponymous', {
columns: [
@@ -193,7 +193,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
});
test('supports rows() returning an array', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.createModule('array_mod', {
columns: [
@@ -213,7 +213,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
});
test('supports empty result set', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.createModule('empty_mod', {
columns: [
@@ -231,7 +231,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
suite('table-valued function with parameters', () => {
test('passes hidden column values as arguments to rows()', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.createModule('gen_series', {
columns: [
@@ -263,7 +263,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
});
test('passes step parameter', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.createModule('gen_step', {
columns: [
@@ -294,7 +294,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
});
test('handles partial parameters (some hidden cols unconstrained)', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.createModule('partial_params', {
columns: [
@@ -320,7 +320,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
});
test('maps parameters correctly beyond 32 hidden columns', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
const paramCount = 40;
const columns = [{ name: 'value', type: 'INTEGER' }];
for (let i = 0; i < paramCount; i++) {
@@ -349,7 +349,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
suite('type conversions', () => {
test('handles various SQLite data types', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.createModule('types_mod', {
columns: [
@@ -378,7 +378,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
suite('useBigIntArguments', () => {
test('passes INTEGER parameters as BigInts when enabled', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
let receivedType;
db.createModule('bigint_mod', {
@@ -398,7 +398,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
});
test('passes INTEGER parameters as numbers by default', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
let receivedType;
db.createModule('number_mod', {
@@ -429,7 +429,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
['a row getter', (db) => () => [{ get 0() { db.close(); return 1; } }]],
]) {
test(`throws when close() is called from ${name}`, () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.createModule('closer', {
columns: [{ name: 'value', type: 'INTEGER' }],
rows: makeRows(db),
@@ -445,7 +445,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
}
test('throws when createModule() is called from an authorizer', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec('CREATE TABLE t(a)');
let err;
db.setAuthorizer(() => {
@@ -468,7 +468,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
suite('iterator cleanup', () => {
test('closes the iterator when SQLite stops stepping early', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
let cleanedUp = false;
db.createModule('early_stop', {
@@ -490,7 +490,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
});
test('keeps the original error when rows() throws', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.createModule('cleanup_throws', {
columns: [{ name: 'value', type: 'INTEGER' }],
@@ -510,7 +510,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
});
test('closes the iterator on break out of a for...of loop', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
let cleanedUp = false;
db.createModule('breaker', {
@@ -533,7 +533,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
});
test('surfaces an error thrown by the iterator\'s return()', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
for (const [label, descriptor] of [
['method', { value() { throw new Error('return boom'); } }],
@@ -592,7 +592,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
// The destructor runs from a GC callback, where JavaScript cannot be
// executed. An abandoned generator does not run `finally` in JavaScript
// either, so the expected outcome is no crash and no cleanup.
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
let cleanedUp = false;
db.createModule('abandoned', {
@@ -622,7 +622,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
// SQLite discards xClose's return value, so a cleanup error there has no
// SQLite error to pair with. Suppressing one would leave the suppression
// flag set for the next unrelated statement.
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.createModule('cleanup_leak', {
columns: [{ name: 'value', type: 'INTEGER' }],
@@ -651,7 +651,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
// one can surface, and xClose cannot choose based on the statement's
// state, because SQLite closes cursors before transferring the error to
// the connection. The constraint violation is the actionable one.
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.createModule('both_fail', {
columns: [{ name: 'value', type: 'INTEGER' }],
@@ -700,7 +700,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
],
]) {
test(`reports an error when ${name}`, () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.createModule('bad', {
columns: [{ name: 'v', type: 'INTEGER' }],
rows,
@@ -721,7 +721,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
suite('hidden column constraints', () => {
const makeDb = () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.createModule('gs', {
columns: [
{ name: 'value', type: 'INTEGER' },
@@ -781,7 +781,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
suite('error handling', () => {
test('propagates errors thrown in rows()', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.createModule('error_mod', {
columns: [
@@ -800,7 +800,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
});
test('propagates errors thrown during iteration', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.createModule('iter_error_mod', {
columns: [
@@ -822,7 +822,7 @@ suite('DatabaseSync.prototype.createModule()', () => {
suite('multiple queries', () => {
test('supports querying the virtual table multiple times', () => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
let callCount = 0;
db.createModule('multi_mod', {
diff --git a/test/parallel/test-sqlite.js b/test/parallel/test-sqlite.js
index b7b65f1258f..a49a6006242 100644
--- a/test/parallel/test-sqlite.js
+++ b/test/parallel/test-sqlite.js
@@ -1,7 +1,7 @@
'use strict';
const { spawnPromisified, skipIfSQLiteMissing } = require('../common');
skipIfSQLiteMissing();
-const { DatabaseSync, constants } = require('node:sqlite');
+const { Database, constants } = require('node:sqlite');
const { suite, test } = require('node:test');
const { pathToFileURL } = require('node:url');
const { nextDb } = require('../sqlite/next-db.js');
@@ -36,7 +36,7 @@ suite('accessing the node:sqlite module', () => {
});
test('ERR_SQLITE_ERROR is thrown for errors originating from SQLite', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => { db.close(); });
const setup = db.exec(`
CREATE TABLE test(
@@ -57,8 +57,8 @@ test('ERR_SQLITE_ERROR is thrown for errors originating from SQLite', (t) => {
});
test('in-memory databases are supported', (t) => {
- const db1 = new DatabaseSync(':memory:');
- const db2 = new DatabaseSync(':memory:');
+ const db1 = new Database(':memory:');
+ const db2 = new Database(':memory:');
const setup1 = db1.exec(`
CREATE TABLE data(key INTEGER PRIMARY KEY);
INSERT INTO data (key) VALUES (1);
@@ -87,7 +87,7 @@ test('sqlite constants are defined', (t) => {
test('PRAGMAs are supported', (t) => {
// WAL journal mode requires an on-disk database.
- const db = new DatabaseSync(nextDb());
+ const db = new Database(nextDb());
t.after(() => { db.close(); });
t.assert.deepStrictEqual(
db.prepare('PRAGMA journal_mode = WAL').get(),
@@ -100,7 +100,7 @@ test('PRAGMAs are supported', (t) => {
});
test('Buffer is supported as the database path', (t) => {
- const db = new DatabaseSync(Buffer.from(nextDb()));
+ const db = new Database(Buffer.from(nextDb()));
t.after(() => { db.close(); });
db.exec(`
CREATE TABLE data(key INTEGER PRIMARY KEY);
@@ -115,7 +115,7 @@ test('Buffer is supported as the database path', (t) => {
test('URL is supported as the database path', (t) => {
const url = pathToFileURL(nextDb());
- const db = new DatabaseSync(url);
+ const db = new Database(url);
t.after(() => { db.close(); });
db.exec(`
CREATE TABLE data(key INTEGER PRIMARY KEY);
@@ -130,7 +130,7 @@ test('URL is supported as the database path', (t) => {
suite('URI query params', () => {
const baseDbPath = nextDb();
- const baseDb = new DatabaseSync(baseDbPath);
+ const baseDb = new Database(baseDbPath);
baseDb.exec(`
CREATE TABLE data(key INTEGER PRIMARY KEY);
INSERT INTO data (key) VALUES (1);
@@ -140,7 +140,7 @@ suite('URI query params', () => {
test('query params are supported with URL objects', (t) => {
const url = pathToFileURL(baseDbPath);
url.searchParams.set('mode', 'ro');
- const readOnlyDB = new DatabaseSync(url);
+ const readOnlyDB = new Database(url);
t.after(() => { readOnlyDB.close(); });
t.assert.deepStrictEqual(
@@ -160,7 +160,7 @@ suite('URI query params', () => {
url.searchParams.set('mode', 'ro');
// Ensures a valid URI passed as a string is supported
- const readOnlyDB = new DatabaseSync(url.toString());
+ const readOnlyDB = new Database(url.toString());
t.after(() => { readOnlyDB.close(); });
t.assert.deepStrictEqual(
@@ -180,7 +180,7 @@ suite('URI query params', () => {
url.searchParams.set('mode', 'ro');
// Ensures a valid URI passed as a Buffer is supported
- const readOnlyDB = new DatabaseSync(Buffer.from(url.toString()));
+ const readOnlyDB = new Database(Buffer.from(url.toString()));
t.after(() => { readOnlyDB.close(); });
t.assert.deepStrictEqual(
@@ -198,7 +198,7 @@ suite('URI query params', () => {
suite('SQL APIs enabled at build time', () => {
test('math functions are enabled', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.assert.deepStrictEqual(
db.prepare('SELECT PI() AS pi').get(),
{ __proto__: null, pi: 3.141592653589793 },
@@ -206,7 +206,7 @@ suite('SQL APIs enabled at build time', () => {
});
test('percentile is enabled', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec(`
CREATE TABLE t1 (x INTEGER);
INSERT INTO t1 (x) VALUES (1), (2), (3), (4), (5);
@@ -219,7 +219,7 @@ suite('SQL APIs enabled at build time', () => {
});
test('dbstat is enabled', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.after(() => { db.close(); });
db.exec(`
CREATE TABLE t1 (key INTEGER PRIMARY KEY);
@@ -244,7 +244,7 @@ suite('SQL APIs enabled at build time', () => {
});
test('fts3 is enabled', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec(`
CREATE VIRTUAL TABLE t1 USING fts3(content TEXT);
INSERT INTO t1 (content) VALUES ('hello world');
@@ -259,7 +259,7 @@ suite('SQL APIs enabled at build time', () => {
});
test('fts3 parenthesis is enabled', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec(`
CREATE VIRTUAL TABLE t1 USING fts3(content TEXT);
INSERT INTO t1 (content) VALUES ('hello world');
@@ -274,7 +274,7 @@ suite('SQL APIs enabled at build time', () => {
});
test('fts4 is enabled', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec(`
CREATE VIRTUAL TABLE t1 USING fts4(content TEXT);
INSERT INTO t1 (content) VALUES ('hello world');
@@ -289,7 +289,7 @@ suite('SQL APIs enabled at build time', () => {
});
test('fts5 is enabled', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec(`
CREATE VIRTUAL TABLE t1 USING fts5(content);
INSERT INTO t1 (content) VALUES ('hello world');
@@ -304,7 +304,7 @@ suite('SQL APIs enabled at build time', () => {
});
test('rtree is enabled', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec(`
CREATE VIRTUAL TABLE t1 USING rtree(id, minX, maxX, minY, maxY);
INSERT INTO t1 (id, minX, maxX, minY, maxY) VALUES (1, 0, 1, 0, 1);
@@ -319,7 +319,7 @@ suite('SQL APIs enabled at build time', () => {
});
test('rbu is enabled', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
t.assert.deepStrictEqual(
db.prepare('SELECT sqlite_compileoption_used(\'SQLITE_ENABLE_RBU\') as rbu_enabled;').get(),
{ __proto__: null, rbu_enabled: 1 },
@@ -327,7 +327,7 @@ suite('SQL APIs enabled at build time', () => {
});
test('geopoly is enabled', (t) => {
- const db = new DatabaseSync(':memory:');
+ const db = new Database(':memory:');
db.exec(`
CREATE VIRTUAL TABLE t1 USING geopoly(a,b,c);
INSERT INTO t1(_shape) VALUES('[[0,0],[1,0],[0.5,1],[0,0]]');
diff --git a/test/sqlite/test_sqlite_extensions/test.js b/test/sqlite/test_sqlite_extensions/test.js
index ece230399c7..b1d88bb5ee7 100644
--- a/test/sqlite/test_sqlite_extensions/test.js
+++ b/test/sqlite/test_sqlite_extensions/test.js
@@ -22,7 +22,7 @@ function resolveBuiltBinary() {
const binary = resolveBuiltBinary();
test('should load extension successfully', () => {
- const db = new sqlite.DatabaseSync(':memory:', {
+ const db = new sqlite.Database(':memory:', {
allowExtension: true,
});
db.loadExtension(binary);
@@ -33,7 +33,7 @@ test('should load extension successfully', () => {
});
test('should not load extension', () => {
- const db = new sqlite.DatabaseSync(':memory:', {
+ const db = new sqlite.Database(':memory:', {
allowExtension: false,
});
assert.throws(() => {
@@ -70,7 +70,7 @@ test('should not load extension', () => {
});
test('should load extension successfully with enableLoadExtension', () => {
- const db = new sqlite.DatabaseSync(':memory:', {
+ const db = new sqlite.Database(':memory:', {
allowExtension: true,
});
db.loadExtension(binary);
@@ -82,7 +82,7 @@ test('should load extension successfully with enableLoadExtension', () => {
});
test('should not load extension with enableLoadExtension', () => {
- const db = new sqlite.DatabaseSync(':memory:', {
+ const db = new sqlite.Database(':memory:', {
allowExtension: true,
});
db.enableLoadExtension(false);
@@ -96,7 +96,7 @@ test('should not load extension with enableLoadExtension', () => {
test('should throw error if permission is enabled', async () => {
const [cmd, opts] = common.escapePOSIXShell`"${process.execPath}" `;
const code = `const sqlite = require('node:sqlite');
-const db = new sqlite.DatabaseSync(':memory:', { allowExtension: true });`;
+const db = new sqlite.Database(':memory:', { allowExtension: true });`;
return new Promise((resolve) => {
childProcess.exec(
`${cmd} --permission -e "${code}"`,
diff --git a/test/sqlite/worker.js b/test/sqlite/worker.js
index 8d1ca2420c9..912ed1374f9 100644
--- a/test/sqlite/worker.js
+++ b/test/sqlite/worker.js
@@ -3,10 +3,10 @@
'use strict';
require('../common');
const { parentPort, workerData } = require('worker_threads');
-const { DatabaseSync, constants } = require('node:sqlite');
+const { Database, constants } = require('node:sqlite');
const { changeset, mode, dbPath } = workerData;
-const db = new DatabaseSync(dbPath);
+const db = new Database(dbPath);
const options = {};
if (mode !== constants.SQLITE_CHANGESET_ABORT && mode !== constants.SQLITE_CHANGESET_OMIT) {