diff --git a/SECURITY.md b/SECURITY.md index 17d35fd4432f..df60feb614e1 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 @@ -524,7 +524,7 @@ The following are **not** vulnerabilities in Node.js: responsibility. The permission model does not restrict how Node.js behaves when the operator intentionally configures it. -* **`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 0610839653df..a962a97d7c3b 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 dca31a18d986..b4b7f238d038 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 58e97274c98f..2f56fd5602fa 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 336a6b176b0d..9acada928b8b 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 c8487dca471b..e4d269b6afda 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 eb2e5074151a..bbd23b69dcf4 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 0fff29ce5686..c7d2a9f833b0 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 5179f0bc5420..3a5c3bbad04c 100644 --- a/doc/api/deprecations.md +++ b/doc/api/deprecations.md @@ -4801,6 +4801,20 @@ async function example() { } ``` +### DEP0210: `sqlite.DatabaseSync` + + + +Type: Runtime + +`node:sqlite`'s `DatabaseSync` class was renamed to `Database`. `DatabaseSync` +is kept as a deprecated alias. Use `Database` 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 e63f23829f90..65de5734b6c1 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 36804b060e80..8d703dafbf20 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` -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()); @@ -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)'); @@ -930,10 +934,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)'); @@ -950,10 +954,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)'); @@ -1650,9 +1654,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()` @@ -1674,7 +1678,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 @@ -1694,14 +1698,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 }) => { @@ -1714,9 +1718,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 9e24eaca3e50..da253ff99ccb 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", diff --git a/lib/sqlite.js b/lib/sqlite.js index db781a21ee1c..05114325708e 100644 --- a/lib/sqlite.js +++ b/lib/sqlite.js @@ -1,3 +1,23 @@ 'use strict'; -module.exports = internalBinding('sqlite'); +const { deprecate } = require('internal/util'); + +const { + Database, + StatementSync, + Session, + constants, + backup, +} = internalBinding('sqlite'); + +module.exports = { + Database, + DatabaseSync: deprecate( + Database, + 'sqlite.DatabaseSync is deprecated, use sqlite.Database instead.', + 'DEP0210'), + StatementSync, + Session, + constants, + backup, +}; diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc index 9ad04eae0878..42f934c2db32 100644 --- a/src/node_sqlite.cc +++ b/src/node_sqlite.cc @@ -89,7 +89,7 @@ BindingData::BindingData(Realm* realm, Local wrap) void BindingData::MemoryInfo(MemoryTracker* tracker) const { tracker->TrackFieldWithSize("open_databases", - open_databases.size() * sizeof(DatabaseSync*), + open_databases.size() * sizeof(Database*), "open_databases"); } @@ -343,9 +343,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; @@ -392,7 +392,7 @@ inline MaybeLocal NullableSQLiteStringToValue(Isolate* isolate, class CustomAggregate { public: explicit CustomAggregate(Environment* env, - BaseObjectWeakPtr db, + BaseObjectWeakPtr db, bool use_bigint_args, Local start, Local step_fn, @@ -578,7 +578,7 @@ class CustomAggregate { } Environment* env_; - BaseObjectWeakPtr db_; + BaseObjectWeakPtr db_; bool use_bigint_args_; Global start_; Global step_fn_; @@ -589,7 +589,7 @@ class CustomAggregate { class BackupJob : public ThreadPoolWork { public: explicit BackupJob(Environment* env, - DatabaseSync* source, + Database* source, Local resolver, std::string source_db, std::string destination_name, @@ -753,7 +753,7 @@ class BackupJob : public ThreadPoolWork { Environment* env() const { return env_; } Environment* env_; - BaseObjectPtr source_; + BaseObjectPtr source_; Global resolver_; Global progressFunc_; struct Sqlite3Deleter { @@ -773,7 +773,7 @@ class BackupJob : public ThreadPoolWork { UserDefinedFunction::UserDefinedFunction(Environment* env, Local fn, - BaseObjectWeakPtr db, + BaseObjectWeakPtr db, bool use_bigint_args) : env_(env), fn_(env->isolate(), fn), @@ -844,26 +844,26 @@ void UserDefinedFunction::xDestroy(void* self) { delete static_cast(self); } -DatabaseSyncLimits::DatabaseSyncLimits(Environment* env, - Local object, - BaseObjectWeakPtr database) +DatabaseLimits::DatabaseLimits(Environment* env, + Local object, + BaseObjectWeakPtr 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 DatabaseSyncLimits::GetTemplate(Environment* env) { +Local DatabaseLimits::GetTemplate(Environment* env) { Local 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, @@ -879,14 +879,14 @@ Local DatabaseSyncLimits::GetTemplate(Environment* env) { return tmpl; } -Intercepted DatabaseSyncLimits::LimitsGetter( +Intercepted DatabaseLimits::LimitsGetter( Local property, const PropertyCallbackInfo& 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(); @@ -911,7 +911,7 @@ Intercepted DatabaseSyncLimits::LimitsGetter( return Intercepted::kYes; } -Intercepted DatabaseSyncLimits::LimitsSetter( +Intercepted DatabaseLimits::LimitsSetter( Local property, Local value, const PropertyCallbackInfo& info) { @@ -919,7 +919,7 @@ Intercepted DatabaseSyncLimits::LimitsSetter( return Intercepted::kNo; } - DatabaseSyncLimits* limits; + DatabaseLimits* limits; ASSIGN_OR_RETURN_UNWRAP(&limits, info.HolderV2(), Intercepted::kNo); Environment* env = limits->env(); @@ -973,7 +973,7 @@ Intercepted DatabaseSyncLimits::LimitsSetter( return Intercepted::kYes; } -Intercepted DatabaseSyncLimits::LimitsQuery( +Intercepted DatabaseLimits::LimitsQuery( Local property, const PropertyCallbackInfo& info) { if (!property->IsString()) { return Intercepted::kNo; @@ -994,8 +994,7 @@ Intercepted DatabaseSyncLimits::LimitsQuery( return Intercepted::kYes; } -void DatabaseSyncLimits::LimitsEnumerator( - const PropertyCallbackInfo& info) { +void DatabaseLimits::LimitsEnumerator(const PropertyCallbackInfo& info) { Isolate* isolate = info.GetIsolate(); LocalVector names(isolate); @@ -1012,21 +1011,21 @@ void DatabaseSyncLimits::LimitsEnumerator( info.GetReturnValue().Set(Array::New(isolate, names.data(), names.size())); } -BaseObjectPtr DatabaseSyncLimits::Create( - Environment* env, BaseObjectWeakPtr database) { +BaseObjectPtr DatabaseLimits::Create( + Environment* env, BaseObjectWeakPtr database) { Local obj; if (!GetTemplate(env)->NewInstance(env->context()).ToLocal(&obj)) { return nullptr; } - return MakeBaseObject(env, obj, std::move(database)); + return MakeBaseObject(env, obj, std::move(database)); } -DatabaseSync::DatabaseSync(Environment* env, - Local object, - DatabaseOpenConfiguration&& open_config, - bool open, - bool allow_load_extension) +Database::Database(Environment* env, + Local 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; @@ -1041,15 +1040,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> DatabaseSync::PinSessions() const { +std::vector> Database::PinSessions() const { std::vector> pinned; pinned.reserve(sessions_.size()); for (Session* session : sessions_) { @@ -1058,7 +1057,7 @@ std::vector> 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()) { @@ -1066,7 +1065,7 @@ void DatabaseSync::DeleteSessions() { } } -DatabaseSync::~DatabaseSync() { +Database::~Database() { BindingData* binding = env()->principal_realm()->GetBindingData(); if (binding != nullptr) binding->open_databases.erase(this); @@ -1080,7 +1079,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 @@ -1088,7 +1087,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; @@ -1180,7 +1179,7 @@ bool DatabaseSync::Open() { return true; } -void DatabaseSync::EnableTracing() { +void Database::EnableTracing() { if (!IsOpen()) return; if (!trace_channel_) { trace_channel_ = @@ -1190,12 +1189,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(); } @@ -1203,7 +1202,7 @@ void DatabaseSync::FinalizeBackups() { backups_.clear(); } -void DatabaseSync::FinalizeStatements() { +void Database::FinalizeStatements() { for (auto stmt : statements_) { stmt->Finalize(); } @@ -1211,28 +1210,28 @@ void DatabaseSync::FinalizeStatements() { statements_.clear(); } -void DatabaseSync::UntrackStatement(StatementSync* statement) { +void Database::UntrackStatement(StatementSync* 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& args) { - DatabaseSync* db = BaseObject::Unwrap(args.This()); +void Database::CreateTagStore(const FunctionCallbackInfo& args) { + Database* db = BaseObject::Unwrap(args.This()); Environment* env = Environment::GetCurrent(args); if (!db->IsOpen()) { @@ -1259,7 +1258,7 @@ void DatabaseSync::CreateTagStore(const FunctionCallbackInfo& args) { capacity = static_cast(val); } BaseObjectPtr session = - SQLTagStore::Create(env, BaseObjectWeakPtr(db), capacity); + SQLTagStore::Create(env, BaseObjectWeakPtr(db), capacity); if (!session) { // Handle error if creation failed THROW_ERR_SQLITE_ERROR(env->isolate(), "Failed to create SQLTagStore"); @@ -1315,7 +1314,7 @@ std::optional ValidateDatabasePath(Environment* env, return std::nullopt; } -void DatabaseSync::New(const FunctionCallbackInfo& args) { +void Database::New(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args); if (!args.IsConstructCall()) { THROW_ERR_CONSTRUCT_CALL_REQUIRED(env); @@ -1570,33 +1569,32 @@ void DatabaseSync::New(const FunctionCallbackInfo& args) { } } - new DatabaseSync( + new Database( env, args.This(), std::move(open_config), open, allow_load_extension); } -void DatabaseSync::Open(const FunctionCallbackInfo& args) { - DatabaseSync* db; +void Database::Open(const FunctionCallbackInfo& args) { + Database* db; ASSIGN_OR_RETURN_UNWRAP(&db, args.This()); db->Open(); } -void DatabaseSync::IsOpenGetter(const FunctionCallbackInfo& args) { - DatabaseSync* db; +void Database::IsOpenGetter(const FunctionCallbackInfo& args) { + Database* db; ASSIGN_OR_RETURN_UNWRAP(&db, args.This()); args.GetReturnValue().Set(db->IsOpen()); } -void DatabaseSync::IsTransactionGetter( - const FunctionCallbackInfo& args) { - DatabaseSync* db; +void Database::IsTransactionGetter(const FunctionCallbackInfo& 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& args) { - DatabaseSync* db; +void Database::LimitsGetter(const FunctionCallbackInfo& args) { + Database* db; ASSIGN_OR_RETURN_UNWRAP(&db, args.This()); Environment* env = Environment::GetCurrent(args); @@ -1604,8 +1602,8 @@ void DatabaseSync::LimitsGetter(const FunctionCallbackInfo& args) { db->object()->GetInternalField(kLimitsObject).template As(); if (limits_val->IsUndefined()) { - BaseObjectPtr limits = - DatabaseSyncLimits::Create(env, BaseObjectWeakPtr(db)); + BaseObjectPtr limits = + DatabaseLimits::Create(env, BaseObjectWeakPtr(db)); if (limits) { db->object()->SetInternalField(kLimitsObject, limits->object()); args.GetReturnValue().Set(limits->object()); @@ -1615,8 +1613,8 @@ void DatabaseSync::LimitsGetter(const FunctionCallbackInfo& args) { } } -void DatabaseSync::Close(const FunctionCallbackInfo& args) { - DatabaseSync* db; +void Database::Close(const FunctionCallbackInfo& 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"); @@ -1631,7 +1629,7 @@ void DatabaseSync::Close(const FunctionCallbackInfo& args) { db->user_defined_functions_.clear(); } -void DatabaseSync::Dispose(const v8::FunctionCallbackInfo& args) { +void Database::Dispose(const v8::FunctionCallbackInfo& args) { v8::TryCatch try_catch(args.GetIsolate()); Close(args); if (try_catch.HasCaught()) { @@ -1639,8 +1637,8 @@ void DatabaseSync::Dispose(const v8::FunctionCallbackInfo& args) { } } -void DatabaseSync::Prepare(const FunctionCallbackInfo& args) { - DatabaseSync* db; +void Database::Prepare(const FunctionCallbackInfo& 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"); @@ -1783,7 +1781,7 @@ void DatabaseSync::Prepare(const FunctionCallbackInfo& args) { } BaseObjectPtr stmt = StatementSync::Create( - env, BaseObjectPtr(db), std::move(stmt_ptr)); + env, BaseObjectPtr(db), std::move(stmt_ptr)); if (!stmt) { return; } @@ -1805,8 +1803,8 @@ void DatabaseSync::Prepare(const FunctionCallbackInfo& args) { args.GetReturnValue().Set(stmt->object()); } -void DatabaseSync::Exec(const FunctionCallbackInfo& args) { - DatabaseSync* db; +void Database::Exec(const FunctionCallbackInfo& 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"); @@ -1821,17 +1819,17 @@ void DatabaseSync::Exec(const FunctionCallbackInfo& 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 guard(db); + BaseObjectPtr guard(db); Utf8Value sql(env->isolate(), args[0].As()); 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& args) { - DatabaseSync* db; +void Database::CustomFunction(const FunctionCallbackInfo& 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"); @@ -1964,7 +1962,7 @@ void DatabaseSync::CustomFunction(const FunctionCallbackInfo& args) { THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open"); UserDefinedFunction* user_data = new UserDefinedFunction( - env, fn, BaseObjectWeakPtr(db), use_bigint_args); + env, fn, BaseObjectWeakPtr(db), use_bigint_args); int text_rep = SQLITE_UTF8; if (deterministic) { @@ -1987,8 +1985,8 @@ void DatabaseSync::CustomFunction(const FunctionCallbackInfo& args) { CHECK_ERROR_OR_THROW(env->isolate(), db, r, SQLITE_OK, void()); } -void DatabaseSync::Location(const FunctionCallbackInfo& args) { - DatabaseSync* db; +void Database::Location(const FunctionCallbackInfo& 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"); @@ -2017,8 +2015,8 @@ void DatabaseSync::Location(const FunctionCallbackInfo& args) { } } -void DatabaseSync::Serialize(const FunctionCallbackInfo& args) { - DatabaseSync* db; +void Database::Serialize(const FunctionCallbackInfo& 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"); @@ -2063,8 +2061,8 @@ void DatabaseSync::Serialize(const FunctionCallbackInfo& args) { args.GetReturnValue().Set(Uint8Array::New(ab, 0, size)); } -void DatabaseSync::Deserialize(const FunctionCallbackInfo& args) { - DatabaseSync* db; +void Database::Deserialize(const FunctionCallbackInfo& 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"); @@ -2155,8 +2153,8 @@ void DatabaseSync::Deserialize(const FunctionCallbackInfo& args) { } } -void DatabaseSync::AggregateFunction(const FunctionCallbackInfo& args) { - DatabaseSync* db; +void Database::AggregateFunction(const FunctionCallbackInfo& 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"); @@ -2320,7 +2318,7 @@ void DatabaseSync::AggregateFunction(const FunctionCallbackInfo& args) { argc, text_rep, new CustomAggregate(env, - BaseObjectWeakPtr(db), + BaseObjectWeakPtr(db), use_bigint_args, start_v, stepFunction, @@ -2334,8 +2332,8 @@ void DatabaseSync::AggregateFunction(const FunctionCallbackInfo& args) { CHECK_ERROR_OR_THROW(env->isolate(), db, r, SQLITE_OK, void()); } -void DatabaseSync::CreateSession(const FunctionCallbackInfo& args) { - DatabaseSync* db; +void Database::CreateSession(const FunctionCallbackInfo& 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"); @@ -2413,7 +2411,7 @@ void DatabaseSync::CreateSession(const FunctionCallbackInfo& args) { CHECK_ERROR_OR_THROW(env->isolate(), db, r, SQLITE_OK, void()); BaseObjectPtr session = - Session::Create(env, BaseObjectPtr(db), pSession); + Session::Create(env, BaseObjectPtr(db), pSession); if (!session) { return; } @@ -2429,7 +2427,7 @@ void Backup(const FunctionCallbackInfo& args) { return; } - DatabaseSync* db; + Database* db; ASSIGN_OR_RETURN_UNWRAP(&db, args[0].As()); THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open"); std::optional dest_path = @@ -2565,10 +2563,10 @@ static int xFilter(void* pCtx, const char* zTab) { return ctx->filterCallback(zTab) ? 1 : 0; } -void DatabaseSync::ApplyChangeset(const FunctionCallbackInfo& args) { +void Database::ApplyChangeset(const FunctionCallbackInfo& 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"); @@ -2677,7 +2675,7 @@ void DatabaseSync::ApplyChangeset(const FunctionCallbackInfo& 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 guard(db); + BaseObjectPtr guard(db); ArrayBufferViewContents buf(args[0]); if (buf.length() > std::numeric_limits::max()) { @@ -2726,9 +2724,8 @@ void DatabaseSync::ApplyChangeset(const FunctionCallbackInfo& args) { THROW_ERR_SQLITE_ERROR(env->isolate(), r); } -void DatabaseSync::EnableLoadExtension( - const FunctionCallbackInfo& args) { - DatabaseSync* db; +void Database::EnableLoadExtension(const FunctionCallbackInfo& 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"); @@ -2759,8 +2756,8 @@ void DatabaseSync::EnableLoadExtension( CHECK_ERROR_OR_THROW(isolate, db, load_extension_ret, SQLITE_OK, void()); } -void DatabaseSync::EnableDefensive(const FunctionCallbackInfo& args) { - DatabaseSync* db; +void Database::EnableDefensive(const FunctionCallbackInfo& 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"); @@ -2782,8 +2779,8 @@ void DatabaseSync::EnableDefensive(const FunctionCallbackInfo& args) { CHECK_ERROR_OR_THROW(isolate, db, defensive_ret, SQLITE_OK, void()); } -void DatabaseSync::LoadExtension(const FunctionCallbackInfo& args) { - DatabaseSync* db; +void Database::LoadExtension(const FunctionCallbackInfo& args) { + Database* db; ASSIGN_OR_RETURN_UNWRAP(&db, args.This()); Environment* env = Environment::GetCurrent(args); THROW_AND_RETURN_ON_BAD_STATE( @@ -2816,8 +2813,8 @@ void DatabaseSync::LoadExtension(const FunctionCallbackInfo& args) { } } -void DatabaseSync::SetAuthorizer(const FunctionCallbackInfo& args) { - DatabaseSync* db; +void Database::SetAuthorizer(const FunctionCallbackInfo& 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"); @@ -2843,20 +2840,20 @@ void DatabaseSync::SetAuthorizer(const FunctionCallbackInfo& 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(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(user_data); CallbackDepthGuard guard(db); AuthorizerDepthGuard authorizer_guard(db); Environment* env = db->env(); @@ -2926,15 +2923,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(user_data); + Database* db = static_cast(user_data); Environment* env = db->env(); diagnostics_channel::Channel* ch = db->trace_channel_.get(); @@ -2992,7 +2989,7 @@ int DatabaseSync::TraceCallback(unsigned int type, StatementSync::StatementSync(Environment* env, Local object, - BaseObjectPtr db, + BaseObjectPtr db, StatementPtr stmt) : BaseObject(env, object), db_(std::move(db)), statement_(std::move(stmt)) { MakeWeak(); @@ -3310,7 +3307,7 @@ Maybe ExtractRowValues(Environment* env, MaybeLocal StatementExecutionHelper::All(Environment* env, StatementSync* statement) { - DatabaseSync* db = statement->db_.get(); + 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_; @@ -3358,7 +3355,7 @@ MaybeLocal StatementExecutionHelper::All(Environment* env, MaybeLocal StatementExecutionHelper::Run(Environment* env, StatementSync* statement) { - DatabaseSync* db = statement->db_.get(); + Database* db = statement->db_.get(); sqlite3_stmt* stmt = statement->statement_.get(); const bool use_big_ints = statement->use_big_ints_; Isolate* isolate = env->isolate(); @@ -3446,7 +3443,7 @@ BaseObjectPtr StatementExecutionHelper::Iterate( MaybeLocal StatementExecutionHelper::Get(Environment* env, StatementSync* statement) { - DatabaseSync* db = statement->db_.get(); + 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_; @@ -3807,7 +3804,7 @@ void IllegalConstructor(const FunctionCallbackInfo& args) { SQLTagStore::SQLTagStore(Environment* env, Local object, - BaseObjectWeakPtr database, + BaseObjectWeakPtr database, int capacity) : BaseObject(env, object), database_(std::move(database)), @@ -3857,7 +3854,7 @@ Local SQLTagStore::GetConstructorTemplate(Environment* env) { } BaseObjectPtr SQLTagStore::Create( - Environment* env, BaseObjectWeakPtr database, int capacity) { + Environment* env, BaseObjectWeakPtr database, int capacity) { Local obj; if (!GetConstructorTemplate(env) ->InstanceTemplate() @@ -4107,17 +4104,15 @@ BaseObjectPtr SQLTagStore::PrepareStatement( return BaseObjectPtr(); } - // 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(); } - BaseObjectPtr stmt_obj = - StatementSync::Create(env, - BaseObjectPtr(session->database_), - std::move(stmt_ptr)); + BaseObjectPtr stmt_obj = StatementSync::Create( + env, BaseObjectPtr(session->database_), std::move(stmt_ptr)); if (!stmt_obj) { THROW_ERR_SQLITE_ERROR(isolate, "Failed to create StatementSync"); @@ -4188,8 +4183,9 @@ Local StatementSync::GetConstructorTemplate( return tmpl; } -BaseObjectPtr StatementSync::Create( - Environment* env, BaseObjectPtr db, StatementPtr stmt) { +BaseObjectPtr StatementSync::Create(Environment* env, + BaseObjectPtr db, + StatementPtr stmt) { Local obj; if (!GetConstructorTemplate(env) ->InstanceTemplate() @@ -4367,7 +4363,7 @@ void StatementSyncIterator::Return(const FunctionCallbackInfo& args) { Session::Session(Environment* env, Local object, - BaseObjectPtr database, + BaseObjectPtr database, sqlite3_session* session) : BaseObject(env, object), session_(std::unique_ptr(session)), @@ -4381,7 +4377,7 @@ Session::~Session() { } BaseObjectPtr Session::Create(Environment* env, - BaseObjectPtr database, + BaseObjectPtr database, sqlite3_session* session) { Local obj; if (!GetConstructorTemplate(env) @@ -4565,7 +4561,7 @@ static void Initialize(Local 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 @@ -4573,54 +4569,44 @@ static void Initialize(Local target, } }); } - Local db_tmpl = - NewFunctionTemplate(isolate, DatabaseSync::New); + Local db_tmpl = NewFunctionTemplate(isolate, Database::New); db_tmpl->InstanceTemplate()->SetInternalFieldCount( - DatabaseSync::kInternalFieldCount); + Database::kInternalFieldCount); Local 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); + 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); 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 sqlite_type_key = FIXED_ONE_BYTE_STRING(isolate, "sqlite-type"); Local sqlite_type_symbol = v8::Symbol::For(isolate, sqlite_type_key); @@ -4628,7 +4614,7 @@ static void Initialize(Local 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", diff --git a/src/node_sqlite.h b/src/node_sqlite.h index 5b91e27d5736..741d4636b0dd 100644 --- a/src/node_sqlite.h +++ b/src/node_sqlite.h @@ -162,8 +162,8 @@ class DatabaseOpenConfiguration { std::array, kLimitMapping.size()> initial_limits_{}; }; -class DatabaseSync; -class DatabaseSyncLimits; +class Database; +class DatabaseLimits; class StatementSyncIterator; class StatementSync; class BackupJob; @@ -191,7 +191,7 @@ class StatementExecutionHelper { StatementSync* statement); }; -class DatabaseSync; +class Database; class BindingData : public BaseObject { public: @@ -203,7 +203,7 @@ class BindingData : public BaseObject { SET_MEMORY_INFO_NAME(BindingData) SET_SELF_SIZE(BindingData) - std::unordered_set open_databases; + std::unordered_set open_databases; static void CreatePerContextProperties(v8::Local target, v8::Local unused, @@ -212,7 +212,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 +220,11 @@ class DatabaseSync : public BaseObject { kInternalFieldCount }; - DatabaseSync(Environment* env, - v8::Local object, - DatabaseOpenConfiguration&& open_config, - bool open, - bool allow_load_extension); + Database(Environment* env, + v8::Local object, + DatabaseOpenConfiguration&& open_config, + bool open, + bool allow_load_extension); void MemoryInfo(MemoryTracker* tracker) const override; static void New(const v8::FunctionCallbackInfo& args); static void Open(const v8::FunctionCallbackInfo& args); @@ -323,14 +323,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_; @@ -354,7 +354,7 @@ class DatabaseSync : public BaseObject { friend class UserDefinedFunction; friend class CustomAggregate; - friend class DatabaseSyncLimits; + friend class DatabaseLimits; friend class Session; friend class SQLTagStore; friend class StatementExecutionHelper; @@ -364,13 +364,13 @@ class StatementSync : public BaseObject { public: StatementSync(Environment* env, v8::Local object, - BaseObjectPtr db, + BaseObjectPtr db, StatementPtr stmt); void MemoryInfo(MemoryTracker* tracker) const override; static v8::Local GetConstructorTemplate( Environment* env); static BaseObjectPtr Create(Environment* env, - BaseObjectPtr db, + BaseObjectPtr db, StatementPtr stmt); static void All(const v8::FunctionCallbackInfo& args); static void Iterate(const v8::FunctionCallbackInfo& args); @@ -402,7 +402,7 @@ class StatementSync : public BaseObject { private: ~StatementSync() override; void Close(); - BaseObjectPtr db_; + BaseObjectPtr db_; StatementPtr statement_; bool return_arrays_ = false; bool use_big_ints_; @@ -417,7 +417,7 @@ class StatementSync : public BaseObject { bool BindParams(const v8::FunctionCallbackInfo& args); bool BindValue(const v8::Local& value, const int index); - friend class DatabaseSync; + friend class Database; friend class StatementSyncIterator; friend class SQLTagStore; friend class StatementExecutionHelper; @@ -452,7 +452,7 @@ class Session : public BaseObject { public: Session(Environment* env, v8::Local object, - BaseObjectPtr database, + BaseObjectPtr database, sqlite3_session* session); ~Session() override; template @@ -462,7 +462,7 @@ class Session : public BaseObject { static v8::Local GetConstructorTemplate( Environment* env); static BaseObjectPtr Create(Environment* env, - BaseObjectPtr database, + BaseObjectPtr database, sqlite3_session* session); void MemoryInfo(MemoryTracker* tracker) const override; @@ -475,10 +475,10 @@ class Session : public BaseObject { void operator()(sqlite3_session* s) const { sqlite3session_delete(s); } }; std::unique_ptr session_; - BaseObjectPtr database_; // The Parent Database + BaseObjectPtr database_; // The Parent Database bool is_generating_changeset_ = false; - friend class DatabaseSync; + friend class Database; }; class SQLTagStore : public BaseObject { @@ -490,11 +490,12 @@ class SQLTagStore : public BaseObject { SQLTagStore(Environment* env, v8::Local object, - BaseObjectWeakPtr database, + BaseObjectWeakPtr database, int capacity); ~SQLTagStore() override; - static BaseObjectPtr Create( - Environment* env, BaseObjectWeakPtr database, int capacity); + static BaseObjectPtr Create(Environment* env, + BaseObjectWeakPtr database, + int capacity); static v8::Local GetConstructorTemplate( Environment* env); static void All(const v8::FunctionCallbackInfo& args); @@ -516,7 +517,7 @@ class SQLTagStore : public BaseObject { Environment* env, StatementSync* stmt, const v8::FunctionCallbackInfo& args); - BaseObjectWeakPtr database_; + BaseObjectWeakPtr database_; LRUCache> sql_tags_; friend class StatementExecutionHelper; }; @@ -526,7 +527,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(); } @@ -535,13 +536,13 @@ class CallbackDepthGuard { CallbackDepthGuard& operator=(const CallbackDepthGuard&) = delete; private: - DatabaseSync* db_; + Database* db_; std::vector> pinned_sessions_; }; class TraceEventSuppressionGuard { public: - explicit TraceEventSuppressionGuard(DatabaseSync* db) : db_(db) { + explicit TraceEventSuppressionGuard(Database* db) : db_(db) { db_->IncrementTraceSuppressionDepth(); } ~TraceEventSuppressionGuard() { db_->DecrementTraceSuppressionDepth(); } @@ -550,12 +551,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(); } @@ -563,12 +564,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(); } @@ -576,14 +577,14 @@ class AuthorizerDepthGuard { AuthorizerDepthGuard& operator=(const AuthorizerDepthGuard&) = delete; private: - DatabaseSync* db_; + Database* db_; }; class UserDefinedFunction { public: UserDefinedFunction(Environment* env, v8::Local fn, - BaseObjectWeakPtr db, + BaseObjectWeakPtr db, bool use_bigint_args); ~UserDefinedFunction(); static void xFunc(sqlite3_context* ctx, int argc, sqlite3_value** argv); @@ -592,21 +593,21 @@ class UserDefinedFunction { private: Environment* env_; v8::Global fn_; - BaseObjectWeakPtr db_; + BaseObjectWeakPtr db_; bool use_bigint_args_; }; -class DatabaseSyncLimits : public BaseObject { +class DatabaseLimits : public BaseObject { public: - DatabaseSyncLimits(Environment* env, - v8::Local object, - BaseObjectWeakPtr database); - ~DatabaseSyncLimits() override; + DatabaseLimits(Environment* env, + v8::Local object, + BaseObjectWeakPtr database); + ~DatabaseLimits() override; void MemoryInfo(MemoryTracker* tracker) const override; static v8::Local GetTemplate(Environment* env); - static BaseObjectPtr Create( - Environment* env, BaseObjectWeakPtr database); + static BaseObjectPtr Create( + Environment* env, BaseObjectWeakPtr database); static v8::Intercepted LimitsGetter( v8::Local property, @@ -620,11 +621,11 @@ class DatabaseSyncLimits : public BaseObject { const v8::PropertyCallbackInfo& info); static void LimitsEnumerator(const v8::PropertyCallbackInfo& info); - SET_MEMORY_INFO_NAME(DatabaseSyncLimits) - SET_SELF_SIZE(DatabaseSyncLimits) + SET_MEMORY_INFO_NAME(DatabaseLimits) + SET_SELF_SIZE(DatabaseLimits) private: - BaseObjectWeakPtr database_; + BaseObjectWeakPtr database_; }; } // namespace sqlite diff --git a/test/fixtures/sqlite/backup-last-request.mjs b/test/fixtures/sqlite/backup-last-request.mjs index 91ad84e77ed5..a68adf302343 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 def6f3d12699..e87849ffb2de 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 6c921b866cbe..f588cc3ee680 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 eda923e258b9..db241dd951f1 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 f995ae3ca72a..6e6872e9b2ba 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(); }); @@ -331,7 +331,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). @@ -349,12 +349,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(); @@ -364,7 +364,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 d1a6cae2d744..0988bdb14a3f 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 0b783ce9bcf6..20b16138813a 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 516233fcb0e8..473e504ead26 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 08a636c9cbdc..a8676b47b5c6 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, StatementSync } = 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,7 +53,7 @@ suite('DatabaseSync() constructor', () => { 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/, @@ -62,7 +62,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/, @@ -71,7 +71,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/, @@ -80,7 +80,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/, @@ -89,18 +89,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)'); }, { @@ -112,7 +112,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/, @@ -121,7 +121,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)); @@ -136,7 +136,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)); @@ -146,7 +146,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/, @@ -155,7 +155,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";'); }, { @@ -166,13 +166,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.', @@ -181,7 +181,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; @@ -201,7 +201,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.', @@ -210,7 +210,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'); @@ -224,7 +224,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.', @@ -233,7 +233,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;' ); @@ -250,7 +250,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.', @@ -259,7 +259,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;' ); @@ -275,17 +275,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); @@ -295,7 +295,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(); @@ -313,7 +313,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(() => { @@ -346,9 +346,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); @@ -356,7 +356,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(() => { @@ -369,15 +369,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); }); 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(); @@ -388,7 +388,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(); @@ -399,7 +399,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(() => { @@ -412,7 +412,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', @@ -425,9 +425,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, @@ -445,7 +445,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'); @@ -457,7 +457,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:', @@ -465,7 +465,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(); @@ -476,7 +476,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(); @@ -487,9 +487,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'); @@ -501,7 +501,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'); @@ -513,7 +513,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; @@ -524,9 +524,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(); @@ -537,7 +537,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); @@ -548,20 +548,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("'", "''"); @@ -571,16 +571,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 8b0776c969d7..eb9461f337d5 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 1a038df05445..c41cbf2e773d 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 fd0a209b6b0b..d8309d2f5f81 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;' @@ -72,7 +72,7 @@ suite('named parameters', () => { suite('StatementSync.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 1aaf4c4fbb79..f55426c290dc 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,11 +85,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() { @@ -101,7 +101,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() { @@ -113,7 +113,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)'); @@ -130,7 +130,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() { @@ -145,7 +145,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(); @@ -177,7 +177,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]; @@ -196,7 +196,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(); @@ -206,7 +206,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() { @@ -221,14 +221,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 e54cfa3c6a75..29e02699cb0c 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 40da13c4bb7f..d64c630fa2c7 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'; @@ -842,7 +842,7 @@ suite('session.close() - from a callback', () => { // with StatementSync'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 052803e72a88..2ac911d5b196 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-sync-columns.js index a0c3fbd74347..7773e74fa5be 100644 --- a/test/parallel/test-sqlite-statement-sync-columns.js +++ b/test/parallel/test-sqlite-statement-sync-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()', () => { 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-sync.js index 44eb482f9bdb..c2f3dd4cbaa9 100644 --- a/test/parallel/test-sqlite-statement-sync.js +++ b/test/parallel/test-sqlite-statement-sync.js @@ -2,7 +2,7 @@ 'use strict'; const { skipIfSQLiteMissing } = require('../common'); skipIfSQLiteMissing(); -const { DatabaseSync, StatementSync } = require('node:sqlite'); +const { Database, StatementSync } = require('node:sqlite'); const { suite, test } = require('node:test'); suite('StatementSync() constructor', () => { @@ -18,7 +18,7 @@ suite('StatementSync() constructor', () => { suite('StatementSync.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; @@ -102,13 +102,13 @@ suite('StatementSync.prototype.get()', () => { suite('StatementSync.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; @@ -184,7 +184,7 @@ suite('StatementSync.prototype.all()', () => { suite('StatementSync.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'); @@ -395,7 +395,7 @@ suite('StatementSync.prototype.iterate()', () => { suite('StatementSync.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(() => { @@ -501,7 +501,7 @@ suite('StatementSync.prototype.run()', () => { suite('StatementSync.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, { @@ -524,7 +524,7 @@ suite('StatementSync.prototype.sourceSQL', () => { suite('StatementSync.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, { @@ -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'), { @@ -654,7 +654,7 @@ suite('StatementSync.prototype.stat()', () => { suite('StatementSync.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(), { @@ -758,7 +758,7 @@ suite('StatementSync.prototype.resetStats()', () => { suite('StatementSync.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(() => { @@ -855,7 +855,7 @@ suite('StatementSync.prototype.setReadBigInts()', () => { suite('StatementSync.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(() => { @@ -884,7 +884,7 @@ suite('StatementSync.prototype.setReturnArrays()', () => { suite('StatementSync.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); @@ -921,7 +921,7 @@ suite('StatementSync.prototype.get() with array output', () => { suite('StatementSync.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, @@ -985,7 +985,7 @@ suite('StatementSync.prototype.all() with array output', () => { suite('StatementSync.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'); @@ -1053,7 +1053,7 @@ suite('StatementSync.prototype.iterate() with array output', () => { suite('StatementSync.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;' ); @@ -1339,7 +1339,7 @@ suite('options.allowBareNamedParameters', () => { suite('StatementSync.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(() => { @@ -1364,7 +1364,7 @@ suite('StatementSync.prototype.close()', () => { suite('StatementSync.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 eaa6d19fc7cd..f7a5053a3301 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 aa3fdae67607..97d40bffc736 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 963e7126a101..3a37a05b3304 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 5236c182e061..84aa42f7a106 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; @@ -27,7 +27,7 @@ const TypedArrays = [ suite('StatementSync 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 @@ -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 cb11e50a7f7a..5a9454d81401 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.js b/test/parallel/test-sqlite.js index b7b65f1258f0..a49a6006242d 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 ece230399c73..b1d88bb5ee75 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 8d1ca2420c93..912ed1374f9a 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) {