expo-sqlite 12.2.1 → 13.1.0

package/build/next/NativeStatement.js.map

@@ -1 +1 @@
-{"version":3,"file":"NativeStatement.js","sourceRoot":"","sources":["../../src/next/NativeStatement.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Result of a `runAsync` call.\n */\nexport interface RunResult {\n  /**\n   * The last inserted row ID.\n   */\n  lastInsertRowid: number;\n\n  /**\n   * The number of rows affected.\n   */\n  changes: number;\n}\n\n/**\n * Bind parameters to the prepared statement.\n * You can either pass the parameters in the following forms:\n *\n * @example\n * - A single array for unnamed parameters.\n * ```ts\n * const statement = await db.prepareAsync('SELECT * FROM test WHERE value = ? AND intValue = ?');\n * await statement.getAsync(['test1', 789]);\n * ```\n *\n * @example\n * - Variadic arguments for unnamed parameters.\n * ```ts\n * const statement = await db.prepareAsync('SELECT * FROM test WHERE value = ? AND intValue = ?');\n * await statement.getAsync('test1', 789);\n * ```\n *\n * @example\n * - A single object for [named parameters](https://www.sqlite.org/lang_expr.html)\n *\n * We support multiple named parameter forms such as `:VVV`, `@VVV`, and `$VVV`. We recommend using `$VVV` because JavaScript allows using `$` in identifiers without escaping.\n * ```ts\n * const statement = await db.prepareAsync('SELECT * FROM test WHERE value = $value AND intValue = $intValue');\n * await statement.getAsync({ $value: 'test1', $intValue: 789 });\n * ```\n */\nexport type BindValue = string | number | null | boolean;\nexport type BindParams = Record<string, BindValue> | BindValue[];\nexport type VariadicBindParams = BindValue[];\n\nexport type ColumnNames = string[];\nexport type ColumnValues = any[];\ntype AnyDatabase = any;\n\n/**\n * A class that represents an instance of the SQLite statement.\n */\nexport declare class NativeStatement {\n  //#region Asynchronous API\n\n  public arrayRunAsync(database: AnyDatabase, params: BindParams): Promise<RunResult>;\n  public objectRunAsync(database: AnyDatabase, params: BindParams): Promise<RunResult>;\n\n  public arrayGetAsync(\n    database: AnyDatabase,\n    params: BindParams\n  ): Promise<ColumnValues | null | undefined>;\n  public objectGetAsync(\n    database: AnyDatabase,\n    params: BindParams\n  ): Promise<ColumnValues | null | undefined>;\n\n  public arrayGetAllAsync(database: AnyDatabase, params: BindParams): Promise<ColumnValues[]>;\n  public objectGetAllAsync(database: AnyDatabase, params: BindParams): Promise<ColumnValues[]>;\n\n  public getColumnNamesAsync(): Promise<ColumnNames>;\n\n  public resetAsync(database: AnyDatabase): Promise<void>;\n  public finalizeAsync(database: AnyDatabase): Promise<void>;\n\n  //#endregion\n\n  //#region Synchronous API\n\n  public arrayRunSync(database: AnyDatabase, params: BindParams): RunResult;\n  public objectRunSync(database: AnyDatabase, params: BindParams): RunResult;\n\n  public arrayGetSync(database: AnyDatabase, params: BindParams): ColumnValues | null | undefined;\n  public objectGetSync(database: AnyDatabase, params: BindParams): ColumnValues | null | undefined;\n\n  public arrayGetAllSync(database: AnyDatabase, params: BindParams): ColumnValues[];\n  public objectGetAllSync(database: AnyDatabase, params: BindParams): ColumnValues[];\n\n  public getColumnNamesSync(): string[];\n\n  public resetSync(database: AnyDatabase): void;\n  public finalizeSync(database: AnyDatabase): void;\n\n  //#endregion\n}\n"]}
+{"version":3,"file":"NativeStatement.js","sourceRoot":"","sources":["../../src/next/NativeStatement.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * A result returned by [`SQLiteDatabase.runAsync`](#runasyncsource-params) or [`SQLiteDatabase.runSync`](#runsyncsource-params).\n */\nexport interface SQLiteRunResult {\n  /**\n   * The last inserted row ID. Returned from the [`sqlite3_last_insert_rowid()`](https://www.sqlite.org/c3ref/last_insert_rowid.html) function.\n   */\n  lastInsertRowId: number;\n\n  /**\n   * The number of rows affected. Returned from the [`sqlite3_changes()`](https://www.sqlite.org/c3ref/changes.html) function.\n   */\n  changes: number;\n}\n\n/**\n * Bind parameters to the prepared statement.\n * You can either pass the parameters in the following forms:\n *\n * @example\n * A single array for unnamed parameters.\n * ```ts\n * const statement = await db.prepareAsync('SELECT * FROM test WHERE value = ? AND intValue = ?');\n * const result = await statement.executeAsync(['test1', 789]);\n * const firstRow = await result.getFirstAsync();\n * ```\n *\n * @example\n * Variadic arguments for unnamed parameters.\n * ```ts\n * const statement = await db.prepareAsync('SELECT * FROM test WHERE value = ? AND intValue = ?');\n * const result = await statement.executeAsync('test1', 789);\n * const firstRow = await result.getFirstAsync();\n * ```\n *\n * @example\n * A single object for [named parameters](https://www.sqlite.org/lang_expr.html)\n *\n * We support multiple named parameter forms such as `:VVV`, `@VVV`, and `$VVV`. We recommend using `$VVV` because JavaScript allows using `$` in identifiers without escaping.\n * ```ts\n * const statement = await db.prepareAsync('SELECT * FROM test WHERE value = $value AND intValue = $intValue');\n * const result = await statement.executeAsync({ $value: 'test1', $intValue: 789 });\n * const firstRow = await result.getFirstAsync();\n * ```\n */\nexport type SQLiteBindValue = string | number | null | boolean | Uint8Array;\nexport type SQLiteBindParams = Record<string, SQLiteBindValue> | SQLiteBindValue[];\nexport type SQLiteVariadicBindParams = SQLiteBindValue[];\n\nexport type SQLiteBindPrimitiveParams = Record<string, Exclude<SQLiteBindValue, Uint8Array>>;\nexport type SQLiteBindBlobParams = Record<string, Uint8Array>;\nexport type SQLiteColumnNames = string[];\nexport type SQLiteColumnValues = any[];\nexport type SQLiteAnyDatabase = any;\n\n/**\n * A class that represents an instance of the SQLite statement.\n */\nexport declare class NativeStatement {\n  //#region Asynchronous API\n\n  public runAsync(\n    database: SQLiteAnyDatabase,\n    bindParams: SQLiteBindPrimitiveParams,\n    bindBlobParams: SQLiteBindBlobParams,\n    shouldPassAsArray: boolean\n  ): Promise<SQLiteRunResult & { firstRowValues: SQLiteColumnValues }>;\n  public stepAsync(database: SQLiteAnyDatabase): Promise<SQLiteColumnValues | null | undefined>;\n  public getAllAsync(database: SQLiteAnyDatabase): Promise<SQLiteColumnValues[]>;\n  public resetAsync(database: SQLiteAnyDatabase): Promise<void>;\n  public getColumnNamesAsync(): Promise<SQLiteColumnNames>;\n  public finalizeAsync(database: SQLiteAnyDatabase): Promise<void>;\n\n  //#endregion\n\n  //#region Synchronous API\n\n  public runSync(\n    database: SQLiteAnyDatabase,\n    bindParams: SQLiteBindPrimitiveParams,\n    bindBlobParams: SQLiteBindBlobParams,\n    shouldPassAsArray: boolean\n  ): SQLiteRunResult & { firstRowValues: SQLiteColumnValues };\n  public stepSync(database: SQLiteAnyDatabase): SQLiteColumnValues | null | undefined;\n  public getAllSync(database: SQLiteAnyDatabase): SQLiteColumnValues[];\n  public resetSync(database: SQLiteAnyDatabase): void;\n  public getColumnNamesSync(): string[];\n  public finalizeSync(database: SQLiteAnyDatabase): void;\n\n  //#endregion\n}\n"]}

