@retaw106/mmc-oc 2.3.0 → 2.5.0

package/src/shared/sqlite-foreground-wait.test.ts

@@ -1,4 +1,4 @@
-import { expect, test } from "bun:test";
+import { expect, spyOn, test } from "bun:test";
 import { rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -11,6 +11,7 @@ import {
     withPrivilegedWriter,
     withSqliteTransformPass,
 } from "./sqlite";
+import { startSqliteWriteLocker } from "./sqlite-write-locker-test-support";
 import { createTestTempDirFromPath } from "./test-temp-dir";
 
 function fixture() {
@@ -66,3 +67,238 @@ for (const mode of ["BEGIN", "autocommit"]) {
         }
     });
 }
+
+// Fork shape: upstream drives the "slow uncontended SQL preserves admission"
+// pair through the OC1 messages-transform handler (deleted in this fork — see
+// the note above); the lease invariant it protects is asserted here against
+// the core primitives instead.
+test("uncontended autocommit work does not consume the foreground wait budget", async () => {
+    const { db, path, close } = fixture();
+    const blocker = new Database(path);
+    const timeouts: number[] = [];
+    const nativeExec = db.exec.bind(db);
+    const exec = spyOn(db, "exec").mockImplementation((sql) => {
+        const timeout = /^PRAGMA busy_timeout=(\d+)$/.exec(sql);
+        if (timeout) timeouts.push(Number(timeout[1]));
+        return nativeExec(sql);
+    });
+    try {
+        await withSqliteTransformPass(async () => {
+            guardSqliteTransformPass({ assert() {}, remainingMs: () => 30_000 });
+            // Spend ~1.5s inside successful, uncontended SQL. Recursive CTEs
+            // keep this independent of CPU speed and UDF APIs.
+            const cte =
+                "WITH RECURSIVE n(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM n WHERE x<1000000)";
+            const slowWrite = db.prepare(
+                `${cte} INSERT INTO result SELECT sum(x) FROM n RETURNING value`,
+            );
+            const slowRead = db.prepare(`${cte} SELECT sum(x) FROM n`);
+            const started = performance.now();
+            do {
+                slowWrite.all();
+                slowRead.all();
+            } while (performance.now() - started < 1500);
+            // The contended retry must still see (nearly) the full budget.
+            blocker.exec("BEGIN IMMEDIATE");
+            timeouts.length = 0;
+            expect(() => db.prepare("INSERT INTO result VALUES ('blocked')").run()).toThrow(
+                SqliteAcquisitionBusyError,
+            );
+        });
+        expect(timeouts[0]).toBe(0);
+        expect(timeouts[1]).toBeGreaterThanOrEqual(1900);
+    } finally {
+        exec.mockRestore();
+        if (blocker.inTransaction) blocker.exec("ROLLBACK");
+        blocker.close();
+        close();
+    }
+}, 30_000);
+
+test("BUSY autocommit probes do not double-apply INSERT OR IGNORE, UPSERT or RETURNING", async () => {
+    const { db, path, close } = fixture();
+    db.exec(
+        "CREATE TABLE counter(id INTEGER PRIMARY KEY, n INTEGER); INSERT INTO counter VALUES (1, 0)",
+    );
+    const forms = [
+        ["INSERT OR IGNORE INTO counter VALUES (2, 1)", "run"],
+        ["INSERT INTO counter VALUES (1, 1) ON CONFLICT(id) DO UPDATE SET n = n + 1", "run"],
+        ["UPDATE counter SET n = n + 1 WHERE id = 1 RETURNING n", "get"],
+        [
+            "INSERT INTO counter VALUES (1, 1) ON CONFLICT(id) DO UPDATE SET n = n + 1 RETURNING n",
+            "all",
+        ],
+    ] as const;
+    try {
+        for (const [sql, method] of forms) {
+            const blocker = new Database(path);
+            blocker.exec("BEGIN IMMEDIATE");
+            db.exec("PRAGMA busy_timeout=0");
+            const before = db.prepare("SELECT * FROM counter ORDER BY id").all();
+            try {
+                expect(() => db.prepare(sql)[method]()).toThrow("locked");
+                expect(db.prepare("SELECT * FROM counter ORDER BY id").all()).toEqual(before);
+                expect(db.inTransaction).toBe(false);
+            } finally {
+                blocker.exec("ROLLBACK");
+                blocker.close();
+            }
+            const locker = await startSqliteWriteLocker(path, 100);
+            try {
+                await withSqliteTransformPass(() => db.prepare(sql)[method]());
+            } finally {
+                expect(await locker.exited).toBe(0);
+            }
+        }
+        expect(db.prepare("SELECT * FROM counter ORDER BY id").all()).toEqual([
+            { id: 1, n: 3 },
+            { id: 2, n: 1 },
+        ]);
+    } finally {
+        close();
+    }
+}, 30_000);
+
+test("many contended autocommit writes share at most two seconds of lock waiting", async () => {
+    const { db, path, close } = fixture();
+    const blocker = new Database(path);
+    blocker.exec("BEGIN IMMEDIATE");
+    const timeouts: number[] = [];
+    const nativeExec = db.exec.bind(db);
+    const exec = spyOn(db, "exec").mockImplementation((sql) => {
+        const timeout = /^PRAGMA busy_timeout=(\d+)$/.exec(sql);
+        if (timeout) timeouts.push(Number(timeout[1]));
+        return nativeExec(sql);
+    });
+    try {
+        await withSqliteTransformPass(() => {
+            // Use real BUSY failures but a controlled accounting clock: each
+            // retry costs 400ms regardless of runner scheduling. The deadline
+            // keeps the real waits short without hiding lease exhaustion.
+            guardSqliteTransformPass({ assert() {}, remainingMs: () => 10 });
+            let now = 0;
+            const clock = spyOn(performance, "now").mockImplementation(() => (now += 400));
+            try {
+                for (let i = 0; i < 8; i++) {
+                    expect(() => db.prepare("INSERT INTO result VALUES ('one')").run()).toThrow(
+                        SqliteAcquisitionBusyError,
+                    );
+                }
+            } finally {
+                clock.mockRestore();
+            }
+            // Five charged retries exhaust 2000ms. All later retries must have
+            // zero timeout even though the deadline still offers another 10ms.
+            expect(timeouts).toEqual([
+                ...Array.from({ length: 5 }, () => [0, 10, 5000]).flat(),
+                ...Array.from({ length: 3 }, () => [0, 0, 5000]).flat(),
+            ]);
+            blocker.exec("ROLLBACK");
+            db.prepare("INSERT INTO result VALUES ('uncontended')").run();
+        });
+        expect(db.prepare("SELECT * FROM result").all()).toEqual([{ value: "uncontended" }]);
+    } finally {
+        exec.mockRestore();
+        if (blocker.inTransaction) blocker.exec("ROLLBACK");
+        blocker.close();
+        close();
+    }
+}, 30_000);
+
+test("an exec script charges its single attempt without a zero-wait probe", () => {
+    const { db, path, close } = fixture();
+    const blocker = new Database(path);
+    const timeouts: number[] = [];
+    const nativeExec = db.exec.bind(db);
+    const exec = spyOn(db, "exec").mockImplementation((sql) => {
+        const timeout = /^PRAGMA busy_timeout=(\d+)$/.exec(sql);
+        if (timeout) timeouts.push(Number(timeout[1]));
+        return nativeExec(sql);
+    });
+    try {
+        withSqliteTransformPass(() => {
+            let now = 0;
+            const clock = spyOn(performance, "now").mockImplementation(() => (now += 2500));
+            try {
+                db.exec(
+                    "INSERT INTO result VALUES ('prefix'); INSERT INTO result VALUES ('suffix')",
+                );
+            } finally {
+                clock.mockRestore();
+            }
+            blocker.exec("BEGIN IMMEDIATE");
+            expect(() => db.prepare("INSERT INTO result VALUES ('blocked')").run()).toThrow(
+                SqliteAcquisitionBusyError,
+            );
+        });
+        expect(timeouts).toEqual([2000, 5000, 0, 0, 5000]);
+        expect(db.prepare("SELECT * FROM result").all()).toEqual([
+            { value: "prefix" },
+            { value: "suffix" },
+        ]);
+    } finally {
+        exec.mockRestore();
+        if (blocker.inTransaction) blocker.exec("ROLLBACK");
+        blocker.close();
+        close();
+    }
+});
+
+test("an explicit transaction keeps its timeout and never probes or retries", () => {
+    const { db, path, close } = fixture();
+    const other = new Database(path);
+    db.exec("PRAGMA busy_timeout=0; BEGIN; SELECT * FROM result");
+    other.exec("INSERT INTO result VALUES ('other')");
+    const exec = spyOn(db, "exec");
+    try {
+        withSqliteTransformPass(() => {
+            expect(() => db.prepare("INSERT INTO result VALUES ('stale')").run()).toThrow("locked");
+        });
+        expect(exec).not.toHaveBeenCalled();
+        expect(db.inTransaction).toBe(true);
+        expect(db.prepare("PRAGMA busy_timeout").get()).toEqual({ timeout: 0 });
+    } finally {
+        exec.mockRestore();
+        if (db.inTransaction) db.exec("ROLLBACK");
+        other.close();
+        close();
+    }
+});
+
+test("an autocommit exec script never replays a committed prefix after BUSY", () => {
+    const main = fixture();
+    const auxiliary = fixture();
+    const free = fixture();
+    try {
+        main.db.prepare("ATTACH DATABASE ? AS aux").run(auxiliary.path);
+        main.db.prepare("ATTACH DATABASE ? AS free").run(free.path);
+        auxiliary.db.exec("BEGIN IMMEDIATE");
+        withSqliteTransformPass(() => {
+            guardSqliteTransformPass({ assert() {}, remainingMs: () => 100 });
+            expect(() =>
+                main.db.exec(
+                    "INSERT INTO main.result VALUES ('prefix'); INSERT INTO aux.result VALUES ('blocked')",
+                ),
+            ).toThrow(SqliteAcquisitionBusyError);
+            expect(() =>
+                main.db.exec(
+                    "CREATE TABLE applied_once(id); INSERT INTO aux.result VALUES ('blocked')",
+                ),
+            ).toThrow(SqliteAcquisitionBusyError);
+            expect(() =>
+                main.db.exec(
+                    "CREATE TABLE free.applied_once(id); INSERT INTO aux.result VALUES ('blocked')",
+                ),
+            ).toThrow(SqliteAcquisitionBusyError);
+        });
+        expect(main.db.prepare("SELECT * FROM main.result").all()).toEqual([{ value: "prefix" }]);
+        expect(
+            main.db.prepare("SELECT name FROM sqlite_schema WHERE name='applied_once'").all(),
+        ).toHaveLength(1);
+    } finally {
+        auxiliary.db.exec("ROLLBACK");
+        auxiliary.close();
+        main.close();
+        free.close();
+    }
+});

