@ohos-ports/libsql-client 0.18.0-beta.0

package/lib-esm/sql_cache.js

@@ -0,0 +1,87 @@
+export class SqlCache {
+    #owner;
+    #sqls;
+    capacity;
+    constructor(owner, capacity) {
+        this.#owner = owner;
+        this.#sqls = new Lru();
+        this.capacity = capacity;
+    }
+    // Replaces SQL strings with cached `hrana.Sql` objects in the statements in `hranaStmts`. After this
+    // function returns, we guarantee that all `hranaStmts` refer to valid (not closed) `hrana.Sql` objects,
+    // but _we may invalidate any other `hrana.Sql` objects_ (by closing them, thus removing them from the
+    // server).
+    //
+    // In practice, this means that after calling this function, you can use the statements only up to the
+    // first `await`, because concurrent code may also use the cache and invalidate those statements.
+    apply(hranaStmts) {
+        if (this.capacity <= 0) {
+            return;
+        }
+        const usedSqlObjs = new Set();
+        for (const hranaStmt of hranaStmts) {
+            if (typeof hranaStmt.sql !== "string") {
+                continue;
+            }
+            const sqlText = hranaStmt.sql;
+            // Stored SQL cannot exceed 5kb.
+            // https://github.com/tursodatabase/libsql/blob/e9d637e051685f92b0da43849507b5ef4232fbeb/libsql-server/src/hrana/http/request.rs#L10
+            if (sqlText.length >= 5000) {
+                continue;
+            }
+            let sqlObj = this.#sqls.get(sqlText);
+            if (sqlObj === undefined) {
+                while (this.#sqls.size + 1 > this.capacity) {
+                    const [evictSqlText, evictSqlObj] = this.#sqls.peekLru();
+                    if (usedSqlObjs.has(evictSqlObj)) {
+                        // The SQL object that we are trying to evict is already in use in this batch, so we
+                        // must not evict and close it.
+                        break;
+                    }
+                    evictSqlObj.close();
+                    this.#sqls.delete(evictSqlText);
+                }
+                if (this.#sqls.size + 1 <= this.capacity) {
+                    sqlObj = this.#owner.storeSql(sqlText);
+                    this.#sqls.set(sqlText, sqlObj);
+                }
+            }
+            if (sqlObj !== undefined) {
+                hranaStmt.sql = sqlObj;
+                usedSqlObjs.add(sqlObj);
+            }
+        }
+    }
+}
+class Lru {
+    // This maps keys to the cache values. The entries are ordered by their last use (entires that were used
+    // most recently are at the end).
+    #cache;
+    constructor() {
+        this.#cache = new Map();
+    }
+    get(key) {
+        const value = this.#cache.get(key);
+        if (value !== undefined) {
+            // move the entry to the back of the Map
+            this.#cache.delete(key);
+            this.#cache.set(key, value);
+        }
+        return value;
+    }
+    set(key, value) {
+        this.#cache.set(key, value);
+    }
+    peekLru() {
+        for (const entry of this.#cache.entries()) {
+            return entry;
+        }
+        return undefined;
+    }
+    delete(key) {
+        this.#cache.delete(key);
+    }
+    get size() {
+        return this.#cache.size;
+    }
+}

package/lib-esm/sqlite3.d.ts

@@ -0,0 +1,53 @@
+import Database from "@ohos-ports/libsql";
+import type { Config, IntMode, Client, Transaction, TransactionMode, ResultSet, InStatement, InArgs, Replicated } from "@libsql/core/api";
+import type { ExpandedConfig } from "@libsql/core/config";
+export * from "@libsql/core/api";
+export declare function createClient(config: Config): Client;
+/** @private */
+export declare function _createClient(config: ExpandedConfig): Client;
+/**
+ * A client owns a small pool of connections to one database, in the same way
+ * that a remote client owns a set of hrana streams: every client operation
+ * borrows one for the duration of the call, and a transaction borrows one for
+ * its lifetime and gives it back on commit, rollback or close. Nothing is
+ * shared between an open transaction and the rest of the client.
+ *
+ * @private
+ */
+export declare class ConnectionPool {
+    #private;
+    constructor(path: string, options: Database.Options, maxConnections: number);
+    acquire(forTransaction?: boolean): Promise<Database.Database>;
+    acquireSync(forTransaction?: boolean): Database.Database;
+    release(db: Database.Database): void;
+    close(): void;
+    reopen(): void;
+}
+export declare class Sqlite3Client implements Client {
+    #private;
+    closed: boolean;
+    protocol: "file";
+    /** @private */
+    constructor(pool: ConnectionPool, intMode: IntMode);
+    execute(stmtOrSql: InStatement | string, args?: InArgs): Promise<ResultSet>;
+    batch(stmts: Array<InStatement | [string, InArgs?]>, mode?: TransactionMode): Promise<Array<ResultSet>>;
+    migrate(stmts: Array<InStatement>): Promise<Array<ResultSet>>;
+    transaction(mode?: TransactionMode): Promise<Transaction>;
+    executeMultiple(sql: string): Promise<void>;
+    sync(): Promise<Replicated>;
+    reconnect(): Promise<void>;
+    close(): void;
+}
+export declare class Sqlite3Transaction implements Transaction {
+    #private;
+    /** @private */
+    constructor(database: Database.Database, intMode: IntMode, release: (db: Database.Database) => void);
+    execute(stmt: InStatement): Promise<ResultSet>;
+    execute(sql: string, args?: InArgs): Promise<ResultSet>;
+    batch(stmts: Array<InStatement | [string, InArgs?]>): Promise<Array<ResultSet>>;
+    executeMultiple(sql: string): Promise<void>;
+    rollback(): Promise<void>;
+    commit(): Promise<void>;
+    close(): void;
+    get closed(): boolean;
+}