@peerbit/indexer-sqlite3 3.0.6 → 3.0.7

package/dist/src/engine.js

@@ -56,7 +56,9 @@ async function getIgnoreFK(stmt, values) {
     }
 }
 const createBatchInsertSQL = (table, rows) => {
-    const columns = table.fields.map((field) => escapeColumnName(field.name)).join(", ");
+    const columns = table.fields
+        .map((field) => escapeColumnName(field.name))
+        .join(", ");
     const rowPlaceholder = `(${table.fields.map(() => "?").join(", ")})`;
     return `insert into ${table.name} (${columns}) VALUES ${Array.from({
         length: rows,
@@ -64,6 +66,9 @@ const createBatchInsertSQL = (table, rows) => {
         .map(() => rowPlaceholder)
         .join(", ")};`;
 };
+const createInsertReturningSQL = (table) => `insert into ${table.name}  (${table.fields.map((field) => escapeColumnName(field.name)).join(", ")}) VALUES (${table.fields.map((_x) => "?").join(", ")}) RETURNING ${table.primary};`;
+const createInsertKnownIdSQL = (table) => `insert into ${table.name} (${table.fields.map((field) => escapeColumnName(field.name)).join(", ")}) VALUES (${table.fields.map((_x) => "?").join(", ")});`;
+const createReplaceSQL = (table) => `insert or replace into ${table.name} (${table.fields.map((field) => escapeColumnName(field.name)).join(", ")}) VALUES (${table.fields.map((_x) => "?").join(", ")});`;
 const canUseWithoutRowId = (table) => {
     if (table.inline || table.primary === false || !table.primaryField) {
         return false;
@@ -103,12 +108,13 @@ export class SQLiteIndex {
     primaryKeyString;
     planner;
     scopeString;
-    _rootTables;
-    _tables;
-    _cursor; // TODO choose limit better
+    _rootTables = [];
+    _tables = new Map();
+    _cursor = new Map(); // TODO choose limit better
     cursorPruner;
     iteratorTimeout;
     closed = true;
+    state = "closed";
     fkMode;
     id;
     constructor(properties, options) {
@@ -128,21 +134,75 @@ export class SQLiteIndex {
     persisted() {
         return this.properties.persisted ?? true;
     }
+    static _emptyTables = new Map();
+    static _emptyRootTables = [];
+    static _emptyCursor = new Map();
+    static closedIterator() {
+        return {
+            all: async () => [],
+            close: async () => undefined,
+            done: () => true,
+            next: async () => [],
+            pending: async () => 0,
+        };
+    }
+    async ifOpen(fallback, fn) {
+        if (this.isClosing()) {
+            return fallback;
+        }
+        this.assertOpen();
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (this.isClosing()) {
+                return fallback;
+            }
+            throw error;
+        }
+    }
+    async withWriteIfOpen(fallback, fn) {
+        if (this.isClosing()) {
+            return fallback;
+        }
+        this.assertOpen();
+        return this.withWriteBarrier(() => this.ifOpen(fallback, fn));
+    }
+    assertOpen() {
+        if (this.state !== "open") {
+            throw new types.NotStartedError();
+        }
+    }
+    isClosing() {
+        return this.state === "closing";
+    }
+    setClosing() {
+        this.state = "closing";
+        this.closed = true;
+    }
+    setClosed() {
+        this.state = "closed";
+        this.closed = true;
+    }
+    setOpen() {
+        this.state = "open";
+        this.closed = false;
+    }
     get tables() {
         if (this.closed) {
-            throw new types.NotStartedError();
+            return SQLiteIndex._emptyTables;
         }
         return this._tables;
     }
     get rootTables() {
         if (this.closed) {
-            throw new types.NotStartedError();
+            return SQLiteIndex._emptyRootTables;
         }
         return this._rootTables;
     }
     get cursor() {
         if (this.closed) {
-            throw new types.NotStartedError();
+            return SQLiteIndex._emptyCursor;
         }
         return this._cursor;
     }
@@ -166,9 +226,12 @@ export class SQLiteIndex {
         return this;
     }
     async start() {
-        if (this.closed === false) {
+        if (this.state === "open") {
             return;
         }
+        if (this.state === "closing") {
+            throw new types.NotStartedError();
+        }
         if (this.primaryKeyArr == null || this.primaryKeyArr.length === 0) {
             throw new Error("Not initialized");
         }
@@ -179,6 +242,8 @@ export class SQLiteIndex {
         false, undefined, false);
         this._rootTables = tables.filter((x) => x.parent == null);
         const allTables = tables;
+        const startupStatements = [];
+        const startupTableStatements = new Map();
         for (const table of allTables) {
             this._tables.set(table.name, table);
             for (const child of table.children) {
@@ -193,7 +258,23 @@ export class SQLiteIndex {
                 ? " strict, without rowid"
                 : " strict";
             const sqlCreateTable = `create table if not exists ${table.name} (${[...table.fields, ...table.constraints].map((s) => s.definition).join(", ")})${tableOptions}`;
-            this.properties.db.exec(sqlCreateTable);
+            startupTableStatements.set(table.name, sqlCreateTable);
+            startupStatements.push({
+                id: putStatementKey(table),
+                sql: createInsertReturningSQL(table),
+            }, {
+                id: insertKnownIdStatementKey(table),
+                sql: createInsertKnownIdSQL(table),
+            }, {
+                id: replaceStatementKey(table),
+                sql: createReplaceSQL(table),
+            });
+            if (table.parent) {
+                startupStatements.push({
+                    id: resolveChildrenStatement(table),
+                    sql: selectChildren(table),
+                });
+            }
             /* const fieldsToIndex = table.fields.filter(
                 (field) =>
                     field.key !== ARRAY_INDEX_COLUMN && field.key !== table.primary,
@@ -226,17 +307,24 @@ export class SQLiteIndex {
                     }
                 }
             } */
-            // put and return the id
-            let sqlPut = `insert into ${table.name}  (${table.fields.map((field) => escapeColumnName(field.name)).join(", ")}) VALUES (${table.fields.map((_x) => "?").join(", ")}) RETURNING ${table.primary};`;
-            // insert without replace when the caller already knows the id is fresh
-            let sqlInsertKnownId = `insert into ${table.name} (${table.fields.map((field) => escapeColumnName(field.name)).join(", ")}) VALUES (${table.fields.map((_x) => "?").join(", ")});`;
-            // insert or replace with id already defined
-            let sqlReplace = `insert or replace into ${table.name} (${table.fields.map((field) => escapeColumnName(field.name)).join(", ")}) VALUES (${table.fields.map((_x) => "?").join(", ")});`;
-            await this.properties.db.prepare(sqlPut, putStatementKey(table));
-            await this.properties.db.prepare(sqlInsertKnownId, insertKnownIdStatementKey(table));
-            await this.properties.db.prepare(sqlReplace, replaceStatementKey(table));
-            if (table.parent) {
-                await this.properties.db.prepare(selectChildren(table), resolveChildrenStatement(table));
+        }
+        if (startupTableStatements.size > 0) {
+            const existingTables = await this.getExistingSQLiteObjects("table", [
+                ...startupTableStatements.keys(),
+            ]);
+            const missingTableStatements = [...startupTableStatements.entries()]
+                .filter(([tableName]) => !existingTables.has(tableName))
+                .map(([, sql]) => sql);
+            if (missingTableStatements.length > 0) {
+                await this.properties.db.exec(missingTableStatements.join(";"));
+            }
+        }
+        if (this.properties.db.prepareMany) {
+            await this.properties.db.prepareMany(startupStatements);
+        }
+        else {
+            for (const statement of startupStatements) {
+                await this.properties.db.prepare(statement.sql, statement.id);
             }
         }
         this.cursorPruner = setInterval(() => {
@@ -247,7 +335,22 @@ export class SQLiteIndex {
                 }
             }
         }, this.iteratorTimeout);
-        this.closed = false;
+        this.setOpen();
+    }
+    async getExistingSQLiteObjects(type, names) {
+        if (names.length === 0) {
+            return new Set();
+        }
+        const sql = `select name from sqlite_master where type = ? and name in (${names
+            .map(() => "?")
+            .join(", ")})`;
+        const statement = this.properties.db.statements.get(sql) ||
+            (await this.properties.db.prepare(sql, sql));
+        const rows = await statement.all([type, ...names]);
+        await statement.reset?.();
+        return new Set(rows
+            .map((row) => row.name)
+            .filter((name) => typeof name === "string"));
     }
     async clearStatements() {
         if ((await this.properties.db.status()) === "closed") {
@@ -256,54 +359,86 @@ export class SQLiteIndex {
         }
     }
     async stop() {
-        if (this.closed) {
+        if (this.state === "closed") {
             return;
         }
-        this.closed = true;
-        clearInterval(this.cursorPruner);
-        await this.clearStatements();
-        this._tables.clear();
-        for (const [k, _v] of this._cursor) {
-            await this.clearupIterator(k);
-        }
-        await this.planner.stop();
-    }
-    async drop() {
-        if (!this.closed) {
-            this.closed = true;
+        if (this.state === "closing") {
+            await this._writeBarrier.catch(() => undefined);
+            return;
         }
-        if (this.cursorPruner != null) {
+        this.setClosing();
+        try {
             clearInterval(this.cursorPruner);
-            this.cursorPruner = undefined;
+            await this._writeBarrier.catch(() => undefined);
+            await this.clearStatements();
+            this._tables?.clear();
+            if (this._cursor) {
+                for (const [k, _v] of this._cursor) {
+                    await this.clearupIterator(k);
+                }
+            }
+            await this.planner.stop();
         }
-        const status = await this.properties.db.status?.();
-        if (status === "closed") {
-            this._tables.clear();
-            return;
+        finally {
+            this.setClosed();
         }
-        await this.clearStatements();
-        // drop root table and cascade
-        // drop table faster by dropping constraints first
-        for (const table of this._rootTables) {
-            await this.properties.db.exec(`drop table if exists ${table.name}`);
+    }
+    async drop() {
+        const wasOpen = this.state === "open";
+        if (wasOpen) {
+            this.setClosing();
         }
-        this._tables.clear();
-        for (const [k, _v] of this._cursor) {
-            await this.clearupIterator(k);
+        try {
+            if (this.cursorPruner != null) {
+                clearInterval(this.cursorPruner);
+                this.cursorPruner = undefined;
+            }
+            if (wasOpen) {
+                await this._writeBarrier.catch(() => undefined);
+            }
+            const status = await this.properties.db.status?.();
+            if (status === "closed") {
+                this._tables?.clear();
+                return;
+            }
+            await this.clearStatements();
+            // drop root table and cascade
+            // drop table faster by dropping constraints first
+            if (this._rootTables) {
+                for (const table of this._rootTables) {
+                    await this.properties.db.exec(`drop table if exists ${table.name}`);
+                }
+            }
+            this._tables?.clear();
+            if (this._cursor) {
+                for (const [k, _v] of this._cursor) {
+                    await this.clearupIterator(k);
+                }
+            }
+            await this.planner.stop();
+        }
+        finally {
+            this.setClosed();
         }
-        await this.planner.stop();
     }
     async resolveDependencies(parentId, table) {
-        const stmt = this.properties.db.statements.get(resolveChildrenStatement(table));
+        const stmt = await this.getOrPrepareStatement(resolveChildrenStatement(table), selectChildren(table));
         const results = await stmt.all([parentId]);
         await stmt.reset?.();
         return results;
     }
+    async getOrPrepareStatement(key, sql) {
+        const existing = this.properties.db.statements.get(key);
+        if (existing) {
+            return existing;
+        }
+        return this.properties.db.prepare(sql, key);
+    }
     async get(id, options) {
-        for (const table of this._rootTables) {
-            const { join: joinMap, selects } = selectAllFieldsFromTable(table, options?.shape);
-            const sql = `${generateSelectQuery(table, selects)} ${buildJoin(joinMap).join} where ${table.name}.${this.primaryKeyString} = ? limit 1`;
-            try {
+        return this.ifOpen(undefined, async () => {
+            for (const table of this._rootTables) {
+                const { join: joinMap, selects } = selectAllFieldsFromTable(table, options?.shape);
+                const sql = `${generateSelectQuery(table, selects)} ${buildJoin(joinMap).join} where ${table.name}.${this.primaryKeyString} = ? limit 1`;
                 const stmt = await this.properties.db.prepare(sql, sql);
                 const rows = await stmt.get([
                     table.primaryField?.from?.type
@@ -318,17 +453,11 @@ export class SQLiteIndex {
                     id,
                 };
             }
-            catch (error) {
-                if (this.closed) {
-                    throw new types.NotStartedError();
-                }
-                throw error;
-            }
-        }
-        return undefined;
+            return undefined;
+        });
     }
     async put(value, _id, options) {
-        return this.withWriteBarrier(async () => {
+        return this.withWriteIfOpen(undefined, async () => {
             const classOfValue = value.constructor;
             return insert(async (values, table) => {
                 let preId = values[table.primaryIndex];
@@ -337,7 +466,7 @@ export class SQLiteIndex {
                     if (preId != null) {
                         const shouldReplace = options?.replace ?? true;
                         if (!shouldReplace) {
-                            statement = this.properties.db.statements.get(insertKnownIdStatementKey(table));
+                            statement = await this.getOrPrepareStatement(insertKnownIdStatementKey(table), createInsertKnownIdSQL(table));
                             try {
                                 this.fkMode === "race-tolerant"
                                     ? await runIgnoreFK(statement, values)
@@ -348,14 +477,14 @@ export class SQLiteIndex {
                                     throw error;
                                 }
                                 await statement.reset?.();
-                                statement = this.properties.db.statements.get(replaceStatementKey(table));
+                                statement = await this.getOrPrepareStatement(replaceStatementKey(table), createReplaceSQL(table));
                                 this.fkMode === "race-tolerant"
                                     ? await runIgnoreFK(statement, values)
                                     : await statement.run(values);
                             }
                         }
                         else {
-                            statement = this.properties.db.statements.get(replaceStatementKey(table));
+                            statement = await this.getOrPrepareStatement(replaceStatementKey(table), createReplaceSQL(table));
                             this.fkMode === "race-tolerant"
                                 ? await runIgnoreFK(statement, values)
                                 : await statement.run(values);
@@ -363,7 +492,7 @@ export class SQLiteIndex {
                         return preId;
                     }
                     else {
-                        statement = this.properties.db.statements.get(putStatementKey(table));
+                        statement = await this.getOrPrepareStatement(putStatementKey(table), createInsertReturningSQL(table));
                         const out = this.fkMode === "race-tolerant"
                             ? await getIgnoreFK(statement, values)
                             : await statement.get(values);
@@ -397,6 +526,10 @@ export class SQLiteIndex {
         });
     }
     iterate(request, options) {
+        if (this.isClosing()) {
+            return SQLiteIndex.closedIterator();
+        }
+        this.assertOpen();
         // create a sql statement where the offset and the limit id dynamic and can be updated
         // TODO don't use offset but sort and limit 'next' calls by the last value of the sort
         /* 	const totalCountKey = "count"; */
@@ -417,54 +550,72 @@ export class SQLiteIndex {
         let planningScope;
         /* let totalCount: undefined | number = undefined; */
         const fetch = async (amount) => {
-            kept = undefined;
-            if (!once) {
-                planningScope = this.planner.scope(normalizedQuery);
-                let { sql, bindable: toBind } = convertSearchRequestToQuery(normalizedQuery, this.tables, this._rootTables, {
-                    planner: planningScope,
-                    shape: options?.shape,
-                    fetchAll: amount === "all", // if we are to fetch all, we dont need stable sorting
-                });
-                sqlFetch = sql;
-                bindable = toBind;
-                await planningScope.beforePrepare();
-                stmt = await this.properties.db.prepare(sqlFetch, sqlFetch);
-                // Bump timeout timer
-                iterator.expire = Date.now() + this.iteratorTimeout;
+            const closeAsDone = () => {
+                once = true;
+                hasMore = false;
+                kept = 0;
+                return [];
+            };
+            if (this.isClosing()) {
+                return closeAsDone();
             }
-            once = true;
-            const allResults = await planningScope.perform(async () => {
-                const allResults = await stmt.all([
+            this.assertOpen();
+            try {
+                kept = undefined;
+                if (!once) {
+                    planningScope = this.planner.scope(normalizedQuery);
+                    let { sql, bindable: toBind } = convertSearchRequestToQuery(normalizedQuery, this.tables, this._rootTables, {
+                        planner: planningScope,
+                        shape: options?.shape,
+                        fetchAll: amount === "all", // if we are to fetch all, we dont need stable sorting
+                    });
+                    sqlFetch = sql;
+                    bindable = toBind;
+                    await planningScope.beforePrepare();
+                    stmt = await this.properties.db.prepare(sqlFetch, sqlFetch);
+                    // Bump timeout timer
+                    iterator.expire = Date.now() + this.iteratorTimeout;
+                }
+                once = true;
+                const allResults = await planningScope.perform(async () => {
+                    const allResults = await stmt.all([
+                        ...bindable,
+                        ...(amount !== "all" ? [amount, offset] : []),
+                    ]);
+                    return allResults;
+                });
+                /* const allResults: Record<string, any>[] = await stmt.all([
                     ...bindable,
-                    ...(amount !== "all" ? [amount, offset] : []),
+                    ...(amount !== "all" ? [amount,
+                        offset] : [])
                 ]);
-                return allResults;
-            });
-            /* const allResults: Record<string, any>[] = await stmt.all([
-                ...bindable,
-                ...(amount !== "all" ? [amount,
-                    offset] : [])
-            ]);
-    */
-            let results = await Promise.all(allResults.map(async (row) => {
-                let selectedTable = this._rootTables.find((table) => row[getTablePrefixedField(table, this.primaryKeyString)] !=
-                    null);
-                const value = await resolveInstanceFromValue(row, this.tables, selectedTable, this.resolveDependencies.bind(this), true, options?.shape);
-                return {
-                    value,
-                    id: types.toId(convertFromSQLType(row[getTablePrefixedField(selectedTable, this.primaryKeyString)], selectedTable.primaryField.from.type)),
-                };
-            }));
-            offset += results.length;
-            /* const uniqueIds = new Set(results.map((x) => x.id.primitive));
-            if (uniqueIds.size !== results.length) {
-                throw new Error("Duplicate ids in result set");
-            } */
-            if (amount === "all" || results.length < amount) {
-                hasMore = false;
-                await this.clearupIterator(requestId);
+        */
+                let results = await Promise.all(allResults.map(async (row) => {
+                    let selectedTable = this._rootTables.find((table) => row[getTablePrefixedField(table, this.primaryKeyString)] !=
+                        null);
+                    const value = await resolveInstanceFromValue(row, this.tables, selectedTable, this.resolveDependencies.bind(this), true, options?.shape);
+                    return {
+                        value,
+                        id: types.toId(convertFromSQLType(row[getTablePrefixedField(selectedTable, this.primaryKeyString)], selectedTable.primaryField.from.type)),
+                    };
+                }));
+                offset += results.length;
+                /* const uniqueIds = new Set(results.map((x) => x.id.primitive));
+                if (uniqueIds.size !== results.length) {
+                    throw new Error("Duplicate ids in result set");
+                } */
+                if (amount === "all" || results.length < amount) {
+                    hasMore = false;
+                    await this.clearupIterator(requestId);
+                }
+                return results;
+            }
+            catch (error) {
+                if (this.isClosing()) {
+                    return closeAsDone();
+                }
+                throw error;
             }
-            return results;
         };
         const iterator = {
             fetch,
@@ -487,12 +638,20 @@ export class SQLiteIndex {
                 return results;
             },
             close: () => {
+                once = true;
                 hasMore = false;
                 kept = 0;
                 this.clearupIterator(requestId);
             },
             next: (amount) => fetch(amount),
             pending: async () => {
+                if (this.isClosing()) {
+                    once = true;
+                    hasMore = false;
+                    kept = 0;
+                    return 0;
+                }
+                this.assertOpen();
                 if (!hasMore) {
                     return 0;
                 }
@@ -504,7 +663,12 @@ export class SQLiteIndex {
                 hasMore = kept > 0;
                 return kept;
             },
-            done: () => (once ? !hasMore : undefined),
+            done: () => {
+                if (this.isClosing()) {
+                    return true;
+                }
+                return once ? !hasMore : undefined;
+            },
         };
     }
     async clearupIterator(id) {
@@ -517,25 +681,33 @@ export class SQLiteIndex {
         this._cursor.delete(id);
     }
     async getSize() {
-        if (this.tables.size === 0) {
-            return 0;
-        }
-        /* const stmt = await this.properties.db.prepare(`select count(*) as total from ${this.rootTableName}`);
-        const result = await stmt.get()
-        stmt.finalize?.();
-        return result.total as number */
-        return this.count();
+        return this.ifOpen(0, async () => {
+            if (this.tables.size === 0) {
+                return 0;
+            }
+            /* const stmt = await this.properties.db.prepare(`select count(*) as total from ${this.rootTableName}`);
+            const result = await stmt.get()
+            stmt.finalize?.();
+            return result.total as number */
+            return this.count();
+        });
     }
     async del(query) {
-        return this.withWriteBarrier(async () => {
+        return this.withWriteIfOpen([], async () => {
             let ret = [];
             let once = false;
             let lastError = undefined;
             for (const table of this._rootTables) {
                 try {
-                    const { sql, bindable } = convertDeleteRequestToQuery(query, this.tables, table);
+                    const planningScope = this.planner.scope(new PlannableQuery({
+                        query: coerceLocalQueries(query.query),
+                    }));
+                    const { sql, bindable } = convertDeleteRequestToQuery(query, this.tables, table, {
+                        planner: planningScope,
+                    });
+                    await planningScope.beforePrepare();
                     const stmt = await this.properties.db.prepare(sql, sql);
-                    const results = await stmt.all(bindable);
+                    const results = await planningScope.perform(async () => stmt.all(bindable));
                     // TODO types
                     for (const result of results) {
                         ret.push(types.toId(convertFromSQLType(result[table.primary], table.primaryField.from.type)));
@@ -557,73 +729,83 @@ export class SQLiteIndex {
         });
     }
     async sum(query) {
-        let ret = undefined;
-        let once = false;
-        let lastError = undefined;
-        let inlinedName = getInlineTableFieldName(query.key);
-        for (const table of this._rootTables) {
-            try {
-                if (table.fields.find((x) => x.name === inlinedName) == null) {
-                    lastError = new MissingFieldError("Missing field: " +
-                        (Array.isArray(query.key) ? query.key : [query.key]).join("."));
-                    continue;
-                }
-                const { sql, bindable } = convertSumRequestToQuery(query, this.tables, table);
-                const stmt = await this.properties.db.prepare(sql, sql);
-                const result = await stmt.get(bindable);
-                if (result != null) {
-                    const value = result.sum;
-                    if (ret == null) {
-                        ret = value;
+        return this.ifOpen(0, async () => {
+            let ret = undefined;
+            let once = false;
+            let lastError = undefined;
+            let inlinedName = getInlineTableFieldName(query.key);
+            for (const table of this._rootTables) {
+                try {
+                    if (table.fields.find((x) => x.name === inlinedName) == null) {
+                        lastError = new MissingFieldError("Missing field: " +
+                            (Array.isArray(query.key) ? query.key : [query.key]).join("."));
+                        continue;
                     }
-                    else {
-                        ret += value;
+                    const planningScope = this.planner.scope(new PlannableQuery({
+                        query: coerceLocalQueries(query.query),
+                    }));
+                    const { sql, bindable } = convertSumRequestToQuery(query, this.tables, table, {
+                        planner: planningScope,
+                    });
+                    await planningScope.beforePrepare();
+                    const stmt = await this.properties.db.prepare(sql, sql);
+                    const result = await planningScope.perform(async () => stmt.get(bindable));
+                    if (result != null) {
+                        const value = result.sum;
+                        if (ret == null) {
+                            ret = value;
+                        }
+                        else {
+                            ret += value;
+                        }
+                        once = true;
                     }
-                    once = true;
                 }
-            }
-            catch (error) {
-                if (error instanceof MissingFieldError) {
-                    lastError = error;
-                    continue;
+                catch (error) {
+                    if (error instanceof MissingFieldError) {
+                        lastError = error;
+                        continue;
+                    }
+                    throw error;
                 }
-                throw error;
             }
-        }
-        if (!once) {
-            throw lastError;
-        }
-        return ret != null ? ret : 0;
+            if (!once) {
+                throw lastError;
+            }
+            return ret != null ? ret : 0;
+        });
     }
     async count(request) {
-        let ret = 0;
-        let once = false;
-        let lastError = undefined;
-        for (const table of this._rootTables) {
-            try {
-                const { sql, bindable } = convertCountRequestToQuery(request, this.tables, table);
-                const stmt = await this.properties.db.prepare(sql, sql);
-                const result = await stmt.get(bindable);
-                if (result != null) {
-                    ret += Number(result.count);
-                    once = true;
+        return this.ifOpen(0, async () => {
+            let ret = 0;
+            let once = false;
+            let lastError = undefined;
+            for (const table of this._rootTables) {
+                try {
+                    const { sql, bindable } = convertCountRequestToQuery(request, this.tables, table);
+                    const stmt = await this.properties.db.prepare(sql, sql);
+                    const result = await stmt.get(bindable);
+                    if (result != null) {
+                        ret += Number(result.count);
+                        once = true;
+                    }
                 }
-            }
-            catch (error) {
-                if (error instanceof MissingFieldError) {
-                    lastError = error;
-                    continue;
+                catch (error) {
+                    if (error instanceof MissingFieldError) {
+                        lastError = error;
+                        continue;
+                    }
+                    throw error;
                 }
-                throw error;
             }
-        }
-        if (!once) {
-            throw lastError;
-        }
-        return ret;
+            if (!once) {
+                throw lastError;
+            }
+            return ret;
+        });
     }
     get cursorCount() {
-        return this.cursor.size;
+        return this.closed ? 0 : this._cursor.size;
     }
 }
 export class SQLiteIndices {
@@ -683,7 +865,10 @@ export class SQLiteIndices {
     async start() {
         this.closed = false;
         if (!this.properties.parent) {
-            await this.properties.db.open();
+            const status = await this.properties.db.status();
+            if (status !== "open") {
+                await this.properties.db.open();
+            }
         }
         for (const scope of this.scopes.values()) {
             await scope.start();