package/build/next/SQLiteDatabase.d.ts

@@ -0,0 +1,266 @@
+import { Subscription } from 'expo-modules-core';
+import { NativeDatabase, SQLiteOpenOptions } from './NativeDatabase';
+import { SQLiteBindParams, SQLiteRunResult, SQLiteStatement, SQLiteVariadicBindParams } from './SQLiteStatement';
+export { SQLiteOpenOptions };
+/**
+ * A SQLite database.
+ */
+export declare class SQLiteDatabase {
+    readonly databaseName: string;
+    readonly options: SQLiteOpenOptions;
+    private readonly nativeDatabase;
+    constructor(databaseName: string, options: SQLiteOpenOptions, nativeDatabase: NativeDatabase);
+    /**
+     * Asynchronous call to return whether the database is currently in a transaction.
+     */
+    isInTransactionAsync(): Promise<boolean>;
+    /**
+     * Close the database.
+     */
+    closeAsync(): Promise<void>;
+    /**
+     * Execute all SQL queries in the supplied string.
+     * > Note: The queries are not escaped for you! Be careful when constructing your queries.
+     *
+     * @param source A string containing all the SQL queries.
+     */
+    execAsync(source: string): Promise<void>;
+    /**
+     * Create a [prepared SQLite statement](https://www.sqlite.org/c3ref/prepare.html).
+     *
+     * @param source A string containing the SQL query.
+     */
+    prepareAsync(source: string): Promise<SQLiteStatement>;
+    /**
+     * Execute a transaction and automatically commit/rollback based on the `task` result.
+     *
+     * > **Note:** This transaction is not exclusive and can be interrupted by other async queries.
+     * @example
+     * ```ts
+     * db.withTransactionAsync(async () => {
+     *   await db.execAsync('UPDATE test SET name = "aaa"');
+     *
+     *   //
+     *   // We cannot control the order of async/await order, so order of execution is not guaranteed.
+     *   // The following UPDATE query out of transaction may be executed here and break the expectation.
+     *   //
+     *
+     *   const result = await db.getAsync<{ name: string }>('SELECT name FROM Users');
+     *   expect(result?.name).toBe('aaa');
+     * });
+     * db.execAsync('UPDATE test SET name = "bbb"');
+     * ```
+     * If you worry about the order of execution, use `withExclusiveTransactionAsync` instead.
+     *
+     * @param task An async function to execute within a transaction.
+     */
+    withTransactionAsync(task: () => Promise<void>): Promise<void>;
+    /**
+     * Execute a transaction and automatically commit/rollback based on the `task` result.
+     *
+     * The transaction may be exclusive.
+     * As long as the transaction is converted into a write transaction,
+     * the other async write queries will abort with `database is locked` error.
+     *
+     * @param task An async function to execute within a transaction. Any queries inside the transaction must be executed on the `txn` object.
+     * The `txn` object has the same interfaces as the [`SQLiteDatabase`](#sqlitedatabase) object. You can use `txn` like a [`SQLiteDatabase`](#sqlitedatabase) object.
+     *
+     * @example
+     * ```ts
+     * db.withExclusiveTransactionAsync(async (txn) => {
+     *   await txn.execAsync('UPDATE test SET name = "aaa"');
+     * });
+     * ```
+     */
+    withExclusiveTransactionAsync(task: (txn: Transaction) => Promise<void>): Promise<void>;
+    /**
+     * Synchronous call to return whether the database is currently in a transaction.
+     */
+    isInTransactionSync(): boolean;
+    /**
+     * Close the database.
+     */
+    closeSync(): void;
+    /**
+     * Execute all SQL queries in the supplied string.
+     *
+     * > **Note:** The queries are not escaped for you! Be careful when constructing your queries.
+     *
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread and affect performance.
+     *
+     * @param source A string containing all the SQL queries.
+     */
+    execSync(source: string): void;
+    /**
+     * Create a [prepared SQLite statement](https://www.sqlite.org/c3ref/prepare.html).
+     *
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread and affect performance.
+     *
+     * @param source A string containing the SQL query.
+     */
+    prepareSync(source: string): SQLiteStatement;
+    /**
+     * Execute a transaction and automatically commit/rollback based on the `task` result.
+     *
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread and affect performance.
+     *
+     * @param task An async function to execute within a transaction.
+     */
+    withTransactionSync(task: () => void): void;
+    /**
+     * A convenience wrapper around [`SQLiteDatabase.prepareAsync()`](#prepareasyncsource), [`SQLiteStatement.executeAsync()`](#executeasyncparams), and [`SQLiteStatement.finalizeAsync()`](#finalizeasync).
+     * @param source A string containing the SQL query.
+     * @param params The parameters to bind to the prepared statement. You can pass values in array, object, or variadic arguments. See [`SQLiteBindValue`](#sqlitebindvalue) for more information about binding values.
+     */
+    runAsync(source: string, params: SQLiteBindParams): Promise<SQLiteRunResult>;
+    /**
+     * @hidden
+     */
+    runAsync(source: string, ...params: SQLiteVariadicBindParams): Promise<SQLiteRunResult>;
+    /**
+     * A convenience wrapper around [`SQLiteDatabase.prepareAsync()`](#prepareasyncsource), [`SQLiteStatement.executeAsync()`](#executeasyncparams), [`SQLiteExecuteAsyncResult.getFirstAsync()`](#getfirstasync), and [`SQLiteStatement.finalizeAsync()`](#finalizeasync).
+     * @param source A string containing the SQL query.
+     * @param params The parameters to bind to the prepared statement. You can pass values in array, object, or variadic arguments. See [`SQLiteBindValue`](#sqlitebindvalue) for more information about binding values.
+     */
+    getFirstAsync<T>(source: string, params: SQLiteBindParams): Promise<T | null>;
+    /**
+     * @hidden
+     */
+    getFirstAsync<T>(source: string, ...params: SQLiteVariadicBindParams): Promise<T | null>;
+    /**
+     * A convenience wrapper around [`SQLiteDatabase.prepareAsync()`](#prepareasyncsource), [`SQLiteStatement.executeAsync()`](#executeasyncparams), [`SQLiteExecuteAsyncResult`](#sqliteexecuteasyncresult) `AsyncIterator`, and [`SQLiteStatement.finalizeAsync()`](#finalizeasync).
+     * @param source A string containing the SQL query.
+     * @param params The parameters to bind to the prepared statement. You can pass values in array, object, or variadic arguments. See [`SQLiteBindValue`](#sqlitebindvalue) for more information about binding values.
+     * @returns Rather than returning Promise, this function returns an [`AsyncIterableIterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncIterator). You can use `for await...of` to iterate over the rows from the SQLite query result.
+     */
+    getEachAsync<T>(source: string, params: SQLiteBindParams): AsyncIterableIterator<T>;
+    /**
+     * @hidden
+     */
+    getEachAsync<T>(source: string, ...params: SQLiteVariadicBindParams): AsyncIterableIterator<T>;
+    /**
+     * A convenience wrapper around [`SQLiteDatabase.prepareAsync()`](#prepareasyncsource), [`SQLiteStatement.executeAsync()`](#executeasyncparams), [`SQLiteExecuteAsyncResult.getAllAsync()`](#getallasync), and [`SQLiteStatement.finalizeAsync()`](#finalizeasync).
+     * @param source A string containing the SQL query.
+     * @param params The parameters to bind to the prepared statement. You can pass values in array, object, or variadic arguments. See [`SQLiteBindValue`](#sqlitebindvalue) for more information about binding values.
+     * @example
+     * ```ts
+     * // For unnamed parameters, you pass values in an array.
+     * db.getAllAsync('SELECT * FROM test WHERE intValue = ? AND name = ?', [1, 'Hello']);
+     *
+     * // For unnamed parameters, you pass values in variadic arguments.
+     * db.getAllAsync('SELECT * FROM test WHERE intValue = ? AND name = ?', 1, 'Hello');
+     *
+     * // For named parameters, you should pass values in object.
+     * db.getAllAsync('SELECT * FROM test WHERE intValue = $intValue AND name = $name', { $intValue: 1, $name: 'Hello' });
+     * ```
+     */
+    getAllAsync<T>(source: string, params: SQLiteBindParams): Promise<T[]>;
+    /**
+     * @hidden
+     */
+    getAllAsync<T>(source: string, ...params: SQLiteVariadicBindParams): Promise<T[]>;
+    /**
+     * A convenience wrapper around [`SQLiteDatabase.prepareSync()`](#preparesyncsource), [`SQLiteStatement.executeSync()`](#executesyncparams), and [`SQLiteStatement.finalizeSync()`](#finalizesync).
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread and affect performance.
+     * @param source A string containing the SQL query.
+     * @param params The parameters to bind to the prepared statement. You can pass values in array, object, or variadic arguments. See [`SQLiteBindValue`](#sqlitebindvalue) for more information about binding values.
+     */
+    runSync(source: string, params: SQLiteBindParams): SQLiteRunResult;
+    /**
+     * @hidden
+     */
+    runSync(source: string, ...params: SQLiteVariadicBindParams): SQLiteRunResult;
+    /**
+     * A convenience wrapper around [`SQLiteDatabase.prepareSync()`](#preparesyncsource), [`SQLiteStatement.executeSync()`](#executesyncparams), [`SQLiteExecuteSyncResult.getFirstSync()`](#getfirstsync), and [`SQLiteStatement.finalizeSync()`](#finalizesync).
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread and affect performance.
+     * @param source A string containing the SQL query.
+     * @param params The parameters to bind to the prepared statement. You can pass values in array, object, or variadic arguments. See [`SQLiteBindValue`](#sqlitebindvalue) for more information about binding values.
+     */
+    getFirstSync<T>(source: string, params: SQLiteBindParams): T | null;
+    /**
+     * @hidden
+     */
+    getFirstSync<T>(source: string, ...params: SQLiteVariadicBindParams): T | null;
+    /**
+     * A convenience wrapper around [`SQLiteDatabase.prepareSync()`](#preparesyncsource), [`SQLiteStatement.executeSync()`](#executesyncparams), [`SQLiteExecuteSyncResult`](#sqliteexecutesyncresult) `Iterator`, and [`SQLiteStatement.finalizeSync()`](#finalizesync).
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread and affect performance.
+     * @param source A string containing the SQL query.
+     * @param params The parameters to bind to the prepared statement. You can pass values in array, object, or variadic arguments. See [`SQLiteBindValue`](#sqlitebindvalue) for more information about binding values.
+     * @returns This function returns an [`IterableIterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Iterator). You can use `for...of` to iterate over the rows from the SQLite query result.
+     */
+    getEachSync<T>(source: string, params: SQLiteBindParams): IterableIterator<T>;
+    /**
+     * @hidden
+     */
+    getEachSync<T>(source: string, ...params: SQLiteVariadicBindParams): IterableIterator<T>;
+    /**
+     * A convenience wrapper around [`SQLiteDatabase.prepareSync()`](#preparesyncsource), [`SQLiteStatement.executeSync()`](#executesyncparams), [`SQLiteExecuteSyncResult.getAllSync()`](#getallsync), and [`SQLiteStatement.finalizeSync()`](#finalizesync).
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread and affect performance.
+     * @param source A string containing the SQL query.
+     * @param params The parameters to bind to the prepared statement. You can pass values in array, object, or variadic arguments. See [`SQLiteBindValue`](#sqlitebindvalue) for more information about binding values.
+     */
+    getAllSync<T>(source: string, params: SQLiteBindParams): T[];
+    /**
+     * @hidden
+     */
+    getAllSync<T>(source: string, ...params: SQLiteVariadicBindParams): T[];
+}
+/**
+ * Open a database.
+ *
+ * @param databaseName The name of the database file to open.
+ * @param options Open options.
+ */
+export declare function openDatabaseAsync(databaseName: string, options?: SQLiteOpenOptions): Promise<SQLiteDatabase>;
+/**
+ * Open a database.
+ *
+ * > **Note:** Running heavy tasks with this function can block the JavaScript thread and affect performance.
+ *
+ * @param databaseName The name of the database file to open.
+ * @param options Open options.
+ */
+export declare function openDatabaseSync(databaseName: string, options?: SQLiteOpenOptions): SQLiteDatabase;
+/**
+ * Delete a database file.
+ *
+ * @param databaseName The name of the database file to delete.
+ */
+export declare function deleteDatabaseAsync(databaseName: string): Promise<void>;
+/**
+ * Delete a database file.
+ *
+ * > **Note:** Running heavy tasks with this function can block the JavaScript thread and affect performance.
+ *
+ * @param databaseName The name of the database file to delete.
+ */
+export declare function deleteDatabaseSync(databaseName: string): void;
+/**
+ * The event payload for the listener of [`addDatabaseChangeListener`](#sqliteadddatabasechangelistenerlistener)
+ */
+export type DatabaseChangeEvent = {
+    /** The database name. The value would be `main` by default and other database names if you use `ATTACH DATABASE` statement. */
+    databaseName: string;
+    /** The absolute file path to the database. */
+    databaseFilePath: string;
+    /** The table name. */
+    tableName: string;
+    /** The changed row ID. */
+    rowId: number;
+};
+/**
+ * Add a listener for database changes.
+ * > Note: to enable this feature, you must set [`enableChangeListener` to `true`](#sqliteopenoptions) when opening the database.
+ *
+ * @param listener A function that receives the `databaseName`, `databaseFilePath`, `tableName` and `rowId` of the modified data.
+ * @returns A `Subscription` object that you can call `remove()` on when you would like to unsubscribe the listener.
+ */
+export declare function addDatabaseChangeListener(listener: (event: DatabaseChangeEvent) => void): Subscription;
+/**
+ * A new connection specific used for [`withExclusiveTransactionAsync`](#withexclusivetransactionasynctask).
+ * @hidden not going to pull all the database methods to the document.
+ */
+declare class Transaction extends SQLiteDatabase {
+    static createAsync(db: SQLiteDatabase): Promise<Transaction>;
+}
+//# sourceMappingURL=SQLiteDatabase.d.ts.map

