@itwin/core-backend 3.6.0-dev.52 → 3.6.0-dev.53

package/lib/cjs/ECDb.js

@@ -1,351 +1,351 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ECDb = exports.ECDbOpenMode = void 0;
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module ECDb
- */
-const core_bentley_1 = require("@itwin/core-bentley");
-const core_common_1 = require("@itwin/core-common");
-const BackendLoggerCategory_1 = require("./BackendLoggerCategory");
-const ConcurrentQuery_1 = require("./ConcurrentQuery");
-const ECSqlStatement_1 = require("./ECSqlStatement");
-const IModelHost_1 = require("./IModelHost");
-const SqliteStatement_1 = require("./SqliteStatement");
-const loggerCategory = BackendLoggerCategory_1.BackendLoggerCategory.ECDb;
-/** Modes for how to open [ECDb]($backend) files.
- * @public
- */
-var ECDbOpenMode;
-(function (ECDbOpenMode) {
-    ECDbOpenMode[ECDbOpenMode["Readonly"] = 0] = "Readonly";
-    ECDbOpenMode[ECDbOpenMode["ReadWrite"] = 1] = "ReadWrite";
-    /** Opens the file read-write and upgrades the file if necessary to the latest file format version. */
-    ECDbOpenMode[ECDbOpenMode["FileUpgrade"] = 2] = "FileUpgrade";
-})(ECDbOpenMode = exports.ECDbOpenMode || (exports.ECDbOpenMode = {}));
-/** An ECDb file
- * @public
- */
-class ECDb {
-    constructor() {
-        this._statementCache = new SqliteStatement_1.StatementCache();
-        this._sqliteStatementCache = new SqliteStatement_1.StatementCache();
-        this._nativeDb = new IModelHost_1.IModelHost.platform.ECDb();
-    }
-    /** only for tests
-     * @internal
-     */
-    resetSqliteCache(size) {
-        this._sqliteStatementCache.clear();
-        this._sqliteStatementCache = new SqliteStatement_1.StatementCache(size);
-    }
-    /** Call this function when finished with this ECDb object. This releases the native resources held by the
-     *  ECDb object.
-     */
-    dispose() {
-        if (!this._nativeDb)
-            return;
-        this.closeDb();
-        this._nativeDb.dispose();
-        this._nativeDb = undefined;
-    }
-    /** Create an ECDb
-     * @param pathName The path to the ECDb file to create.
-     * @throws [IModelError]($common) if the operation failed.
-     */
-    createDb(pathName) {
-        const status = this.nativeDb.createDb(pathName);
-        if (status !== core_bentley_1.DbResult.BE_SQLITE_OK)
-            throw new core_common_1.IModelError(status, "Failed to created ECDb");
-    }
-    /** Open the ECDb.
-     * @param pathName The path to the ECDb file to open
-     * @param openMode Open mode
-     * @throws [IModelError]($common) if the operation failed.
-     */
-    openDb(pathName, openMode = ECDbOpenMode.Readonly) {
-        const nativeOpenMode = openMode === ECDbOpenMode.Readonly ? core_bentley_1.OpenMode.Readonly : core_bentley_1.OpenMode.ReadWrite;
-        const tryUpgrade = openMode === ECDbOpenMode.FileUpgrade;
-        const status = this.nativeDb.openDb(pathName, nativeOpenMode, tryUpgrade);
-        if (status !== core_bentley_1.DbResult.BE_SQLITE_OK)
-            throw new core_common_1.IModelError(status, "Failed to open ECDb");
-    }
-    /** Returns true if the ECDb is open */
-    get isOpen() { return this.nativeDb.isOpen(); }
-    /** Close the Db after saving any uncommitted changes.
-     * @throws [IModelError]($common) if the database is not open.
-     */
-    closeDb() {
-        this._statementCache.clear();
-        this._sqliteStatementCache.clear();
-        this.nativeDb.closeDb();
-    }
-    /** @internal use to test statement caching */
-    clearStatementCache() {
-        this._statementCache.clear();
-    }
-    /** @internal use to test statement caching */
-    getCachedStatementCount() {
-        return this._statementCache.size;
-    }
-    /** Commit the outermost transaction, writing changes to the file. Then, restart the transaction.
-     * @param changesetName The name of the operation that generated these changes.
-     * @throws [IModelError]($common) if the database is not open or if the operation failed.
-     */
-    saveChanges(changesetName) {
-        const status = this.nativeDb.saveChanges(changesetName);
-        if (status !== core_bentley_1.DbResult.BE_SQLITE_OK)
-            throw new core_common_1.IModelError(status, "Failed to save changes");
-    }
-    /** Abandon (cancel) the outermost transaction, discarding all changes since last save. Then, restart the transaction.
-     * @throws [IModelError]($common) if the database is not open or if the operation failed.
-     */
-    abandonChanges() {
-        const status = this.nativeDb.abandonChanges();
-        if (status !== core_bentley_1.DbResult.BE_SQLITE_OK)
-            throw new core_common_1.IModelError(status, "Failed to abandon changes");
-    }
-    /** Import a schema.
-     *
-     * If the import was successful, the database is automatically saved to disk.
-     * @param pathName Path to ECSchema XML file to import.
-     * @throws [IModelError]($common) if the database is not open or if the operation failed.
-     */
-    importSchema(pathName) {
-        const status = this.nativeDb.importSchema(pathName);
-        if (status !== core_bentley_1.DbResult.BE_SQLITE_OK) {
-            core_bentley_1.Logger.logError(loggerCategory, `Failed to import schema from '${pathName}'.`);
-            throw new core_common_1.IModelError(status, `Failed to import schema from '${pathName}'.`);
-        }
-    }
-    /**
-     * Use a prepared ECSQL statement, potentially from the statement cache. If the requested statement doesn't exist
-     * in the statement cache, a new statement is prepared. After the callback completes, the statement is reset and saved
-     * in the statement cache so it can be reused in the future. Use this method for ECSQL statements that will be
-     * reused often and are expensive to prepare. The statement cache holds the most recently used statements, discarding
-     * the oldest statements as it fills. For statements you don't intend to reuse, instead use [[withStatement]].
-     * @param sql The SQLite SQL statement to execute
-     * @param callback the callback to invoke on the prepared statement
-     * @param logErrors Determines if error will be logged if statement fail to prepare
-     * @returns the value returned by `callback`.
-     * @see [[withStatement]]
-     * @public
-     */
-    withPreparedStatement(ecsql, callback, logErrors = true) {
-        var _a;
-        const stmt = (_a = this._statementCache.findAndRemove(ecsql)) !== null && _a !== void 0 ? _a : this.prepareStatement(ecsql, logErrors);
-        const release = () => this._statementCache.addOrDispose(stmt);
-        try {
-            const val = callback(stmt);
-            if (val instanceof Promise) {
-                val.then(release, release);
-            }
-            else {
-                release();
-            }
-            return val;
-        }
-        catch (err) {
-            release();
-            throw err;
-        }
-    }
-    /**
-     * Prepared and execute a callback on an ECSQL statement. After the callback completes the statement is disposed.
-     * Use this method for ECSQL statements are either not expected to be reused, or are not expensive to prepare.
-     * For statements that will be reused often, instead use [[withPreparedStatement]].
-     * @param sql The SQLite SQL statement to execute
-     * @param callback the callback to invoke on the prepared statement
-     * @param logErrors Determines if error will be logged if statement fail to prepare
-     * @returns the value returned by `callback`.
-     * @see [[withPreparedStatement]]
-     * @public
-     */
-    withStatement(ecsql, callback, logErrors = true) {
-        const stmt = this.prepareStatement(ecsql, logErrors);
-        const release = () => stmt.dispose();
-        try {
-            const val = callback(stmt);
-            if (val instanceof Promise) {
-                val.then(release, release);
-            }
-            else {
-                release();
-            }
-            return val;
-        }
-        catch (err) {
-            release();
-            throw err;
-        }
-    }
-    /** Prepare an ECSQL statement.
-     * @param ecsql The ECSQL statement to prepare
-     * @param logErrors Determines if error will be logged if statement fail to prepare
-     * @throws [IModelError]($common) if there is a problem preparing the statement.
-     */
-    prepareStatement(ecsql, logErrors = true) {
-        const stmt = new ECSqlStatement_1.ECSqlStatement();
-        stmt.prepare(this.nativeDb, ecsql, logErrors);
-        return stmt;
-    }
-    /**
-     * Use a prepared SQL statement, potentially from the statement cache. If the requested statement doesn't exist
-     * in the statement cache, a new statement is prepared. After the callback completes, the statement is reset and saved
-     * in the statement cache so it can be reused in the future. Use this method for SQL statements that will be
-     * reused often and are expensive to prepare. The statement cache holds the most recently used statements, discarding
-     * the oldest statements as it fills. For statements you don't intend to reuse, instead use [[withSqliteStatement]].
-     * @param sql The SQLite SQL statement to execute
-     * @param callback the callback to invoke on the prepared statement
-     * @param logErrors Determines if error will be logged if statement fail to prepare
-     * @returns the value returned by `callback`.
-     * @see [[withPreparedStatement]]
-     * @public
-     */
-    withPreparedSqliteStatement(sql, callback, logErrors = true) {
-        var _a;
-        const stmt = (_a = this._sqliteStatementCache.findAndRemove(sql)) !== null && _a !== void 0 ? _a : this.prepareSqliteStatement(sql, logErrors);
-        const release = () => this._sqliteStatementCache.addOrDispose(stmt);
-        try {
-            const val = callback(stmt);
-            if (val instanceof Promise) {
-                val.then(release, release);
-            }
-            else {
-                release();
-            }
-            return val;
-        }
-        catch (err) {
-            release();
-            throw err;
-        }
-    }
-    /**
-     * Prepared and execute a callback on a SQL statement. After the callback completes the statement is disposed.
-     * Use this method for SQL statements are either not expected to be reused, or are not expensive to prepare.
-     * For statements that will be reused often, instead use [[withPreparedSqliteStatement]].
-     * @param sql The SQLite SQL statement to execute
-     * @param callback the callback to invoke on the prepared statement
-     * @param logErrors Determines if error will be logged if statement fail to prepare
-     * @returns the value returned by `callback`.
-     * @public
-     */
-    withSqliteStatement(sql, callback, logErrors = true) {
-        const stmt = this.prepareSqliteStatement(sql, logErrors);
-        const release = () => stmt.dispose();
-        try {
-            const val = callback(stmt);
-            if (val instanceof Promise) {
-                val.then(release, release);
-            }
-            else {
-                release();
-            }
-            return val;
-        }
-        catch (err) {
-            release();
-            throw err;
-        }
-    }
-    /** Prepare an SQL statement.
-     * @param sql The SQLite SQL statement to prepare
-     * @param logErrors Determines if error will be logged if statement fail to prepare
-     * @throws [IModelError]($common) if there is a problem preparing the statement.
-     * @internal
-     */
-    prepareSqliteStatement(sql, logErrors = true) {
-        const stmt = new SqliteStatement_1.SqliteStatement(sql);
-        stmt.prepare(this.nativeDb, logErrors);
-        return stmt;
-    }
-    /** @internal */
-    get nativeDb() {
-        (0, core_bentley_1.assert)(undefined !== this._nativeDb);
-        return this._nativeDb;
-    }
-    /** Allow to execute query and read results along with meta data. The result are streamed.
-     * @param params The values to bind to the parameters (if the ECSQL has any).
-     * @param config Allow to specify certain flags which control how query is executed.
-     * @returns Returns *ECSqlQueryReader* which help iterate over result set and also give access to meta data.
-     * @beta
-     * */
-    createQueryReader(ecsql, params, config) {
-        if (!this._nativeDb || !this._nativeDb.isOpen()) {
-            throw new core_common_1.IModelError(core_bentley_1.DbResult.BE_SQLITE_ERROR, "db not open");
-        }
-        const executor = {
-            execute: async (request) => {
-                return ConcurrentQuery_1.ConcurrentQuery.executeQueryRequest(this.nativeDb, request);
-            },
-        };
-        return new core_common_1.ECSqlReader(executor, ecsql, params, config);
-    }
-    /** Execute a query and stream its results
-     * The result of the query is async iterator over the rows. The iterator will get next page automatically once rows in current page has been read.
-     * [ECSQL row]($docs/learning/ECSQLRowFormat).
-     *
-     * See also:
-     * - [ECSQL Overview]($docs/learning/backend/ExecutingECSQL)
-     * - [Code Examples]($docs/learning/backend/ECSQLCodeExamples)
-     *
-     * @param ecsql The ECSQL statement to execute
-     * @param params The values to bind to the parameters (if the ECSQL has any).
-     * @param options Allow to specify certain flags which control how query is executed.
-     * @returns Returns the query result as an *AsyncIterableIterator<any>*  which lazy load result as needed. The row format is determined by *rowFormat* parameter.
-     * See [ECSQL row format]($docs/learning/ECSQLRowFormat) for details about the format of the returned rows.
-     * @throws [IModelError]($common) If there was any error while submitting, preparing or stepping into query
-     */
-    async *query(ecsql, params, options) {
-        const builder = new core_common_1.QueryOptionsBuilder(options);
-        const reader = this.createQueryReader(ecsql, params, builder.getOptions());
-        while (await reader.step())
-            yield reader.formatCurrentRow();
-    }
-    /** Compute number of rows that would be returned by the ECSQL.
-     *
-     * See also:
-     * - [ECSQL Overview]($docs/learning/backend/ExecutingECSQL)
-     * - [Code Examples]($docs/learning/backend/ECSQLCodeExamples)
-     *
-     * @param ecsql The ECSQL statement to execute
-     * @param params The values to bind to the parameters (if the ECSQL has any).
-     * See "[iTwin.js Types used in ECSQL Parameter Bindings]($docs/learning/ECSQLParameterTypes)" for details.
-     * @returns Return row count.
-     * @throws [IModelError]($common) If the statement is invalid
-     */
-    async queryRowCount(ecsql, params) {
-        for await (const row of this.query(`select count(*) from (${ecsql})`, params)) {
-            return row[0];
-        }
-        throw new core_common_1.IModelError(core_bentley_1.DbResult.BE_SQLITE_ERROR, "Failed to get row count");
-    }
-    /** Cancel any previous query with same token and run execute the current specified query.
-     * The result of the query is async iterator over the rows. The iterator will get next page automatically once rows in current page has been read.
-     * [ECSQL row]($docs/learning/ECSQLRowFormat).
-     *
-     * See also:
-     * - [ECSQL Overview]($docs/learning/backend/ExecutingECSQL)
-     * - [Code Examples]($docs/learning/backend/ECSQLCodeExamples)
-     *
-     * @param ecsql The ECSQL statement to execute
-     * @param token None empty restart token. The previous query with same token would be cancelled. This would cause
-     * exception which user code must handle.
-     * @param params The values to bind to the parameters (if the ECSQL has any).
-     * @param options Allow to specify certain flags which control how query is executed.
-     * @returns Returns the query result as an *AsyncIterableIterator<any>*  which lazy load result as needed. The row format is determined by *rowFormat* parameter.
-     * See [ECSQL row format]($docs/learning/ECSQLRowFormat) for details about the format of the returned rows.
-     * @throws [IModelError]($common) If there was any error while submitting, preparing or stepping into query
-     */
-    async *restartQuery(token, ecsql, params, options) {
-        for await (const row of this.query(ecsql, params, new core_common_1.QueryOptionsBuilder(options).setRestartToken(token).getOptions())) {
-            yield row;
-        }
-    }
-}
-exports.ECDb = ECDb;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ECDb = exports.ECDbOpenMode = void 0;
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module ECDb
+ */
+const core_bentley_1 = require("@itwin/core-bentley");
+const core_common_1 = require("@itwin/core-common");
+const BackendLoggerCategory_1 = require("./BackendLoggerCategory");
+const ConcurrentQuery_1 = require("./ConcurrentQuery");
+const ECSqlStatement_1 = require("./ECSqlStatement");
+const IModelHost_1 = require("./IModelHost");
+const SqliteStatement_1 = require("./SqliteStatement");
+const loggerCategory = BackendLoggerCategory_1.BackendLoggerCategory.ECDb;
+/** Modes for how to open [ECDb]($backend) files.
+ * @public
+ */
+var ECDbOpenMode;
+(function (ECDbOpenMode) {
+    ECDbOpenMode[ECDbOpenMode["Readonly"] = 0] = "Readonly";
+    ECDbOpenMode[ECDbOpenMode["ReadWrite"] = 1] = "ReadWrite";
+    /** Opens the file read-write and upgrades the file if necessary to the latest file format version. */
+    ECDbOpenMode[ECDbOpenMode["FileUpgrade"] = 2] = "FileUpgrade";
+})(ECDbOpenMode = exports.ECDbOpenMode || (exports.ECDbOpenMode = {}));
+/** An ECDb file
+ * @public
+ */
+class ECDb {
+    constructor() {
+        this._statementCache = new SqliteStatement_1.StatementCache();
+        this._sqliteStatementCache = new SqliteStatement_1.StatementCache();
+        this._nativeDb = new IModelHost_1.IModelHost.platform.ECDb();
+    }
+    /** only for tests
+     * @internal
+     */
+    resetSqliteCache(size) {
+        this._sqliteStatementCache.clear();
+        this._sqliteStatementCache = new SqliteStatement_1.StatementCache(size);
+    }
+    /** Call this function when finished with this ECDb object. This releases the native resources held by the
+     *  ECDb object.
+     */
+    dispose() {
+        if (!this._nativeDb)
+            return;
+        this.closeDb();
+        this._nativeDb.dispose();
+        this._nativeDb = undefined;
+    }
+    /** Create an ECDb
+     * @param pathName The path to the ECDb file to create.
+     * @throws [IModelError]($common) if the operation failed.
+     */
+    createDb(pathName) {
+        const status = this.nativeDb.createDb(pathName);
+        if (status !== core_bentley_1.DbResult.BE_SQLITE_OK)
+            throw new core_common_1.IModelError(status, "Failed to created ECDb");
+    }
+    /** Open the ECDb.
+     * @param pathName The path to the ECDb file to open
+     * @param openMode Open mode
+     * @throws [IModelError]($common) if the operation failed.
+     */
+    openDb(pathName, openMode = ECDbOpenMode.Readonly) {
+        const nativeOpenMode = openMode === ECDbOpenMode.Readonly ? core_bentley_1.OpenMode.Readonly : core_bentley_1.OpenMode.ReadWrite;
+        const tryUpgrade = openMode === ECDbOpenMode.FileUpgrade;
+        const status = this.nativeDb.openDb(pathName, nativeOpenMode, tryUpgrade);
+        if (status !== core_bentley_1.DbResult.BE_SQLITE_OK)
+            throw new core_common_1.IModelError(status, "Failed to open ECDb");
+    }
+    /** Returns true if the ECDb is open */
+    get isOpen() { return this.nativeDb.isOpen(); }
+    /** Close the Db after saving any uncommitted changes.
+     * @throws [IModelError]($common) if the database is not open.
+     */
+    closeDb() {
+        this._statementCache.clear();
+        this._sqliteStatementCache.clear();
+        this.nativeDb.closeDb();
+    }
+    /** @internal use to test statement caching */
+    clearStatementCache() {
+        this._statementCache.clear();
+    }
+    /** @internal use to test statement caching */
+    getCachedStatementCount() {
+        return this._statementCache.size;
+    }
+    /** Commit the outermost transaction, writing changes to the file. Then, restart the transaction.
+     * @param changesetName The name of the operation that generated these changes.
+     * @throws [IModelError]($common) if the database is not open or if the operation failed.
+     */
+    saveChanges(changesetName) {
+        const status = this.nativeDb.saveChanges(changesetName);
+        if (status !== core_bentley_1.DbResult.BE_SQLITE_OK)
+            throw new core_common_1.IModelError(status, "Failed to save changes");
+    }
+    /** Abandon (cancel) the outermost transaction, discarding all changes since last save. Then, restart the transaction.
+     * @throws [IModelError]($common) if the database is not open or if the operation failed.
+     */
+    abandonChanges() {
+        const status = this.nativeDb.abandonChanges();
+        if (status !== core_bentley_1.DbResult.BE_SQLITE_OK)
+            throw new core_common_1.IModelError(status, "Failed to abandon changes");
+    }
+    /** Import a schema.
+     *
+     * If the import was successful, the database is automatically saved to disk.
+     * @param pathName Path to ECSchema XML file to import.
+     * @throws [IModelError]($common) if the database is not open or if the operation failed.
+     */
+    importSchema(pathName) {
+        const status = this.nativeDb.importSchema(pathName);
+        if (status !== core_bentley_1.DbResult.BE_SQLITE_OK) {
+            core_bentley_1.Logger.logError(loggerCategory, `Failed to import schema from '${pathName}'.`);
+            throw new core_common_1.IModelError(status, `Failed to import schema from '${pathName}'.`);
+        }
+    }
+    /**
+     * Use a prepared ECSQL statement, potentially from the statement cache. If the requested statement doesn't exist
+     * in the statement cache, a new statement is prepared. After the callback completes, the statement is reset and saved
+     * in the statement cache so it can be reused in the future. Use this method for ECSQL statements that will be
+     * reused often and are expensive to prepare. The statement cache holds the most recently used statements, discarding
+     * the oldest statements as it fills. For statements you don't intend to reuse, instead use [[withStatement]].
+     * @param sql The SQLite SQL statement to execute
+     * @param callback the callback to invoke on the prepared statement
+     * @param logErrors Determines if error will be logged if statement fail to prepare
+     * @returns the value returned by `callback`.
+     * @see [[withStatement]]
+     * @public
+     */
+    withPreparedStatement(ecsql, callback, logErrors = true) {
+        var _a;
+        const stmt = (_a = this._statementCache.findAndRemove(ecsql)) !== null && _a !== void 0 ? _a : this.prepareStatement(ecsql, logErrors);
+        const release = () => this._statementCache.addOrDispose(stmt);
+        try {
+            const val = callback(stmt);
+            if (val instanceof Promise) {
+                val.then(release, release);
+            }
+            else {
+                release();
+            }
+            return val;
+        }
+        catch (err) {
+            release();
+            throw err;
+        }
+    }
+    /**
+     * Prepared and execute a callback on an ECSQL statement. After the callback completes the statement is disposed.
+     * Use this method for ECSQL statements are either not expected to be reused, or are not expensive to prepare.
+     * For statements that will be reused often, instead use [[withPreparedStatement]].
+     * @param sql The SQLite SQL statement to execute
+     * @param callback the callback to invoke on the prepared statement
+     * @param logErrors Determines if error will be logged if statement fail to prepare
+     * @returns the value returned by `callback`.
+     * @see [[withPreparedStatement]]
+     * @public
+     */
+    withStatement(ecsql, callback, logErrors = true) {
+        const stmt = this.prepareStatement(ecsql, logErrors);
+        const release = () => stmt.dispose();
+        try {
+            const val = callback(stmt);
+            if (val instanceof Promise) {
+                val.then(release, release);
+            }
+            else {
+                release();
+            }
+            return val;
+        }
+        catch (err) {
+            release();
+            throw err;
+        }
+    }
+    /** Prepare an ECSQL statement.
+     * @param ecsql The ECSQL statement to prepare
+     * @param logErrors Determines if error will be logged if statement fail to prepare
+     * @throws [IModelError]($common) if there is a problem preparing the statement.
+     */
+    prepareStatement(ecsql, logErrors = true) {
+        const stmt = new ECSqlStatement_1.ECSqlStatement();
+        stmt.prepare(this.nativeDb, ecsql, logErrors);
+        return stmt;
+    }
+    /**
+     * Use a prepared SQL statement, potentially from the statement cache. If the requested statement doesn't exist
+     * in the statement cache, a new statement is prepared. After the callback completes, the statement is reset and saved
+     * in the statement cache so it can be reused in the future. Use this method for SQL statements that will be
+     * reused often and are expensive to prepare. The statement cache holds the most recently used statements, discarding
+     * the oldest statements as it fills. For statements you don't intend to reuse, instead use [[withSqliteStatement]].
+     * @param sql The SQLite SQL statement to execute
+     * @param callback the callback to invoke on the prepared statement
+     * @param logErrors Determines if error will be logged if statement fail to prepare
+     * @returns the value returned by `callback`.
+     * @see [[withPreparedStatement]]
+     * @public
+     */
+    withPreparedSqliteStatement(sql, callback, logErrors = true) {
+        var _a;
+        const stmt = (_a = this._sqliteStatementCache.findAndRemove(sql)) !== null && _a !== void 0 ? _a : this.prepareSqliteStatement(sql, logErrors);
+        const release = () => this._sqliteStatementCache.addOrDispose(stmt);
+        try {
+            const val = callback(stmt);
+            if (val instanceof Promise) {
+                val.then(release, release);
+            }
+            else {
+                release();
+            }
+            return val;
+        }
+        catch (err) {
+            release();
+            throw err;
+        }
+    }
+    /**
+     * Prepared and execute a callback on a SQL statement. After the callback completes the statement is disposed.
+     * Use this method for SQL statements are either not expected to be reused, or are not expensive to prepare.
+     * For statements that will be reused often, instead use [[withPreparedSqliteStatement]].
+     * @param sql The SQLite SQL statement to execute
+     * @param callback the callback to invoke on the prepared statement
+     * @param logErrors Determines if error will be logged if statement fail to prepare
+     * @returns the value returned by `callback`.
+     * @public
+     */
+    withSqliteStatement(sql, callback, logErrors = true) {
+        const stmt = this.prepareSqliteStatement(sql, logErrors);
+        const release = () => stmt.dispose();
+        try {
+            const val = callback(stmt);
+            if (val instanceof Promise) {
+                val.then(release, release);
+            }
+            else {
+                release();
+            }
+            return val;
+        }
+        catch (err) {
+            release();
+            throw err;
+        }
+    }
+    /** Prepare an SQL statement.
+     * @param sql The SQLite SQL statement to prepare
+     * @param logErrors Determines if error will be logged if statement fail to prepare
+     * @throws [IModelError]($common) if there is a problem preparing the statement.
+     * @internal
+     */
+    prepareSqliteStatement(sql, logErrors = true) {
+        const stmt = new SqliteStatement_1.SqliteStatement(sql);
+        stmt.prepare(this.nativeDb, logErrors);
+        return stmt;
+    }
+    /** @internal */
+    get nativeDb() {
+        (0, core_bentley_1.assert)(undefined !== this._nativeDb);
+        return this._nativeDb;
+    }
+    /** Allow to execute query and read results along with meta data. The result are streamed.
+     * @param params The values to bind to the parameters (if the ECSQL has any).
+     * @param config Allow to specify certain flags which control how query is executed.
+     * @returns Returns *ECSqlQueryReader* which help iterate over result set and also give access to meta data.
+     * @beta
+     * */
+    createQueryReader(ecsql, params, config) {
+        if (!this._nativeDb || !this._nativeDb.isOpen()) {
+            throw new core_common_1.IModelError(core_bentley_1.DbResult.BE_SQLITE_ERROR, "db not open");
+        }
+        const executor = {
+            execute: async (request) => {
+                return ConcurrentQuery_1.ConcurrentQuery.executeQueryRequest(this.nativeDb, request);
+            },
+        };
+        return new core_common_1.ECSqlReader(executor, ecsql, params, config);
+    }
+    /** Execute a query and stream its results
+     * The result of the query is async iterator over the rows. The iterator will get next page automatically once rows in current page has been read.
+     * [ECSQL row]($docs/learning/ECSQLRowFormat).
+     *
+     * See also:
+     * - [ECSQL Overview]($docs/learning/backend/ExecutingECSQL)
+     * - [Code Examples]($docs/learning/backend/ECSQLCodeExamples)
+     *
+     * @param ecsql The ECSQL statement to execute
+     * @param params The values to bind to the parameters (if the ECSQL has any).
+     * @param options Allow to specify certain flags which control how query is executed.
+     * @returns Returns the query result as an *AsyncIterableIterator<any>*  which lazy load result as needed. The row format is determined by *rowFormat* parameter.
+     * See [ECSQL row format]($docs/learning/ECSQLRowFormat) for details about the format of the returned rows.
+     * @throws [IModelError]($common) If there was any error while submitting, preparing or stepping into query
+     */
+    async *query(ecsql, params, options) {
+        const builder = new core_common_1.QueryOptionsBuilder(options);
+        const reader = this.createQueryReader(ecsql, params, builder.getOptions());
+        while (await reader.step())
+            yield reader.formatCurrentRow();
+    }
+    /** Compute number of rows that would be returned by the ECSQL.
+     *
+     * See also:
+     * - [ECSQL Overview]($docs/learning/backend/ExecutingECSQL)
+     * - [Code Examples]($docs/learning/backend/ECSQLCodeExamples)
+     *
+     * @param ecsql The ECSQL statement to execute
+     * @param params The values to bind to the parameters (if the ECSQL has any).
+     * See "[iTwin.js Types used in ECSQL Parameter Bindings]($docs/learning/ECSQLParameterTypes)" for details.
+     * @returns Return row count.
+     * @throws [IModelError]($common) If the statement is invalid
+     */
+    async queryRowCount(ecsql, params) {
+        for await (const row of this.query(`select count(*) from (${ecsql})`, params)) {
+            return row[0];
+        }
+        throw new core_common_1.IModelError(core_bentley_1.DbResult.BE_SQLITE_ERROR, "Failed to get row count");
+    }
+    /** Cancel any previous query with same token and run execute the current specified query.
+     * The result of the query is async iterator over the rows. The iterator will get next page automatically once rows in current page has been read.
+     * [ECSQL row]($docs/learning/ECSQLRowFormat).
+     *
+     * See also:
+     * - [ECSQL Overview]($docs/learning/backend/ExecutingECSQL)
+     * - [Code Examples]($docs/learning/backend/ECSQLCodeExamples)
+     *
+     * @param ecsql The ECSQL statement to execute
+     * @param token None empty restart token. The previous query with same token would be cancelled. This would cause
+     * exception which user code must handle.
+     * @param params The values to bind to the parameters (if the ECSQL has any).
+     * @param options Allow to specify certain flags which control how query is executed.
+     * @returns Returns the query result as an *AsyncIterableIterator<any>*  which lazy load result as needed. The row format is determined by *rowFormat* parameter.
+     * See [ECSQL row format]($docs/learning/ECSQLRowFormat) for details about the format of the returned rows.
+     * @throws [IModelError]($common) If there was any error while submitting, preparing or stepping into query
+     */
+    async *restartQuery(token, ecsql, params, options) {
+        for await (const row of this.query(ecsql, params, new core_common_1.QueryOptionsBuilder(options).setRestartToken(token).getOptions())) {
+            yield row;
+        }
+    }
+}
+exports.ECDb = ECDb;
 //# sourceMappingURL=ECDb.js.map