bun-types
Version:
Type definitions and documentation for Bun, an incredibly fast JavaScript runtime
1,167 lines (1,125 loc) • 29 kB
TypeScript
/**
* Fast SQLite3 driver for Bun.js
* @since v0.0.83
*
* @example
* ```ts
* import { Database } from 'bun:sqlite';
*
* var db = new Database('app.db');
* db.query('SELECT * FROM users WHERE name = ?').all('John');
* // => [{ id: 1, name: 'John' }]
* ```
*
* The following types can be used when binding parameters:
*
* | JavaScript type | SQLite type |
* | -------------- | ----------- |
* | `string` | `TEXT` |
* | `number` | `INTEGER` or `DECIMAL` |
* | `boolean` | `INTEGER` (1 or 0) |
* | `Uint8Array` | `BLOB` |
* | `Buffer` | `BLOB` |
* | `bigint` | `INTEGER` |
* | `null` | `NULL` |
*/
declare module "bun:sqlite" {
export class Database implements Disposable {
/**
* Open or create a SQLite3 database
*
* @param filename The filename of the database to open. Pass an empty string (`""`) or `":memory:"` or undefined for an in-memory database.
* @param options defaults to `{readwrite: true, create: true}`. If a number, then it's treated as `SQLITE_OPEN_*` constant flags.
*
* @example
*
* ```ts
* const db = new Database("mydb.sqlite");
* db.run("CREATE TABLE foo (bar TEXT)");
* db.run("INSERT INTO foo VALUES (?)", ["baz"]);
* console.log(db.query("SELECT * FROM foo").all());
* ```
*
* @example
*
* Open an in-memory database
*
* ```ts
* const db = new Database(":memory:");
* db.run("CREATE TABLE foo (bar TEXT)");
* db.run("INSERT INTO foo VALUES (?)", ["hiiiiii"]);
* console.log(db.query("SELECT * FROM foo").all());
* ```
*
* @example
*
* Open read-only
*
* ```ts
* const db = new Database("mydb.sqlite", {readonly: true});
* ```
*/
constructor(
filename?: string,
options?:
| number
| {
/**
* Open the database as read-only (no write operations, no create).
*
* Equivalent to {@link constants.SQLITE_OPEN_READONLY}
*/
readonly?: boolean;
/**
* Allow creating a new database
*
* Equivalent to {@link constants.SQLITE_OPEN_CREATE}
*/
create?: boolean;
/**
* Open the database as read-write
*
* Equivalent to {@link constants.SQLITE_OPEN_READWRITE}
*/
readwrite?: boolean;
/**
* When set to `true`, integers are returned as `bigint` types.
*
* When set to `false`, integers are returned as `number` types and truncated to 52 bits.
*
* @default false
* @since v1.1.14
*/
safeIntegers?: boolean;
/**
* When set to `false` or `undefined`:
* - Queries missing bound parameters will NOT throw an error
* - Bound named parameters in JavaScript need to exactly match the SQL query.
*
* @example
* ```ts
* const db = new Database(":memory:", { strict: false });
* db.run("INSERT INTO foo (name) VALUES ($name)", { $name: "foo" });
* ```
*
* When set to `true`:
* - Queries missing bound parameters will throw an error
* - Bound named parameters in JavaScript no longer need to be `$`, `:`, or `@`. The SQL query will remain prefixed.
*
* @example
* ```ts
* const db = new Database(":memory:", { strict: true });
* db.run("INSERT INTO foo (name) VALUES ($name)", { name: "foo" });
* ```
* @since v1.1.14
*/
strict?: boolean;
},
);
/**
* This is an alias of `new Database()`
*
* See {@link Database}
*/
static open(
filename: string,
options?:
| number
| {
/**
* Open the database as read-only (no write operations, no create).
*
* Equivalent to {@link constants.SQLITE_OPEN_READONLY}
*/
readonly?: boolean;
/**
* Allow creating a new database
*
* Equivalent to {@link constants.SQLITE_OPEN_CREATE}
*/
create?: boolean;
/**
* Open the database as read-write
*
* Equivalent to {@link constants.SQLITE_OPEN_READWRITE}
*/
readwrite?: boolean;
},
): Database;
/**
* Execute a SQL query **without returning any results**.
*
* This does not cache the query, so if you want to run a query multiple times, you should use {@link prepare} instead.
*
* @example
* ```ts
* db.run("CREATE TABLE foo (bar TEXT)");
* db.run("INSERT INTO foo VALUES (?)", ["baz"]);
* ```
*
* Useful for queries like:
* - `CREATE TABLE`
* - `INSERT INTO`
* - `UPDATE`
* - `DELETE FROM`
* - `DROP TABLE`
* - `PRAGMA`
* - `ATTACH DATABASE`
* - `DETACH DATABASE`
* - `REINDEX`
* - `VACUUM`
* - `EXPLAIN ANALYZE`
* - `CREATE INDEX`
* - `CREATE TRIGGER`
* - `CREATE VIEW`
* - `CREATE VIRTUAL TABLE`
* - `CREATE TEMPORARY TABLE`
*
* @param sql The SQL query to run
*
* @param bindings Optional bindings for the query
*
* @returns `Database` instance
*
* Under the hood, this calls `sqlite3_prepare_v3` followed by `sqlite3_step` and `sqlite3_finalize`.
*
* * The following types can be used when binding parameters:
*
* | JavaScript type | SQLite type |
* | -------------- | ----------- |
* | `string` | `TEXT` |
* | `number` | `INTEGER` or `DECIMAL` |
* | `boolean` | `INTEGER` (1 or 0) |
* | `Uint8Array` | `BLOB` |
* | `Buffer` | `BLOB` |
* | `bigint` | `INTEGER` |
* | `null` | `NULL` |
*/
run<ParamsType extends SQLQueryBindings[]>(
sqlQuery: string,
...bindings: ParamsType[]
): Changes;
/**
This is an alias of {@link Database.prototype.run}
*/
exec<ParamsType extends SQLQueryBindings[]>(
sqlQuery: string,
...bindings: ParamsType[]
): Changes;
/**
* Compile a SQL query and return a {@link Statement} object. This is the
* same as {@link prepare} except that it caches the compiled query.
*
* This **does not execute** the query, but instead prepares it for later
* execution and caches the compiled query if possible.
*
* @example
* ```ts
* // compile the query
* const stmt = db.query("SELECT * FROM foo WHERE bar = ?");
* // run the query
* stmt.all("baz");
*
* // run the query again
* stmt.all();
* ```
*
* @param sql The SQL query to compile
*
* @returns `Statment` instance
*
* Under the hood, this calls `sqlite3_prepare_v3`.
*/
query<ReturnType, ParamsType extends SQLQueryBindings | SQLQueryBindings[]>(
sqlQuery: string,
): // eslint-disable-next-line @definitelytyped/no-single-element-tuple-type
Statement<ReturnType, ParamsType extends any[] ? ParamsType : [ParamsType]>;
/**
* Compile a SQL query and return a {@link Statement} object.
*
* This does not cache the compiled query and does not execute the query.
*
* @example
* ```ts
* // compile the query
* const stmt = db.query("SELECT * FROM foo WHERE bar = ?");
* // run the query
* stmt.all("baz");
* ```
*
* @param sql The SQL query to compile
* @param params Optional bindings for the query
*
* @returns `Statment` instance
*
* Under the hood, this calls `sqlite3_prepare_v3`.
*/
prepare<
ReturnType,
ParamsType extends SQLQueryBindings | SQLQueryBindings[],
>(
sqlQuery: string,
params?: ParamsType,
): // eslint-disable-next-line @definitelytyped/no-single-element-tuple-type
Statement<ReturnType, ParamsType extends any[] ? ParamsType : [ParamsType]>;
/**
* Is the database in a transaction?
*
* @returns `true` if the database is in a transaction, `false` otherwise
*
* @example
* ```ts
* db.run("CREATE TABLE foo (bar TEXT)");
* db.run("INSERT INTO foo VALUES (?)", ["baz"]);
* db.run("BEGIN");
* db.run("INSERT INTO foo VALUES (?)", ["qux"]);
* console.log(db.inTransaction());
* ```
*/
get inTransaction(): boolean;
/**
* Close the database connection.
*
* It is safe to call this method multiple times. If the database is already
* closed, this is a no-op. Running queries after the database has been
* closed will throw an error.
*
* @example
* ```ts
* db.close();
* ```
* This is called automatically when the database instance is garbage collected.
*
* Internally, this calls `sqlite3_close_v2`.
*/
close(
/**
* If `true`, then the database will throw an error if it is in use
* @default false
*
* When true, this calls `sqlite3_close` instead of `sqlite3_close_v2`.
*
* Learn more about this in the [sqlite3 documentation](https://www.sqlite.org/c3ref/close.html).
*
* Bun will automatically call close by default when the database instance is garbage collected.
* In The future, Bun may default `throwOnError` to be true but for backwards compatibility, it is false by default.
*/
throwOnError?: boolean,
): void;
/**
* The filename passed when `new Database()` was called
* @example
* ```ts
* const db = new Database("mydb.sqlite");
* console.log(db.filename);
* // => "mydb.sqlite"
* ```
*/
readonly filename: string;
/**
* The underlying `sqlite3` database handle
*
* In native code, this is not a file descriptor, but an index into an array of database handles
*/
readonly handle: number;
/**
* Load a SQLite3 extension
*
* macOS requires a custom SQLite3 library to be linked because the Apple build of SQLite for macOS disables loading extensions. See {@link Database.setCustomSQLite}
*
* Bun chooses the Apple build of SQLite on macOS because it brings a ~50% performance improvement.
*
* @param extension name/path of the extension to load
* @param entryPoint optional entry point of the extension
*/
loadExtension(extension: string, entryPoint?: string): void;
/**
* Change the dynamic library path to SQLite
*
* @note macOS-only
*
* This only works before SQLite is loaded, so
* that's before you call `new Database()`.
*
* It can only be run once because this will load
* the SQLite library into the process.
*
* @param path The path to the SQLite library
*/
static setCustomSQLite(path: string): boolean;
[Symbol.dispose](): void;
/**
* Creates a function that always runs inside a transaction. When the
* function is invoked, it will begin a new transaction. When the function
* returns, the transaction will be committed. If an exception is thrown,
* the transaction will be rolled back (and the exception will propagate as
* usual).
*
* @param insideTransaction The callback which runs inside a transaction
*
* @example
* ```ts
* // setup
* import { Database } from "bun:sqlite";
* const db = Database.open(":memory:");
* db.exec(
* "CREATE TABLE cats (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT UNIQUE, age INTEGER)"
* );
*
* const insert = db.prepare("INSERT INTO cats (name, age) VALUES ($name, $age)");
* const insertMany = db.transaction((cats) => {
* for (const cat of cats) insert.run(cat);
* });
*
* insertMany([
* { $name: "Joey", $age: 2 },
* { $name: "Sally", $age: 4 },
* { $name: "Junior", $age: 1 },
* ]);
* ```
*/
transaction(insideTransaction: (...args: any) => void): CallableFunction & {
/**
* uses "BEGIN DEFERRED"
*/
deferred: (...args: any) => void;
/**
* uses "BEGIN IMMEDIATE"
*/
immediate: (...args: any) => void;
/**
* uses "BEGIN EXCLUSIVE"
*/
exclusive: (...args: any) => void;
};
/**
* Save the database to an in-memory {@link Buffer} object.
*
* Internally, this calls `sqlite3_serialize`.
*
* @param name Name to save the database as @default "main"
* @returns Buffer containing the serialized database
*/
serialize(name?: string): Buffer;
/**
* Load a serialized SQLite3 database
*
* Internally, this calls `sqlite3_deserialize`.
*
* @param serialized Data to load
* @returns `Database` instance
*
* @example
* ```ts
* test("supports serialize/deserialize", () => {
* const db = Database.open(":memory:");
* db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)");
* db.exec('INSERT INTO test (name) VALUES ("Hello")');
* db.exec('INSERT INTO test (name) VALUES ("World")');
*
* const input = db.serialize();
* const db2 = new Database(input);
*
* const stmt = db2.prepare("SELECT * FROM test");
* expect(JSON.stringify(stmt.get())).toBe(
* JSON.stringify({
* id: 1,
* name: "Hello",
* }),
* );
*
* expect(JSON.stringify(stmt.all())).toBe(
* JSON.stringify([
* {
* id: 1,
* name: "Hello",
* },
* {
* id: 2,
* name: "World",
* },
* ]),
* );
* db2.exec("insert into test (name) values ('foo')");
* expect(JSON.stringify(stmt.all())).toBe(
* JSON.stringify([
* {
* id: 1,
* name: "Hello",
* },
* {
* id: 2,
* name: "World",
* },
* {
* id: 3,
* name: "foo",
* },
* ]),
* );
*
* const db3 = Database.deserialize(input, true);
* try {
* db3.exec("insert into test (name) values ('foo')");
* throw new Error("Expected error");
* } catch (e) {
* expect(e.message).toBe("attempt to write a readonly database");
* }
* });
* ```
*/
static deserialize(
serialized: NodeJS.TypedArray | ArrayBufferLike,
isReadOnly?: boolean,
): Database;
/**
* See `sqlite3_file_control` for more information.
* @link https://www.sqlite.org/c3ref/file_control.html
*/
fileControl(op: number, arg?: ArrayBufferView | number): number;
/**
* See `sqlite3_file_control` for more information.
* @link https://www.sqlite.org/c3ref/file_control.html
*/
fileControl(
zDbName: string,
op: number,
arg?: ArrayBufferView | number,
): number;
}
/**
* A prepared statement.
*
* This is returned by {@link Database.prepare} and {@link Database.query}.
*
* @example
* ```ts
* const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
* stmt.all("baz");
* // => [{bar: "baz"}]
* ```
*
* @example
* ```ts
* const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
* stmt.get("baz");
* // => {bar: "baz"}
* ```
*
* @example
* ```ts
* const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
* stmt.run("baz");
* // => undefined
* ```
*/
export class Statement<
ReturnType = unknown,
ParamsType extends SQLQueryBindings[] = any[],
> implements Disposable
{
/**
* Creates a new prepared statement from native code.
*
* This is used internally by the {@link Database} class. Probably you don't need to call this yourself.
*/
constructor(nativeHandle: any);
/**
* Execute the prepared statement and return all results as objects.
*
* @param params optional values to bind to the statement. If omitted, the statement is run with the last bound values or no parameters if there are none.
*
* @example
* ```ts
* const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
*
* stmt.all("baz");
* // => [{bar: "baz"}]
*
* stmt.all();
* // => []
*
* stmt.all("foo");
* // => [{bar: "foo"}]
* ```
*/
all(...params: ParamsType): ReturnType[];
/**
* Execute the prepared statement and return **the first** result.
*
* If no result is returned, this returns `null`.
*
* @param params optional values to bind to the statement. If omitted, the statement is run with the last bound values or no parameters if there are none.
*
* @example
* ```ts
* const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
*
* stmt.get("baz");
* // => {bar: "baz"}
*
* stmt.get();
* // => null
*
* stmt.get("foo");
* // => {bar: "foo"}
* ```
*
* The following types can be used when binding parameters:
*
* | JavaScript type | SQLite type |
* | -------------- | ----------- |
* | `string` | `TEXT` |
* | `number` | `INTEGER` or `DECIMAL` |
* | `boolean` | `INTEGER` (1 or 0) |
* | `Uint8Array` | `BLOB` |
* | `Buffer` | `BLOB` |
* | `bigint` | `INTEGER` |
* | `null` | `NULL` |
*/
get(...params: ParamsType): ReturnType | null;
/**
* Execute the prepared statement and return an
*
* @param params optional values to bind to the statement. If omitted, the statement is run with the last bound values or no parameters if there are none.
*
*/
iterate(...params: ParamsType): IterableIterator<ReturnType>;
[Symbol.iterator](): IterableIterator<ReturnType>;
/**
* Execute the prepared statement. This returns `undefined`.
*
* @param params optional values to bind to the statement. If omitted, the statement is run with the last bound values or no parameters if there are none.
*
* @example
* ```ts
* const stmt = db.prepare("UPDATE foo SET bar = ?");
* stmt.run("baz");
* // => undefined
*
* stmt.run();
* // => undefined
*
* stmt.run("foo");
* // => undefined
* ```
*
* The following types can be used when binding parameters:
*
* | JavaScript type | SQLite type |
* | -------------- | ----------- |
* | `string` | `TEXT` |
* | `number` | `INTEGER` or `DECIMAL` |
* | `boolean` | `INTEGER` (1 or 0) |
* | `Uint8Array` | `BLOB` |
* | `Buffer` | `BLOB` |
* | `bigint` | `INTEGER` |
* | `null` | `NULL` |
*/
run(...params: ParamsType): Changes;
/**
* Execute the prepared statement and return the results as an array of arrays.
*
* In Bun v0.6.7 and earlier, this method returned `null` if there were no
* results instead of `[]`. This was changed in v0.6.8 to align
* more with what people expect.
*
* @param params optional values to bind to the statement. If omitted, the statement is run with the last bound values or no parameters if there are none.
*
* @example
* ```ts
* const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
*
* stmt.values("baz");
* // => [['baz']]
*
* stmt.values();
* // => [['baz']]
*
* stmt.values("foo");
* // => [['foo']]
*
* stmt.values("not-found");
* // => []
* ```
*
* The following types can be used when binding parameters:
*
* | JavaScript type | SQLite type |
* | ---------------|-------------|
* | `string` | `TEXT` |
* | `number` | `INTEGER` or `DECIMAL` |
* | `boolean` | `INTEGER` (1 or 0) |
* | `Uint8Array` | `BLOB` |
* | `Buffer` | `BLOB` |
* | `bigint` | `INTEGER` |
* | `null` | `NULL` |
*/
values(
...params: ParamsType
): Array<Array<string | bigint | number | boolean | Uint8Array>>;
/**
* The names of the columns returned by the prepared statement.
* @example
* ```ts
* const stmt = db.prepare("SELECT bar FROM foo WHERE bar = ?");
*
* console.log(stmt.columnNames);
* // => ["bar"]
* ```
*/
readonly columnNames: string[];
/**
* The number of parameters expected in the prepared statement.
* @example
* ```ts
* const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
* console.log(stmt.paramsCount);
* // => 1
* ```
* @example
* ```ts
* const stmt = db.prepare("SELECT * FROM foo WHERE bar = ? AND baz = ?");
* console.log(stmt.paramsCount);
* // => 2
* ```
*/
readonly paramsCount: number;
/**
* Finalize the prepared statement, freeing the resources used by the
* statement and preventing it from being executed again.
*
* This is called automatically when the prepared statement is garbage collected.
*
* It is safe to call this multiple times. Calling this on a finalized
* statement has no effect.
*
* Internally, this calls `sqlite3_finalize`.
*/
finalize(): void;
/**
* Calls {@link finalize} if it wasn't already called.
*/
[Symbol.dispose](): void;
/**
* Return the expanded SQL string for the prepared statement.
*
* Internally, this calls `sqlite3_expanded_sql()` on the underlying `sqlite3_stmt`.
*
* @example
* ```ts
* const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?", "baz");
* console.log(stmt.toString());
* // => "SELECT * FROM foo WHERE bar = 'baz'"
* console.log(stmt);
* // => "SELECT * FROM foo WHERE bar = 'baz'"
* ```
*/
toString(): string;
/**
*
* Make {@link get} and {@link all} return an instance of the provided
* `Class` instead of the default `Object`.
*
* @param Class A class to use
* @returns The same statement instance, modified to return an instance of `Class`
*
* This lets you attach methods, getters, and setters to the returned
* objects.
*
* For performance reasons, constructors for classes are not called, which means
* initializers will not be called and private fields will not be
* accessible.
*
* @example
*
* ## Custom class
* ```ts
* class User {
* rawBirthdate: string;
* get birthdate() {
* return new Date(this.rawBirthdate);
* }
* }
*
* const db = new Database(":memory:");
* db.exec("CREATE TABLE users (id INTEGER PRIMARY KEY, rawBirthdate TEXT)");
* db.run("INSERT INTO users (rawBirthdate) VALUES ('1995-12-19')");
* const query = db.query("SELECT * FROM users");
* query.as(User);
* const user = query.get();
* console.log(user.birthdate);
* // => Date(1995, 12, 19)
* ```
*/
as<T = unknown>(Class: new (...args: any[]) => T): Statement<T, ParamsType>;
/**
* Native object representing the underlying `sqlite3_stmt`
*
* This is left untyped because the ABI of the native bindings may change at any time.
*/
readonly native: any;
}
/**
* Constants from `sqlite3.h`
*
* This list isn't exhaustive, but some of the ones which are relevant
*/
export const constants: {
/**
* Open the database as read-only (no write operations, no create).
* @constant 0x00000001
*/
SQLITE_OPEN_READONLY: number;
/**
* Open the database for reading and writing
* @constant 0x00000002
*/
SQLITE_OPEN_READWRITE: number;
/**
* Allow creating a new database
* @constant 0x00000004
*/
SQLITE_OPEN_CREATE: number;
/**
* @constant 0x00000008
*/
SQLITE_OPEN_DELETEONCLOSE: number;
/**
* @constant 0x00000010
*/
SQLITE_OPEN_EXCLUSIVE: number;
/**
* @constant 0x00000020
*/
SQLITE_OPEN_AUTOPROXY: number;
/**
* @constant 0x00000040
*/
SQLITE_OPEN_URI: number;
/**
* @constant 0x00000080
*/
SQLITE_OPEN_MEMORY: number;
/**
* @constant 0x00000100
*/
SQLITE_OPEN_MAIN_DB: number;
/**
* @constant 0x00000200
*/
SQLITE_OPEN_TEMP_DB: number;
/**
* @constant 0x00000400
*/
SQLITE_OPEN_TRANSIENT_DB: number;
/**
* @constant 0x00000800
*/
SQLITE_OPEN_MAIN_JOURNAL: number;
/**
* @constant 0x00001000
*/
SQLITE_OPEN_TEMP_JOURNAL: number;
/**
* @constant 0x00002000
*/
SQLITE_OPEN_SUBJOURNAL: number;
/**
* @constant 0x00004000
*/
SQLITE_OPEN_SUPER_JOURNAL: number;
/**
* @constant 0x00008000
*/
SQLITE_OPEN_NOMUTEX: number;
/**
* @constant 0x00010000
*/
SQLITE_OPEN_FULLMUTEX: number;
/**
* @constant 0x00020000
*/
SQLITE_OPEN_SHAREDCACHE: number;
/**
* @constant 0x00040000
*/
SQLITE_OPEN_PRIVATECACHE: number;
/**
* @constant 0x00080000
*/
SQLITE_OPEN_WAL: number;
/**
* @constant 0x01000000
*/
SQLITE_OPEN_NOFOLLOW: number;
/**
* @constant 0x02000000
*/
SQLITE_OPEN_EXRESCODE: number;
/**
* @constant 0x01
*/
SQLITE_PREPARE_PERSISTENT: number;
/**
* @constant 0x02
*/
SQLITE_PREPARE_NORMALIZE: number;
/**
* @constant 0x04
*/
SQLITE_PREPARE_NO_VTAB: number;
/**
* @constant 1
*/
SQLITE_FCNTL_LOCKSTATE: number;
/**
* @constant 2
*/
SQLITE_FCNTL_GET_LOCKPROXYFILE: number;
/**
* @constant 3
*/
SQLITE_FCNTL_SET_LOCKPROXYFILE: number;
/**
* @constant 4
*/
SQLITE_FCNTL_LAST_ERRNO: number;
/**
* @constant 5
*/
SQLITE_FCNTL_SIZE_HINT: number;
/**
* @constant 6
*/
SQLITE_FCNTL_CHUNK_SIZE: number;
/**
* @constant 7
*/
SQLITE_FCNTL_FILE_POINTER: number;
/**
* @constant 8
*/
SQLITE_FCNTL_SYNC_OMITTED: number;
/**
* @constant 9
*/
SQLITE_FCNTL_WIN32_AV_RETRY: number;
/**
* @constant 10
*
* Control whether or not the WAL is persisted
* Some versions of macOS configure WAL to be persistent by default.
*
* You can change this with code like the below:
* ```ts
* import { Database } from "bun:sqlite";
*
* const db = Database.open("mydb.sqlite");
* db.fileControl(constants.SQLITE_FCNTL_PERSIST_WAL, 0);
* // enable WAL
* db.exec("PRAGMA journal_mode = WAL");
* // .. do some work
* db.close();
* ```
*
*/
SQLITE_FCNTL_PERSIST_WAL: number;
/**
* @constant 11
*/
SQLITE_FCNTL_OVERWRITE: number;
/**
* @constant 12
*/
SQLITE_FCNTL_VFSNAME: number;
/**
* @constant 13
*/
SQLITE_FCNTL_POWERSAFE_OVERWRITE: number;
/**
* @constant 14
*/
SQLITE_FCNTL_PRAGMA: number;
/**
* @constant 15
*/
SQLITE_FCNTL_BUSYHANDLER: number;
/**
* @constant 16
*/
SQLITE_FCNTL_TEMPFILENAME: number;
/**
* @constant 18
*/
SQLITE_FCNTL_MMAP_SIZE: number;
/**
* @constant 19
*/
SQLITE_FCNTL_TRACE: number;
/**
* @constant 20
*/
SQLITE_FCNTL_HAS_MOVED: number;
/**
* @constant 21
*/
SQLITE_FCNTL_SYNC: number;
/**
* @constant 22
*/
SQLITE_FCNTL_COMMIT_PHASETWO: number;
/**
* @constant 23
*/
SQLITE_FCNTL_WIN32_SET_HANDLE: number;
/**
* @constant 24
*/
SQLITE_FCNTL_WAL_BLOCK: number;
/**
* @constant 25
*/
SQLITE_FCNTL_ZIPVFS: number;
/**
* @constant 26
*/
SQLITE_FCNTL_RBU: number;
/**
* @constant 27
*/
SQLITE_FCNTL_VFS_POINTER: number;
/**
* @constant 28
*/
SQLITE_FCNTL_JOURNAL_POINTER: number;
/**
* @constant 29
*/
SQLITE_FCNTL_WIN32_GET_HANDLE: number;
/**
* @constant 30
*/
SQLITE_FCNTL_PDB: number;
/**
* @constant 31
*/
SQLITE_FCNTL_BEGIN_ATOMIC_WRITE: number;
/**
* @constant 32
*/
SQLITE_FCNTL_COMMIT_ATOMIC_WRITE: number;
/**
* @constant 33
*/
SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE: number;
/**
* @constant 34
*/
SQLITE_FCNTL_LOCK_TIMEOUT: number;
/**
* @constant 35
*/
SQLITE_FCNTL_DATA_VERSION: number;
/**
* @constant 36
*/
SQLITE_FCNTL_SIZE_LIMIT: number;
/**
* @constant 37
*/
SQLITE_FCNTL_CKPT_DONE: number;
/**
* @constant 38
*/
SQLITE_FCNTL_RESERVE_BYTES: number;
/**
* @constant 39
*/
SQLITE_FCNTL_CKPT_START: number;
/**
* @constant 40
*/
SQLITE_FCNTL_EXTERNAL_READER: number;
/**
* @constant 41
*/
SQLITE_FCNTL_CKSM_FILE: number;
/**
* @constant 42
*/
SQLITE_FCNTL_RESET_CACHE: number;
};
/**
* The native module implementing the sqlite3 C bindings
*
* It is lazily-initialized, so this will return `undefined` until the first
* call to new Database().
*
* The native module makes no gurantees about ABI stability, so it is left
* untyped
*
* If you need to use it directly for some reason, please let us know because
* that probably points to a deficiency in this API.
*/
export var native: any;
export type SQLQueryBindings =
| string
| bigint
| NodeJS.TypedArray
| number
| boolean
| null
| Record<
string,
string | bigint | NodeJS.TypedArray | number | boolean | null
>;
export default Database;
/**
* Errors from SQLite have a name `SQLiteError`.
*
*/
export class SQLiteError extends Error {
readonly name: "SQLiteError";
/**
* The SQLite3 extended error code
*
* This corresponds to `sqlite3_extended_errcode`.
*
* @since v1.0.21
*/
errno: number;
/**
* The name of the SQLite3 error code
*
* @example
* "SQLITE_CONSTRAINT_UNIQUE"
*
* @since v1.0.21
*/
code?: string;
/**
* The UTF-8 byte offset of the sqlite3 query that failed, if known
*
* This corresponds to `sqlite3_error_offset`.
*
* @since v1.0.21
*/
readonly byteOffset: number;
}
/**
* An object representing the changes made to the database since the last `run` or `exec` call.
*
* @since Bun v1.1.14
*/
export interface Changes {
/**
* The number of rows changed by the last `run` or `exec` call.
*/
changes: number;
/**
* If `safeIntegers` is `true`, this is a `bigint`. Otherwise, it is a `number`.
*/
lastInsertRowid: number | bigint;
}
}