package/build/next/SQLiteDatabase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SQLiteDatabase.d.ts","sourceRoot":"","sources":["../../src/next/SQLiteDatabase.ts"],"names":[],"mappings":"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"}

package/build/next/{Database.js → SQLiteDatabase.js}

@@ -1,16 +1,16 @@
 import { EventEmitter } from 'expo-modules-core';
 import ExpoSQLite from './ExpoSQLiteNext';
-import { Statement } from './Statement';
+import { SQLiteStatement, } from './SQLiteStatement';
 const emitter = new EventEmitter(ExpoSQLite);
 /**
  * A SQLite database.
  */
-export class Database {
-    dbName;
+export class SQLiteDatabase {
+    databaseName;
     options;
     nativeDatabase;
-    constructor(dbName, options, nativeDatabase) {
-        this.dbName = dbName;
+    constructor(databaseName, options, nativeDatabase) {
+        this.databaseName = databaseName;
         this.options = options;
         this.nativeDatabase = nativeDatabase;
     }
@@ -36,14 +36,14 @@ export class Database {
         return this.nativeDatabase.execAsync(source);
     }
     /**
-     * Prepare a SQL statement.
+     * Create a [prepared SQLite statement](https://www.sqlite.org/c3ref/prepare.html).
      *
      * @param source A string containing the SQL query.
      */
     async prepareAsync(source) {
         const nativeStatement = new ExpoSQLite.NativeStatement();
         await this.nativeDatabase.prepareAsync(nativeStatement, source);
-        return new Statement(this.nativeDatabase, nativeStatement);
+        return new SQLiteStatement(this.nativeDatabase, nativeStatement);
     }
     /**
      * Execute a transaction and automatically commit/rollback based on the `task` result.
@@ -51,7 +51,7 @@ export class Database {
      * > **Note:** This transaction is not exclusive and can be interrupted by other async queries.
      * @example
      * ```ts
-     * db.transactionAsync(async () => {
+     * db.withTransactionAsync(async () => {
      *   await db.execAsync('UPDATE test SET name = "aaa"');
      *
      *   //
@@ -64,11 +64,11 @@ export class Database {
      * });
      * db.execAsync('UPDATE test SET name = "bbb"');
      * ```
-     * If you worry about the order of execution, use `transactionExclusiveAsync` instead.
+     * If you worry about the order of execution, use `withExclusiveTransactionAsync` instead.
      *
      * @param task An async function to execute within a transaction.
      */
-    async transactionAsync(task) {
+    async withTransactionAsync(task) {
         try {
             await this.execAsync('BEGIN');
             await task();
@@ -87,16 +87,16 @@ export class Database {
      * the other async write queries will abort with `database is locked` error.
      *
      * @param task An async function to execute within a transaction. Any queries inside the transaction must be executed on the `txn` object.
-     * The `txn` object has the same interfaces as the `Database` object. You can use `txn` like a `Database` object.
+     * The `txn` object has the same interfaces as the [`SQLiteDatabase`](#sqlitedatabase) object. You can use `txn` like a [`SQLiteDatabase`](#sqlitedatabase) object.
      *
      * @example
      * ```ts
-     * db.transactionExclusiveAsync(async (txn) => {
+     * db.withExclusiveTransactionAsync(async (txn) => {
      *   await txn.execAsync('UPDATE test SET name = "aaa"');
      * });
      * ```
      */
-    async transactionExclusiveAsync(task) {
+    async withExclusiveTransactionAsync(task) {
         const transaction = await Transaction.createAsync(this);
         let error;
         try {
@@ -140,7 +140,7 @@ export class Database {
         return this.nativeDatabase.execSync(source);
     }
     /**
-     * Prepare a SQL statement.
+     * Create a [prepared SQLite statement](https://www.sqlite.org/c3ref/prepare.html).
      *
      * > **Note:** Running heavy tasks with this function can block the JavaScript thread and affect performance.
      *
@@ -149,7 +149,7 @@ export class Database {
     prepareSync(source) {
         const nativeStatement = new ExpoSQLite.NativeStatement();
         this.nativeDatabase.prepareSync(nativeStatement, source);
-        return new Statement(this.nativeDatabase, nativeStatement);
+        return new SQLiteStatement(this.nativeDatabase, nativeStatement);
     }
     /**
      * Execute a transaction and automatically commit/rollback based on the `task` result.
@@ -158,7 +158,7 @@ export class Database {
      *
      * @param task An async function to execute within a transaction.
      */
-    transactionSync(task) {
+    withTransactionSync(task) {
         try {
             this.execSync('BEGIN');
             task();
@@ -173,151 +173,161 @@ export class Database {
         const statement = await this.prepareAsync(source);
         let result;
         try {
-            result = await statement.runAsync(...params);
+            result = await statement.executeAsync(...params);
         }
         finally {
             await statement.finalizeAsync();
         }
         return result;
     }
-    async getAsync(source, ...params) {
+    async getFirstAsync(source, ...params) {
         const statement = await this.prepareAsync(source);
-        let result;
+        let firstRow;
         try {
-            result = await statement.getAsync(...params);
+            const result = await statement.executeAsync(...params);
+            firstRow = await result.getFirstAsync();
         }
         finally {
             await statement.finalizeAsync();
         }
-        return result;
+        return firstRow;
     }
-    async *eachAsync(source, ...params) {
+    async *getEachAsync(source, ...params) {
         const statement = await this.prepareAsync(source);
         try {
-            yield* await statement.eachAsync(...params);
+            const result = await statement.executeAsync(...params);
+            for await (const row of result) {
+                yield row;
+            }
         }
         finally {
             await statement.finalizeAsync();
         }
     }
-    async allAsync(source, ...params) {
+    async getAllAsync(source, ...params) {
         const statement = await this.prepareAsync(source);
-        let result;
+        let allRows;
         try {
-            result = await statement.allAsync(...params);
+            const result = await statement.executeAsync(...params);
+            allRows = await result.getAllAsync();
         }
         finally {
             await statement.finalizeAsync();
         }
-        return result;
+        return allRows;
     }
     runSync(source, ...params) {
         const statement = this.prepareSync(source);
         let result;
         try {
-            result = statement.runSync(...params);
+            result = statement.executeSync(...params);
         }
         finally {
             statement.finalizeSync();
         }
         return result;
     }
-    getSync(source, ...params) {
+    getFirstSync(source, ...params) {
         const statement = this.prepareSync(source);
-        let result;
+        let firstRow;
         try {
-            result = statement.getSync(...params);
+            const result = statement.executeSync(...params);
+            firstRow = result.getFirstSync();
         }
         finally {
             statement.finalizeSync();
         }
-        return result;
+        return firstRow;
     }
-    *eachSync(source, ...params) {
+    *getEachSync(source, ...params) {
         const statement = this.prepareSync(source);
         try {
-            yield* statement.eachSync(...params);
+            const result = statement.executeSync(...params);
+            for (const row of result) {
+                yield row;
+            }
         }
         finally {
             statement.finalizeSync();
         }
     }
-    allSync(source, ...params) {
+    getAllSync(source, ...params) {
         const statement = this.prepareSync(source);
-        let result;
+        let allRows;
         try {
-            result = statement.allSync(...params);
+            const result = statement.executeSync(...params);
+            allRows = result.getAllSync();
         }
         finally {
             statement.finalizeSync();
         }
-        return result;
+        return allRows;
     }
 }
 /**
  * Open a database.
  *
- * @param dbName The name of the database file to open.
+ * @param databaseName The name of the database file to open.
  * @param options Open options.
  */
-export async function openDatabaseAsync(dbName, options) {
+export async function openDatabaseAsync(databaseName, options) {
     const openOptions = options ?? {};
-    const nativeDatabase = new ExpoSQLite.NativeDatabase(dbName, openOptions);
+    const nativeDatabase = new ExpoSQLite.NativeDatabase(databaseName, openOptions);
     await nativeDatabase.initAsync();
-    return new Database(dbName, openOptions, nativeDatabase);
+    return new SQLiteDatabase(databaseName, openOptions, nativeDatabase);
 }
 /**
  * Open a database.
  *
  * > **Note:** Running heavy tasks with this function can block the JavaScript thread and affect performance.
  *
- * @param dbName The name of the database file to open.
+ * @param databaseName The name of the database file to open.
  * @param options Open options.
  */
-export function openDatabaseSync(dbName, options) {
+export function openDatabaseSync(databaseName, options) {
     const openOptions = options ?? {};
-    const nativeDatabase = new ExpoSQLite.NativeDatabase(dbName, openOptions);
+    const nativeDatabase = new ExpoSQLite.NativeDatabase(databaseName, openOptions);
     nativeDatabase.initSync();
-    return new Database(dbName, openOptions, nativeDatabase);
+    return new SQLiteDatabase(databaseName, openOptions, nativeDatabase);
 }
 /**
  * Delete a database file.
  *
- * @param dbName The name of the database file to delete.
+ * @param databaseName The name of the database file to delete.
  */
-export async function deleteDatabaseAsync(dbName) {
-    return await ExpoSQLite.deleteDatabaseAsync(dbName);
+export async function deleteDatabaseAsync(databaseName) {
+    return await ExpoSQLite.deleteDatabaseAsync(databaseName);
 }
 /**
  * Delete a database file.
  *
  * > **Note:** Running heavy tasks with this function can block the JavaScript thread and affect performance.
  *
- * @param dbName The name of the database file to delete.
+ * @param databaseName The name of the database file to delete.
  */
-export function deleteDatabaseSync(dbName) {
-    return ExpoSQLite.deleteDatabaseSync(dbName);
+export function deleteDatabaseSync(databaseName) {
+    return ExpoSQLite.deleteDatabaseSync(databaseName);
 }
 /**
  * Add a listener for database changes.
- * > Note: to enable this feature, you must set [`enableChangeListener` to `true`](#openoptions) when opening the database.
+ * > Note: to enable this feature, you must set [`enableChangeListener` to `true`](#sqliteopenoptions) when opening the database.
  *
- * @param listener A function that receives the `dbFilePath`, `dbName`, `tableName` and `rowId` of the modified data.
+ * @param listener A function that receives the `databaseName`, `databaseFilePath`, `tableName` and `rowId` of the modified data.
  * @returns A `Subscription` object that you can call `remove()` on when you would like to unsubscribe the listener.
  */
 export function addDatabaseChangeListener(listener) {
     return emitter.addListener('onDatabaseChange', listener);
 }
 /**
- * A new connection specific used for [`transactionExclusiveAsync`](#transactionexclusiveasynctask).
+ * A new connection specific used for [`withExclusiveTransactionAsync`](#withexclusivetransactionasynctask).
  * @hidden not going to pull all the database methods to the document.
  */
-class Transaction extends Database {
+class Transaction extends SQLiteDatabase {
     static async createAsync(db) {
         const options = { ...db.options, useNewConnection: true };
-        const nativeDatabase = new ExpoSQLite.NativeDatabase(db.dbName, options);
+        const nativeDatabase = new ExpoSQLite.NativeDatabase(db.databaseName, options);
         await nativeDatabase.initAsync();
-        return new Transaction(db.dbName, options, nativeDatabase);
+        return new Transaction(db.databaseName, options, nativeDatabase);
     }
 }
-//# sourceMappingURL=Database.js.map
+//# sourceMappingURL=SQLiteDatabase.js.map