package/src/shared/sqlite-turn-deadline.test.ts

@@ -0,0 +1,286 @@
+import { Database as NativeDatabase } from "bun:sqlite";
+import { expect, spyOn, test } from "bun:test";
+import { rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+    createSqliteTurnDatabase,
+    Database,
+    hasSqliteTurnDeadlineRouting,
+    withoutSqliteTransformPass,
+    withSqliteBackgroundWriter,
+    withSqliteTransformPass,
+    withSqliteTurnDeadline,
+} from "./sqlite";
+import { createTestTempDirFromPath } from "./test-temp-dir";
+
+async function fixture(run: (db: Database, path: string) => Promise<void>) {
+    const root = createTestTempDirFromPath(join(tmpdir(), "sqlite-turn-deadline-"));
+    const path = join(root, "context.db");
+    const db = createSqliteTurnDatabase(path);
+    db.exec(
+        "PRAGMA journal_mode=DELETE; PRAGMA busy_timeout=900; CREATE TABLE t(value); INSERT INTO t VALUES(1)",
+    );
+    try {
+        await run(db, path);
+    } finally {
+        db.close();
+        rmSync(root, { recursive: true, force: true });
+    }
+}
+
+async function hold(path: string, reader = false) {
+    const child = Bun.spawn(
+        [
+            process.execPath,
+            "-e",
+            `
+        const { Database } = require('bun:sqlite');
+        const db = new Database(process.argv[1]);
+        db.exec(${JSON.stringify(reader ? "BEGIN; SELECT * FROM t" : "BEGIN EXCLUSIVE")});
+        console.log('HELD');
+        setInterval(() => {}, 1000);
+        `,
+            path,
+        ],
+        { stdout: "pipe", stderr: "pipe", windowsHide: true },
+    );
+    const output = child.stdout.getReader();
+    const first = await output.read();
+    output.releaseLock();
+    if (!new TextDecoder().decode(first.value).includes("HELD")) {
+        child.kill();
+        throw new Error(`holder failed: ${await new Response(child.stderr).text()}`);
+    }
+    return async () => {
+        child.kill();
+        await child.exited;
+    };
+}
+
+function timeout(db: Database): number {
+    return (db.prepare("PRAGMA busy_timeout").get() as { timeout: number }).timeout;
+}
+
+function bounded(operation: () => unknown) {
+    const start = performance.now();
+    expect(() =>
+        withSqliteTurnDeadline(() => Math.max(0, 80 - (performance.now() - start)), operation),
+    ).toThrow(/locked|busy/i);
+    expect(performance.now() - start).toBeLessThan(400);
+    expect(performance.now() - start).toBeGreaterThan(40);
+}
+
+test("ordinary connections keep native cached SELECT methods and do not opt in", () => {
+    const db = new Database(":memory:");
+    const native = new NativeDatabase(":memory:");
+    try {
+        expect(hasSqliteTurnDeadlineRouting(db)).toBe(false);
+        expect(db.prepare("SELECT 1").get).toBe(native.prepare("SELECT 1").get);
+    } finally {
+        db.close();
+        native.close();
+    }
+});
+
+test("native deadline timeout is read once, not on every cached SELECT", () => {
+    let reads = 0;
+    const prepare = Database.prototype.prepare;
+    const spy = spyOn(Database.prototype, "prepare").mockImplementation(function (
+        this: Database,
+        sql: string,
+    ) {
+        const statement = prepare.call(this, sql);
+        if (sql === "PRAGMA busy_timeout") {
+            const get = statement.get.bind(statement);
+            statement.get = (...args: unknown[]) => {
+                reads++;
+                return get(...args);
+            };
+        }
+        return statement;
+    });
+    let db: Database | undefined;
+    try {
+        db = createSqliteTurnDatabase(":memory:");
+        db.exec("PRAGMA busy_timeout=900");
+        const read = db.prepare("SELECT 1 AS value");
+        withSqliteTurnDeadline(
+            () => 80,
+            () => {
+                for (let i = 0; i < 100; i++) expect(read.get()).toEqual({ value: 1 });
+            },
+        );
+        expect(reads).toBe(1);
+    } finally {
+        db?.close();
+        spy.mockRestore();
+    }
+});
+
+for (const method of ["get", "all", "run", "values", "iterate"] as const) {
+    test(`turn deadline bounds cached SELECT ${method} and restores timeout`, async () => {
+        await fixture(async (db, path) => {
+            expect(hasSqliteTurnDeadlineRouting(db)).toBe(true);
+            const statement: any = db.prepare("SELECT * FROM t");
+            const release = await hold(path);
+            try {
+                bounded(() =>
+                    method === "iterate" ? statement.iterate().next() : statement[method](),
+                );
+                expect(timeout(db)).toBe(900);
+            } finally {
+                await release();
+            }
+            expect(statement.get()).toEqual({ value: 1 });
+        });
+    });
+}
+
+test("turn deadline bounds exec, prepare, deferred reads and COMMIT", async () => {
+    await fixture(async (db, path) => {
+        const read = db.prepare("SELECT * FROM t");
+        const fresh = createSqliteTurnDatabase(path);
+        fresh.exec("PRAGMA busy_timeout=900");
+        const release = await hold(path);
+        try {
+            bounded(() => db.exec("SELECT * FROM t"));
+            bounded(() => fresh.prepare("SELECT * FROM t"));
+            db.exec("BEGIN DEFERRED");
+            bounded(() => read.get());
+            db.exec("ROLLBACK");
+        } finally {
+            fresh.close();
+            await release();
+        }
+        db.exec("BEGIN IMMEDIATE; UPDATE t SET value=2");
+        const releaseReader = await hold(path, true);
+        try {
+            bounded(() => db.exec("COMMIT"));
+            expect(db.inTransaction).toBe(true);
+            expect(timeout(db)).toBe(900);
+            db.exec("ROLLBACK");
+        } finally {
+            await releaseReader();
+        }
+        expect(read.get()).toEqual({ value: 1 });
+    });
+});
+
+test("timeout mirror follows setters, prepare-time effects and failed script prefixes", async () => {
+    await fixture(async (db, path) => {
+        db.exec(
+            "PRAGMA main.busy_timeout(850); SELECT '; PRAGMA busy_timeout=0;'; -- PRAGMA busy_timeout=1",
+        );
+        const setter = db.prepare("PRAGMA busy_timeout=800");
+        expect(timeout(db)).toBe(800);
+        const success = () =>
+            withSqliteTurnDeadline(
+                () => 80,
+                () => db.prepare("SELECT 1").get(),
+            );
+        success();
+        expect(timeout(db)).toBe(800);
+        db.exec("PRAGMA busy_timeout=750");
+        setter.get();
+        const before = timeout(db);
+        success();
+        expect(timeout(db)).toBe(before);
+        const iterator = db.prepare("PRAGMA busy_timeout=600").iterate();
+        db.exec("PRAGMA busy_timeout=500");
+        iterator.next();
+        const after = timeout(db);
+        success();
+        expect(timeout(db)).toBe(after);
+        iterator.return?.();
+        expect(() => db.exec("PRAGMA busy_timeout=700; SELECT * FROM missing_table")).toThrow();
+        const read = db.prepare("SELECT * FROM t");
+        const release = await hold(path);
+        try {
+            bounded(() => read.get());
+            expect(timeout(db)).toBe(700);
+        } finally {
+            await release();
+        }
+    });
+});
+
+test("deadline leaves zero-wait probes and existing writer acquisition semantics intact", async () => {
+    await fixture(async (db, path) => {
+        const release = await hold(path);
+        try {
+            bounded(() => withSqliteTransformPass(() => db.exec("BEGIN IMMEDIATE")));
+            expect(timeout(db)).toBe(900);
+            db.exec("PRAGMA busy_timeout=0");
+            const start = performance.now();
+            expect(() =>
+                withSqliteTurnDeadline(
+                    () => 80,
+                    () => db.exec("SELECT * FROM t"),
+                ),
+            ).toThrow();
+            expect(performance.now() - start).toBeLessThan(100);
+            expect(timeout(db)).toBe(0);
+        } finally {
+            await release();
+        }
+    });
+});
+
+for (const detach of [withoutSqliteTransformPass, withSqliteBackgroundWriter]) {
+    test(`detached native reads retain configured timeout (${detach.name})`, async () => {
+        await fixture(async (db, path) => {
+            const read = db.prepare("SELECT * FROM t");
+            const release = await hold(path);
+            try {
+                const start = performance.now();
+                expect(() =>
+                    withSqliteTurnDeadline(
+                        () => 0,
+                        () => detach(() => read.get()),
+                    ),
+                ).toThrow();
+                expect(performance.now() - start).toBeGreaterThan(700);
+                expect(timeout(db)).toBe(900);
+            } finally {
+                await release();
+            }
+        });
+    });
+}
+
+for (const outcome of ["success", "throw", "reject"] as const) {
+    test(`completed native lease stops consulting request callback (${outcome})`, async () => {
+        const db = createSqliteTurnDatabase(":memory:");
+        let reads = 0;
+        let descendant!: () => unknown;
+        let resume!: () => void;
+        const gate = new Promise<void>((resolve) => {
+            resume = resolve;
+        });
+        let pending!: Promise<unknown>;
+        try {
+            try {
+                await withSqliteTurnDeadline(
+                    () => {
+                        reads++;
+                        return 80;
+                    },
+                    () => {
+                        pending = gate.then(() => descendant());
+                        descendant = () => db.prepare("SELECT 1").get();
+                        if (outcome === "throw") throw new Error("sync failure");
+                        if (outcome === "reject") return Promise.reject(new Error("async failure"));
+                    },
+                );
+            } catch (error) {
+                expect(String(error)).toContain("failure");
+            }
+            resume();
+            await pending;
+            expect(reads).toBe(0);
+        } finally {
+            db.close();
+        }
+    });
+}