{ "type": "module", "source": "doc/api/sqlite.md", "modules": [ { "textRaw": "SQLite", "name": "sqlite", "introduced_in": "v22.5.0", "type": "module", "meta": { "added": [ "v22.5.0" ], "changes": [ { "version": "v25.7.0", "pr-url": "https://github.com/nodejs/node/pull/61262", "description": "SQLite is now a release candidate." }, { "version": [ "v23.4.0", "v22.13.0" ], "pr-url": "https://github.com/nodejs/node/pull/55890", "description": "SQLite is no longer behind `--experimental-sqlite` but still experimental." } ] }, "stability": 1.2, "stabilityText": "Release candidate.", "desc": "

The node:sqlite module facilitates working with SQLite databases.\nTo access it:

import sqlite from 'node:sqlite';\n

const sqlite = require('node:sqlite');\n

This module is only available under the node: scheme. SQL trace events can\nbe observed via the diagnostics_channel module. See\n'sqlite.db.query' for details.

The following example shows the basic usage of the node:sqlite module to open\nan in-memory database, write data to the database, and then read the data back.

import { DatabaseSync } from 'node:sqlite';\nconst database = new DatabaseSync(':memory:');\n\n// Execute SQL statements from strings.\ndatabase.exec(`\n  CREATE TABLE data(\n    key INTEGER PRIMARY KEY,\n    value TEXT\n  ) STRICT\n`);\n// Create a prepared statement to insert data into the database.\nconst insert = database.prepare('INSERT INTO data (key, value) VALUES (?, ?)');\n// Execute the prepared statement with bound values.\ninsert.run(1, 'hello');\ninsert.run(2, 'world');\n// Finalize the prepared statement once it is no longer needed.\ninsert.close();\n// Create a prepared statement to read data from the database.\nconst query = database.prepare('SELECT * FROM data ORDER BY key');\n// Execute the prepared statement and log the result set.\nconsole.log(query.all());\n// Prints: [ { key: 1, value: 'hello' }, { key: 2, value: 'world' } ]\nquery.close();\n

const { DatabaseSync } = require('node:sqlite');\nconst database = new DatabaseSync(':memory:');\n\n// Execute SQL statements from strings.\ndatabase.exec(`\n  CREATE TABLE data(\n    key INTEGER PRIMARY KEY,\n    value TEXT\n  ) STRICT\n`);\n// Create a prepared statement to insert data into the database.\nconst insert = database.prepare('INSERT INTO data (key, value) VALUES (?, ?)');\n// Execute the prepared statement with bound values.\ninsert.run(1, 'hello');\ninsert.run(2, 'world');\n// Finalize the prepared statement once it is no longer needed.\ninsert.close();\n// Create a prepared statement to read data from the database.\nconst query = database.prepare('SELECT * FROM data ORDER BY key');\n// Execute the prepared statement and log the result set.\nconsole.log(query.all());\n// Prints: [ { key: 1, value: 'hello' }, { key: 2, value: 'world' } ]\nquery.close();\n

When Node.js writes to or reads from SQLite, it is necessary to convert between\nJavaScript data types and SQLite's data types. Because JavaScript supports\nmore data types than SQLite, only a subset of JavaScript types are supported.\nAttempting to write an unsupported data type to SQLite will result in an\nexception.

Booleans are written as the INTEGER values 1 and 0. Like any other\nINTEGER value, they are read back as number by default, or as bigint\nvalues (1n and 0n) when reading BigInts is enabled. Writing a bigint that\ndoes not fit in a signed 64-bit integer throws an ERR_INVALID_ARG_VALUE\nerror.

APIs that read values from SQLite have a configuration option that determines\nwhether INTEGER values are converted to number or bigint in JavaScript,\nsuch as the readBigInts option for statements and the useBigIntArguments\noption for user-defined functions. If Node.js reads an INTEGER value from\nSQLite that is outside the JavaScript safe integer range, and the option to\nread BigInts is not enabled, then an ERR_OUT_OF_RANGE error will be thrown.

This class represents a single connection to a SQLite database. All APIs\nexposed by this class execute synchronously.

Constructs a new DatabaseSync instance.

Registers a new aggregate function with the SQLite database. This method is a wrapper around\nsqlite3_create_window_function().

When used as a window function, the result function will be called multiple times.

const { DatabaseSync } = require('node:sqlite');\n\nconst db = new DatabaseSync(':memory:');\ndb.exec(`\n  CREATE TABLE t3(x, y);\n  INSERT INTO t3 VALUES ('a', 4),\n                        ('b', 5),\n                        ('c', 3),\n                        ('d', 8),\n                        ('e', 1);\n`);\n\ndb.aggregate('sumint', {\n  start: 0,\n  step: (acc, value) => acc + value,\n});\n\nusing query = db.prepare('SELECT sumint(y) as total FROM t3');\nquery.get(); // { total: 21 }\n

import { DatabaseSync } from 'node:sqlite';\n\nconst db = new DatabaseSync(':memory:');\ndb.exec(`\n  CREATE TABLE t3(x, y);\n  INSERT INTO t3 VALUES ('a', 4),\n                        ('b', 5),\n                        ('c', 3),\n                        ('d', 8),\n                        ('e', 1);\n`);\n\ndb.aggregate('sumint', {\n  start: 0,\n  step: (acc, value) => acc + value,\n});\n\nusing query = db.prepare('SELECT sumint(y) as total FROM t3');\nquery.get(); // { total: 21 }\n

Closes the database connection. An exception is thrown if the database is not\nopen. An ERR_INVALID_STATE error is thrown if the method is called while\na statement is executing, such as inside a user-defined function, an aggregate\nfunction, an authorizer callback, or a 'sqlite.db.query' subscriber. This\nmethod is a wrapper around sqlite3_close_v2().

Loads a shared library into the database connection. This method is a wrapper\naround sqlite3_load_extension(). It is required to enable the\nallowExtension option when constructing the DatabaseSync instance.

import { DatabaseSync } from 'node:sqlite';\nconst database = new DatabaseSync(':memory:', { allowExtension: true });\n\n// Load using the entry point derived from the filename.\ndatabase.loadExtension('./decimal.dylib');\n\n// Override the entry point when the derived name does not match.\ndatabase.loadExtension('./base64.dylib', 'sqlite3_base64_init');\n

const { DatabaseSync } = require('node:sqlite');\nconst database = new DatabaseSync(':memory:', { allowExtension: true });\n\n// Load using the entry point derived from the filename.\ndatabase.loadExtension('./decimal.dylib');\n\n// Override the entry point when the derived name does not match.\ndatabase.loadExtension('./base64.dylib', 'sqlite3_base64_init');\n

Enables or disables the loadExtension SQL function, and the loadExtension()\nmethod. When allowExtension is false when constructing, you cannot enable\nloading extensions for security reasons.

Enables or disables the defensive flag. When the defensive flag is active,\nlanguage features that allow ordinary SQL to deliberately corrupt the database file are disabled.\nSee SQLITE_DBCONFIG_DEFENSIVE in the SQLite documentation for details.

This method is a wrapper around sqlite3_db_filename()

This method allows one or more SQL statements to be executed without returning\nany results. This method is useful when executing SQL statements read from a\nfile. This method is a wrapper around sqlite3_exec().

This method is used to create SQLite user-defined functions. This method is a\nwrapper around sqlite3_create_function_v2().

Sets an authorizer callback that SQLite will invoke whenever it attempts to\naccess data or modify the database schema through prepared statements.\nThis can be used to implement security policies, audit access, or restrict certain operations.\nThis method is a wrapper around sqlite3_set_authorizer().

When invoked, the callback receives five arguments:

\n
• actionCode number The type of operation being performed (e.g.,\nSQLITE_INSERT, SQLITE_UPDATE, SQLITE_SELECT).
\n
• arg1 string | null The first argument (context-dependent, often a table name).
\n
• arg2 string | null The second argument (context-dependent, often a column name).
\n
• dbName string | null The name of the database.
\n
• triggerOrView string | null The name of the trigger or view causing the access.
\n

The callback must return one of the following constants:

\n
• SQLITE_OK - Allow the operation.
\n
• SQLITE_DENY - Deny the operation (causes an error).
\n
• SQLITE_IGNORE - Ignore the operation (silently skip).
\n

SQLite requires that the authorizer callback not modify the database connection\nthat invoked it, which includes preparing and stepping statements. Methods that\nwould do so throw an error with code ERR_INVALID_STATE while the callback is\non the stack, including database.prepare(), database.exec(), the execution\nmethods of that connection's statements, iterators, and tag stores, and\ndatabase.setAuthorizer() itself. Other connections remain usable.

The callback can also be invoked from within statement.run(),\nstatement.get(), and similar methods, because SQLite may re-prepare a\nstatement during execution after a schema change.

Separately, a statement that is currently being executed cannot be reentered.\nCalling statement.close() on it would free the virtual machine that is\nrunning, and re-running it through statement.run(), statement.get(),\nstatement.all(), statement.iterate(), iterator.next(),\niterator.return(), or the equivalent tag store methods would reset that\nvirtual machine mid-execution. All of these throw an ERR_INVALID_STATE error\ninstead. This applies to any callback SQLite invokes during execution, such as a\nuser-defined function. Other statements on the connection remain usable.

Operations that touch no SQLite state stay available from the callback:\nsqlTagStore.clear(), which only drops cached statements, and next() and\nreturn() on an already-drained iterator, which keep returning\n{ done: true }.

const { DatabaseSync, constants } = require('node:sqlite');\nconst db = new DatabaseSync(':memory:');\n\n// Set up an authorizer that denies all table creation\ndb.setAuthorizer((actionCode) => {\n  if (actionCode === constants.SQLITE_CREATE_TABLE) {\n    return constants.SQLITE_DENY;\n  }\n  return constants.SQLITE_OK;\n});\n\n// This will work\nusing query = db.prepare('SELECT 1');\nquery.get();\n\n// This will throw an error due to authorization denial\ntry {\n  db.exec('CREATE TABLE blocked (id INTEGER)');\n} catch (err) {\n  console.log('Operation blocked:', err.message);\n}\n

import { DatabaseSync, constants } from 'node:sqlite';\nconst db = new DatabaseSync(':memory:');\n\n// Set up an authorizer that denies all table creation\ndb.setAuthorizer((actionCode) => {\n  if (actionCode === constants.SQLITE_CREATE_TABLE) {\n    return constants.SQLITE_DENY;\n  }\n  return constants.SQLITE_OK;\n});\n\n// This will work\nusing query = db.prepare('SELECT 1');\nquery.get();\n\n// This will throw an error due to authorization denial\ntry {\n  db.exec('CREATE TABLE blocked (id INTEGER)');\n} catch (err) {\n  console.log('Operation blocked:', err.message);\n}\n

Opens the database specified in the path argument of the DatabaseSync\nconstructor. This method should only be used when the database is not opened via\nthe constructor. An exception is thrown if the database is already open.

Serializes the database into a binary representation, returned as a\nUint8Array. This is useful for saving, cloning, or transferring an in-memory\ndatabase. This method is a wrapper around sqlite3_serialize().

import { DatabaseSync } from 'node:sqlite';\n\nconst db = new DatabaseSync(':memory:');\ndb.exec('CREATE TABLE t(key INTEGER PRIMARY KEY, value TEXT)');\ndb.exec(\"INSERT INTO t VALUES (1, 'hello')\");\nconst buffer = db.serialize();\nconsole.log(buffer.length); // Prints the byte length of the database\n

const { DatabaseSync } = require('node:sqlite');\n\nconst db = new DatabaseSync(':memory:');\ndb.exec('CREATE TABLE t(key INTEGER PRIMARY KEY, value TEXT)');\ndb.exec(\"INSERT INTO t VALUES (1, 'hello')\");\nconst buffer = db.serialize();\nconsole.log(buffer.length); // Prints the byte length of the database\n

Loads a serialized database into this connection, replacing the current\ndatabase. The deserialized database is writable. Existing prepared statements\nare finalized before deserialization is attempted, even if the operation\nsubsequently fails. An ERR_INVALID_STATE error is thrown if the method is\ncalled while a database callback is on the stack, for example a user-defined\nfunction, an aggregate function, an authorizer, or a changeset filter or conflict\nhandler. This method is a wrapper around sqlite3_deserialize().

import { DatabaseSync } from 'node:sqlite';\n\nconst original = new DatabaseSync(':memory:');\noriginal.exec('CREATE TABLE t(key INTEGER PRIMARY KEY, value TEXT)');\noriginal.exec(\"INSERT INTO t VALUES (1, 'hello')\");\nconst buffer = original.serialize();\noriginal.close();\n\nconst clone = new DatabaseSync(':memory:');\nclone.deserialize(buffer);\nusing query = clone.prepare('SELECT value FROM t');\nconsole.log(query.get());\n// Prints: { value: 'hello' }\n

const { DatabaseSync } = require('node:sqlite');\n\nconst original = new DatabaseSync(':memory:');\noriginal.exec('CREATE TABLE t(key INTEGER PRIMARY KEY, value TEXT)');\noriginal.exec(\"INSERT INTO t VALUES (1, 'hello')\");\nconst buffer = original.serialize();\noriginal.close();\n\nconst clone = new DatabaseSync(':memory:');\nclone.deserialize(buffer);\nusing query = clone.prepare('SELECT value FROM t');\nconsole.log(query.get());\n// Prints: { value: 'hello' }\n

Compiles a SQL statement into a prepared statement. This method is a wrapper\naround sqlite3_prepare_v3().

Creates a new SQLTagStore, which is a Least Recently Used (LRU) cache\nfor storing prepared statements. This allows for the efficient reuse of\nprepared statements by tagging them with a unique identifier.

When a tagged SQL literal is executed, the SQLTagStore checks if a prepared\nstatement for the corresponding SQL query string already exists in the cache.\nIf it does, the cached statement is used. If not, a new prepared statement is\ncreated, executed, and then stored in the cache for future use. This mechanism\nhelps to avoid the overhead of repeatedly parsing and preparing the same SQL\nstatements.

Tagged statements bind the placeholder values from the template literal as\nparameters to the underlying prepared statement. For example:

sqlTagStore.get`SELECT ${value}`;\n

is equivalent to:

using statement = db.prepare('SELECT ?');\nstatement.get(value);\n

However, in the first example, the tag store will cache the underlying prepared\nstatement for future use.

\n

Note: The ${value} syntax in tagged statements binds a parameter to\nthe prepared statement. This differs from its behavior in untagged template\nliterals, where it performs string interpolation.

\n

// This a safe example of binding a parameter to a tagged statement.\nsqlTagStore.run`INSERT INTO t1 (id) VALUES (${id})`;\n\n// This is an *unsafe* example of an untagged template string.\n// `id` is interpolated into the query text as a string.\n// This can lead to SQL injection and data corruption.\ndb.run(`INSERT INTO t1 (id) VALUES (${id})`);\n

\n

The tag store will match a statement from the cache if the query strings\n(including the positions of any bound placeholders) are identical.

// The following statements will match in the cache:\nsqlTagStore.get`SELECT * FROM t1 WHERE id = ${id} AND active = 1`;\nsqlTagStore.get`SELECT * FROM t1 WHERE id = ${12345} AND active = 1`;\n\n// The following statements will not match, as the query strings\n// and bound placeholders differ:\nsqlTagStore.get`SELECT * FROM t1 WHERE id = ${id} AND active = 1`;\nsqlTagStore.get`SELECT * FROM t1 WHERE id = 12345 AND active = 1`;\n\n// The following statements will not match, as matches are case-sensitive:\nsqlTagStore.get`SELECT * FROM t1 WHERE id = ${id} AND active = 1`;\nsqlTagStore.get`select * from t1 where id = ${id} and active = 1`;\n

The only way of binding parameters in tagged statements is with the ${value}\nsyntax. Do not add parameter binding placeholders (? etc.) to the SQL query\nstring itself.

import { DatabaseSync } from 'node:sqlite';\n\nconst db = new DatabaseSync(':memory:');\nconst sql = db.createTagStore();\n\ndb.exec('CREATE TABLE users (id INT, name TEXT)');\n\n// Using the 'run' method to insert data.\n// The tagged literal is used to identify the prepared statement.\nsql.run`INSERT INTO users VALUES (1, 'Alice')`;\nsql.run`INSERT INTO users VALUES (2, 'Bob')`;\n\n// Using the 'get' method to retrieve a single row.\nconst name = 'Alice';\nconst user = sql.get`SELECT * FROM users WHERE name = ${name}`;\nconsole.log(user); // { id: 1, name: 'Alice' }\n\n// Using the 'all' method to retrieve all rows.\nconst allUsers = sql.all`SELECT * FROM users ORDER BY id`;\nconsole.log(allUsers);\n// [\n//   { id: 1, name: 'Alice' },\n//   { id: 2, name: 'Bob' }\n// ]\n

const { DatabaseSync } = require('node:sqlite');\n\nconst db = new DatabaseSync(':memory:');\nconst sql = db.createTagStore();\n\ndb.exec('CREATE TABLE users (id INT, name TEXT)');\n\n// Using the 'run' method to insert data.\n// The tagged literal is used to identify the prepared statement.\nsql.run`INSERT INTO users VALUES (1, 'Alice')`;\nsql.run`INSERT INTO users VALUES (2, 'Bob')`;\n\n// Using the 'get' method to retrieve a single row.\nconst name = 'Alice';\nconst user = sql.get`SELECT * FROM users WHERE name = ${name}`;\nconsole.log(user); // { id: 1, name: 'Alice' }\n\n// Using the 'all' method to retrieve all rows.\nconst allUsers = sql.all`SELECT * FROM users ORDER BY id`;\nconsole.log(allUsers);\n// [\n//   { id: 1, name: 'Alice' },\n//   { id: 2, name: 'Bob' }\n// ]\n

Creates and attaches a session to the database. This method is a wrapper around sqlite3session_create() and sqlite3session_attach().

An exception is thrown if the database is not\nopen. This method is a wrapper around sqlite3changeset_apply().

import { DatabaseSync } from 'node:sqlite';\n\nconst sourceDb = new DatabaseSync(':memory:');\nconst targetDb = new DatabaseSync(':memory:');\n\nsourceDb.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');\ntargetDb.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');\n\nconst session = sourceDb.createSession();\n\nusing insert = sourceDb.prepare('INSERT INTO data (key, value) VALUES (?, ?)');\ninsert.run(1, 'hello');\ninsert.run(2, 'world');\n\nconst changeset = session.changeset();\ntargetDb.applyChangeset(changeset);\n// Now that the changeset has been applied, targetDb contains the same data as sourceDb.\n

const { DatabaseSync } = require('node:sqlite');\n\nconst sourceDb = new DatabaseSync(':memory:');\nconst targetDb = new DatabaseSync(':memory:');\n\nsourceDb.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');\ntargetDb.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');\n\nconst session = sourceDb.createSession();\n\nusing insert = sourceDb.prepare('INSERT INTO data (key, value) VALUES (?, ?)');\ninsert.run(1, 'hello');\ninsert.run(2, 'world');\n\nconst changeset = session.changeset();\ntargetDb.applyChangeset(changeset);\n// Now that the changeset has been applied, targetDb contains the same data as sourceDb.\n

Closes the database connection. If the database connection is already closed\nthen this is a no-op.

An object for getting and setting SQLite database limits at runtime.\nEach property corresponds to an SQLite limit and can be read or written.

const db = new DatabaseSync(':memory:');\n\n// Read current limit\nconsole.log(db.limits.length);\n\n// Set a new limit\ndb.limits.sqlLength = 100000;\n\n// Reset a limit to its compile-time maximum\ndb.limits.sqlLength = Infinity;\n

Available properties: length, sqlLength, column, exprDepth,\ncompoundSelect, vdbeOp, functionArg, attach, likePatternLength,\nvariableNumber, triggerDepth.

Setting a property to Infinity resets the limit to its compile-time maximum value.

Retrieves a changeset containing all changes since the changeset was created. Can be called multiple times.\nAn exception is thrown if the database or the session is not open. This method is a wrapper around sqlite3session_changeset().

Similar to the method above, but generates a more compact patchset. See Changesets and Patchsets\nin the documentation of SQLite. An exception is thrown if the database or the session is not open. This method is a\nwrapper around sqlite3session_patchset().

Closes the session. An exception is thrown if the database or the session is not open,\nor if the session is currently generating a changeset or patchset. This method is a\nwrapper around sqlite3session_delete().

Closes the session. If the session is already closed, does nothing.

This class represents a single prepared statement. This class cannot be\ninstantiated via its constructor. Instead, instances are created via the\ndatabase.prepare() method. All APIs exposed by this class execute\nsynchronously.

A prepared statement is an efficient binary representation of the SQL used to\ncreate it. Prepared statements are parameterizable, and can be invoked multiple\ntimes with different bound values. Parameters also offer protection against\nSQL injection attacks. For these reasons, prepared statements are preferred\nover hand-crafted SQL strings when handling user input.

The all(), get(), iterate(), and run() methods bind their arguments to\nthe parameters of the prepared statement before executing it. Parameters are\neither anonymous or named.

Anonymous parameters are written as ? in SQL and are bound in order from the\narguments passed to the method. The ?NNN form assigns SQLite parameter index\nNNN to a placeholder. Avoid mixing numbered and named parameters because they\nshare parameter indexes.

db.prepare('SELECT ? AS a, ? AS b').get('x', 42);\n// { a: 'x', b: 42 }\ndb.prepare('SELECT ?2 AS a, ?1 AS b').get('first', 'second');\n// { a: 'second', b: 'first' }\n

Named parameters begin with one of the prefix characters $, :, or @ in\nSQL. They are bound from an object passed as the first argument. Repeating a\nname in the SQL binds the same value to every occurrence.

db.prepare('SELECT $a AS a, $b AS b').get({ $a: 1, $b: 2 });\n// { a: 1, b: 2 }\ndb.prepare('SELECT :a AS a').get({ ':a': 1 });\n// { a: 1 }\ndb.prepare('SELECT @a AS a').get({ '@a': 1 });\n// { a: 1 }\ndb.prepare('SELECT $k AS a, $k AS b').get({ k: 7 });\n// { a: 7, b: 7 }\n

The last example omits the prefix character from the object key. Bare names are\nallowed by default; see statement.setAllowBareNamedParameters() for their\ncaveats.

Binding a key that does not name a parameter of the statement throws an\nERR_INVALID_STATE error unless unknown named parameters are ignored. See\nstatement.setAllowUnknownNamedParameters().

See Type conversion between JavaScript and SQLite for the values that can be\nbound. Binding any other value throws an ERR_INVALID_ARG_TYPE error.

This method executes a prepared statement and returns all results as an array of\nobjects. If the prepared statement does not return any results, this method\nreturns an empty array. The prepared statement parameters are bound using\nthe values in namedParameters and anonymousParameters. See\nBinding parameters.

Finalizes the prepared statement. An exception is thrown if the statement is\nalready finalized. An ERR_INVALID_STATE error is thrown if this statement\nis currently executing, which happens when the method is called from a callback\nthat the statement itself triggered, such as a user-defined function, an\naggregate function, or a 'sqlite.db.query' subscriber. Idle statements\non the same connection can be finalized from such a callback. This method is a\nwrapper around sqlite3_finalize().

This method is used to retrieve information about the columns returned by the\nprepared statement.

This method executes a prepared statement and returns the first result as an\nobject. If the prepared statement does not return any results, this method\nreturns undefined. The prepared statement parameters are bound using the\nvalues in namedParameters and anonymousParameters. See\nBinding parameters.

This method executes a prepared statement and returns an iterator of\nobjects. If the prepared statement does not return any results, this method\nreturns an empty iterator. The prepared statement parameters are bound using\nthe values in namedParameters and anonymousParameters. See\nBinding parameters.

Resets every counter reported by statement.stat() back to zero, except\nmemused, which reports current memory usage and cannot be reset. This\nmethod is a wrapper around sqlite3_stmt_status() and is useful for\nmeasuring a specific workload without the counts accumulated by earlier\nexecutions of the same prepared statement.

This method executes a prepared statement and returns an object summarizing the\nresulting changes. The prepared statement parameters are bound using the\nvalues in namedParameters and anonymousParameters. See\nBinding parameters.

The names of SQLite parameters begin with a prefix character. However, with the\nexception of the dollar sign character, these prefix characters also require\nextra quoting when used in object keys.

To improve ergonomics, node:sqlite allows bare named parameters, which do not\nrequire the prefix character in JavaScript code, by default. This method can be\nused to disable that behavior, requiring the prefix character when binding.\nThere are several caveats to be aware of when bare named parameters are\nallowed:

\n
• The prefix character is still required in SQL.
\n
• The prefix character is still allowed in JavaScript. In fact, prefixed names\nwill have slightly better binding performance.
\n
• Using ambiguous named parameters, such as $k and @k, in the same prepared\nstatement will result in an exception as it cannot be determined how to bind\na bare name.
\n

By default, if an unknown name is encountered while binding parameters, an\nexception is thrown. This method allows unknown named parameters to be ignored.

When enabled, query results returned by the all(), get(), and iterate() methods will be returned as arrays instead\nof objects.

When reading from the database, SQLite INTEGERs are mapped to JavaScript\nnumbers by default. However, SQLite INTEGERs can store values larger than\nJavaScript numbers are capable of representing. In such cases, this method can\nbe used to read INTEGER data using JavaScript BigInts. This method has no\nimpact on database write operations where numbers and BigInts are both\nsupported at all times.

Finalizes the prepared statement. If the prepared statement is already\nfinalized, then this is a no-op. An ERR_INVALID_STATE error is thrown if\nthis statement is currently executing, under the same conditions as\nstatement.close().

Returns one of the runtime counters that SQLite tracks for this prepared\nstatement. This method is a wrapper around sqlite3_stmt_status() and does\nnot reset the counter. Asserting that a statement does not perform a full table\nscan (statement.stat('fullscanStep') === 0) is a useful check to guard\nagainst degenerate performance.

The 'filterMiss' and 'filterHit' counters require SQLite 3.38.0 or later.\nBuilds linked against an older SQLite with --shared-sqlite do not expose them,\nand passing either name throws ERR_INVALID_ARG_VALUE.

The source SQL text of the prepared statement with parameter\nplaceholders replaced by the values that were used during the most recent\nexecution of this prepared statement. This property is a wrapper around\nsqlite3_expanded_sql().

The source SQL text of the prepared statement. This property is a\nwrapper around sqlite3_sql().

This class represents a single LRU (Least Recently Used) cache for storing\nprepared statements.

Instances of this class are created via the database.createTagStore()\nmethod, not by using a constructor. The store caches prepared statements based\non the provided SQL query string. When the same query is seen again, the store\nretrieves the cached statement and safely applies the new values through\nparameter binding, thereby preventing attacks like SQL injection.

The cache has a maxSize that defaults to 1000 statements, but a custom size can\nbe provided (e.g., database.createTagStore(100)). All APIs exposed by this\nclass execute synchronously.

Executes the given SQL query and returns all resulting rows as an array of\nobjects.

This function is intended to be used as a template literal tag, not to be\ncalled directly.

Executes the given SQL query and returns the first resulting row as an object.

This function is intended to be used as a template literal tag, not to be\ncalled directly.

Executes the given SQL query and returns an iterator over the resulting rows.

This function is intended to be used as a template literal tag, not to be\ncalled directly.

Executes the given SQL query, which is expected to not return any rows (e.g., INSERT, UPDATE, DELETE).

This function is intended to be used as a template literal tag, not to be\ncalled directly.

Resets the LRU cache, clearing all stored prepared statements.

A read-only property that returns the number of prepared statements currently in the cache.

A read-only property that returns the maximum number of prepared statements the cache can hold.

A read-only property that returns the DatabaseSync object associated with this SQLTagStore.

This method makes a database backup. This method abstracts the sqlite3_backup_init(), sqlite3_backup_step()\nand sqlite3_backup_finish() functions.

The backed-up database can be used normally during the backup process. Mutations coming from the same connection - same\nDatabaseSync - object will be reflected in the backup right away. However, mutations from other connections will cause\nthe backup process to restart.

const { backup, DatabaseSync } = require('node:sqlite');\n\n(async () => {\n  const sourceDb = new DatabaseSync('source.db');\n  const totalPagesTransferred = await backup(sourceDb, 'backup.db', {\n    rate: 1, // Copy one page at a time.\n    progress: ({ totalPages, remainingPages }) => {\n      console.log('Backup in progress', { totalPages, remainingPages });\n    },\n  });\n\n  console.log('Backup completed', totalPagesTransferred);\n})();\n

import { backup, DatabaseSync } from 'node:sqlite';\n\nconst sourceDb = new DatabaseSync('source.db');\nconst totalPagesTransferred = await backup(sourceDb, 'backup.db', {\n  rate: 1, // Copy one page at a time.\n  progress: ({ totalPages, remainingPages }) => {\n    console.log('Backup in progress', { totalPages, remainingPages });\n  },\n});\n\nconsole.log('Backup completed', totalPagesTransferred);\n

An object containing commonly used constants for SQLite operations.

The following constants are exported by the sqlite.constants object.

One of the following constants is available as an argument to the onConflict\nconflict resolution handler passed to database.applyChangeset(). See also\nConstants Passed To The Conflict Handler in the SQLite documentation.

One of the following constants must be returned from the onConflict conflict\nresolution handler passed to database.applyChangeset(). See also\nConstants Returned From The Conflict Handler in the SQLite documentation.

The following constants are used with the database.setAuthorizer() method.

One of the following constants must be returned from the authorizer callback\nfunction passed to database.setAuthorizer().

The following constants are passed as the first argument to the authorizer\ncallback function to indicate what type of operation is being authorized.