@livestore/wa-sqlite 1.0.1-dev.0

package/test/callbacks.test.js

@@ -0,0 +1,373 @@
+import { TestContext } from "./TestContext.js";
+import AsyncifyFactory from 'wa-sqlite/dist/wa-sqlite-async.mjs';
+import JSPIFactory from 'wa-sqlite/dist/wa-sqlite-jspi.mjs';
+import * as SQLite from '../src/sqlite-api.js';
+
+const FACTORIES = new Map([
+  ['asyncify', AsyncifyFactory],
+  ['jspi', JSPIFactory]
+]);
+
+const supportsJSPI = await TestContext.supportsJSPI();
+
+for (const [key, factory] of FACTORIES) {
+  if (key === 'jspi' && !supportsJSPI) continue;
+
+  const sqlite3 = await factory().then(module => SQLite.Factory(module));
+  describe(`${key} create_function`, function() {
+    let db;
+    beforeEach(async function() {
+      db = await sqlite3.open_v2(':memory:');
+    });
+  
+    afterEach(async function() {
+      await sqlite3.close(db);
+    });
+  
+    it('should return an int', async function() {
+      let rc;
+      
+      rc = await sqlite3.create_function(
+        db,
+        'fn',
+        0,
+        SQLite.SQLITE_DETERMINISTIC, 0,
+        (function(context, values) {
+          sqlite3.result_int(context, 42);
+        }));
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+  
+      let result;
+      rc = await sqlite3.exec(db, 'SELECT fn()', row => result = row[0]);
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+      expect(result).toEqual(42);
+    });
+  
+    it('should return an int64', async function() {
+      let rc;
+      
+      rc = await sqlite3.create_function(
+        db,
+        'fn',
+        0,
+        SQLite.SQLITE_DETERMINISTIC, 0,
+        (function(context, values) {
+          sqlite3.result_int64(context, 0x7FFF_FFFF_FFFF_FFFFn);
+        }));
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+  
+      for await (const stmt of sqlite3.statements(db, 'SELECT fn()')) {
+        while (await sqlite3.step(stmt) === SQLite.SQLITE_ROW) {
+          const value = sqlite3.column_int64(stmt, 0);        
+          expect(value).toEqual(0x7FFF_FFFF_FFFF_FFFFn);
+        }
+      }
+    });
+  
+    it('should return a double', async function() {
+      let rc;
+      
+      rc = await sqlite3.create_function(
+        db,
+        'fn',
+        0,
+        SQLite.SQLITE_DETERMINISTIC, 0,
+        (function(context, values) {
+          sqlite3.result_double(context, 3.14);
+        }));
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+  
+      let result;
+      rc = await sqlite3.exec(db, 'SELECT fn()', row => result = row[0]);
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+      expect(result).toEqual(3.14);
+    });
+  
+    it('should return a string', async function() {
+      let rc;
+      
+      rc = await sqlite3.create_function(
+        db,
+        'fn',
+        0,
+        SQLite.SQLITE_DETERMINISTIC, 0,
+        (function(context, values) {
+          sqlite3.result_text(context, 'foobar');
+        }));
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+  
+      let result;
+      rc = await sqlite3.exec(db, 'SELECT fn()', row => result = row[0]);
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+      expect(result).toEqual('foobar');
+    });
+  
+    it('should return a blob', async function() {
+      let rc;
+      
+      rc = await sqlite3.create_function(
+        db,
+        'fn',
+        0,
+        SQLite.SQLITE_DETERMINISTIC, 0,
+        (function(context, values) {
+          sqlite3.result_blob(context, new Uint8Array([0x12, 0x34, 0x56]));
+        }));
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+  
+      let result;
+      rc = await sqlite3.exec(db, 'SELECT fn()', row => result = row[0]);
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+      expect(result).toEqual(new Uint8Array([0x12, 0x34, 0x56]));
+    });
+  
+    it('should return null', async function() {
+      let rc;
+      
+      rc = await sqlite3.create_function(
+        db,
+        'fn',
+        0,
+        SQLite.SQLITE_DETERMINISTIC, 0,
+        (function(context, values) {
+          sqlite3.result_null(context);
+        }));
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+  
+      let result;
+      rc = await sqlite3.exec(db, 'SELECT fn()', row => result = row[0]);
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+      expect(result).toEqual(null);
+    });
+  
+    it('should pass a fixed number of arguments', async function() {
+      let rc;
+      
+      rc = await sqlite3.create_function(
+        db,
+        'fn',
+        5,
+        SQLite.SQLITE_DETERMINISTIC, 0,
+        (function(context, values) {
+          expect(sqlite3.value_type(values[0])).toEqual(SQLite.SQLITE_INTEGER);
+          expect(sqlite3.value_int(values[0])).toEqual(42);
+          expect(sqlite3.value_int64(values[0])).toEqual(42n);
+          expect(sqlite3.value(values[0])).toEqual(42);
+  
+          expect(sqlite3.value_type(values[1])).toEqual(SQLite.SQLITE_FLOAT);
+          expect(sqlite3.value_double(values[1])).toEqual(3.14);
+          expect(sqlite3.value(values[1])).toEqual(3.14);
+  
+          expect(sqlite3.value_type(values[2])).toEqual(SQLite.SQLITE_TEXT);
+          expect(sqlite3.value_text(values[2])).toEqual('hello');
+          expect(sqlite3.value(values[2])).toEqual('hello');
+  
+          expect(sqlite3.value_type(values[3])).toEqual(SQLite.SQLITE_BLOB);
+          expect(sqlite3.value_blob(values[3])).toEqual(new Uint8Array([0x12, 0x34, 0x56]));
+          expect(sqlite3.value_bytes(values[3])).toEqual(3);
+          expect(sqlite3.value(values[3])).toEqual(new Uint8Array([0x12, 0x34, 0x56]));
+  
+          expect(sqlite3.value_type(values[4])).toEqual(SQLite.SQLITE_NULL);
+        }));
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+  
+      rc = await sqlite3.exec(db, `
+        SELECT fn(42, 3.14, 'hello', x'123456', NULL)
+      `);
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+    });
+  
+    it('should pass a variable number of arguments', async function() {
+      let rc;
+      
+      rc = await sqlite3.create_function(
+        db,
+        'fn',
+        -1,
+        SQLite.SQLITE_DETERMINISTIC, 0,
+        (function(context, values) {
+          expect(values.length).toBe(5);
+          
+          expect(sqlite3.value_type(values[0])).toEqual(SQLite.SQLITE_INTEGER);
+          expect(sqlite3.value_int(values[0])).toEqual(42);
+          expect(sqlite3.value_int64(values[0])).toEqual(42n);
+          expect(sqlite3.value_double(values[0])).toEqual(42.0);
+          expect(sqlite3.value(values[0])).toEqual(42);
+  
+          expect(sqlite3.value_type(values[1])).toEqual(SQLite.SQLITE_FLOAT);
+          expect(sqlite3.value_double(values[1])).toEqual(3.14);
+          expect(sqlite3.value(values[1])).toEqual(3.14);
+  
+          expect(sqlite3.value_type(values[2])).toEqual(SQLite.SQLITE_TEXT);
+          expect(sqlite3.value_text(values[2])).toEqual('hello');
+          expect(sqlite3.value(values[2])).toEqual('hello');
+  
+          expect(sqlite3.value_type(values[3])).toEqual(SQLite.SQLITE_BLOB);
+          expect(sqlite3.value_blob(values[3])).toEqual(new Uint8Array([0x12, 0x34, 0x56]));
+          expect(sqlite3.value_bytes(values[3])).toEqual(3);
+          expect(sqlite3.value(values[3])).toEqual(new Uint8Array([0x12, 0x34, 0x56]));
+  
+          expect(sqlite3.value_type(values[4])).toEqual(SQLite.SQLITE_NULL);
+        }));
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+  
+      rc = await sqlite3.exec(db, `
+        SELECT fn(42, 3.14, 'hello', x'123456', NULL)
+      `);
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+    });
+  
+    it('should create an aggregate function', async function() {
+      let rc;
+      
+      let product = 1;
+      rc = await sqlite3.create_function(
+        db,
+        'fn',
+        1,
+        SQLite.SQLITE_DETERMINISTIC, 0,
+        null,
+        (function(context, values) {
+          const value = sqlite3.value_double(values[0]);
+          product *= value;
+        }),
+        (function(context) {
+          sqlite3.result_double(context, product);
+        }));
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+  
+      rc = await sqlite3.exec(db, `
+        SELECT fn(column1) FROM (VALUES (1), (2), (3), (4), (5));
+      `);
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+      expect(product).toEqual(1 * 2 * 3 * 4 * 5);
+    });
+  
+    it('should return asynchronously', async function() {
+      let rc;
+      
+      rc = await sqlite3.create_function(
+        db,
+        'fn',
+        0,
+        SQLite.SQLITE_DETERMINISTIC, 0,
+        async (context, values) => {
+          await new Promise(resolve => setTimeout(resolve));
+          sqlite3.result_int(context, 42);
+        });
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+  
+      let result;
+      rc = await sqlite3.exec(db, 'SELECT fn()', row => result = row[0]);
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+      expect(result).toEqual(42);
+    });
+  });
+
+  describe(`${key} progress_handler`, function() {
+    let db;
+    beforeEach(async function() {
+      db = await sqlite3.open_v2(':memory:');
+    });
+  
+    afterEach(async function() {
+      await sqlite3.close(db);
+    });
+
+    it('should call progress handler', async function() {
+      let rc;
+      
+      let count = 0;
+      await sqlite3.progress_handler(db, 1, () => ++count && 0, null);
+  
+      rc = await sqlite3.exec(db, `
+        CREATE TABLE t AS
+        WITH RECURSIVE cnt(x) AS (
+          SELECT 1
+          UNION ALL
+          SELECT x+1 FROM cnt
+            LIMIT 100
+        )
+        SELECT x FROM cnt;
+      `);
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+      expect(count).toBeGreaterThan(0);
+    });
+
+    it('should call asynchronous progress handler', async function() {
+      let rc;
+      
+      let count = 0;
+      await sqlite3.progress_handler(db, 1, async () => ++count && 0, null);
+  
+      rc = await sqlite3.exec(db, `
+        CREATE TABLE t AS
+        WITH RECURSIVE cnt(x) AS (
+          SELECT 1
+          UNION ALL
+          SELECT x+1 FROM cnt
+            LIMIT 100
+        )
+        SELECT x FROM cnt;
+      `);
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+      expect(count).toBeGreaterThan(0);
+    });
+  });
+
+  describe(`${key} set_authorizer`, function() {
+    let db;
+    beforeEach(async function() {
+      db = await sqlite3.open_v2(':memory:');
+    });
+  
+    afterEach(async function() {
+      await sqlite3.close(db);
+    });
+
+    it('should call authorizer', async function() {
+      let rc;
+
+      const authorizations = [];
+      rc = sqlite3.set_authorizer(db, (_, iActionCode, p3, p4, p5, p6) => {
+        authorizations.push([iActionCode, p3, p4, p5, p6]);
+        return SQLite.SQLITE_OK;
+      });
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+
+      rc = await sqlite3.exec(db, 'CREATE TABLE t(x)');
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+
+      expect(authorizations.length).toBeGreaterThan(0);
+    });
+
+    it('should deny authorization', async function() {
+      let rc;
+
+      rc = sqlite3.set_authorizer(db, (_, iActionCode, p3, p4, p5, p6) => {
+        return SQLite.SQLITE_DENY;
+      });
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+
+      const result = sqlite3.exec(db, 'CREATE TABLE t(x)');
+      await expectAsync(result).toBeRejectedWith(new Error('not authorized'));
+    });
+
+    it('should call async authorizer', async function() {
+      let rc;
+
+      const authorizations = [];
+      rc = sqlite3.set_authorizer(db, async (_, iActionCode, p3, p4, p5, p6) => {
+        authorizations.push([iActionCode, p3, p4, p5, p6]);
+        return SQLite.SQLITE_OK;
+      });
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+
+      rc = await sqlite3.exec(db, 'CREATE TABLE t(x)');
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+
+      expect(authorizations.length).toBeGreaterThan(0);
+    });
+  });
+}
+

package/test/sql.test.js

@@ -0,0 +1,64 @@
+import { TestContext } from "./TestContext.js";
+import { sql_0001 } from "./sql_0001.js";
+import { sql_0002 } from "./sql_0002.js";
+import { sql_0003 } from "./sql_0003.js";
+import { sql_0004 } from "./sql_0004.js";
+import { sql_0005 } from "./sql_0005.js";
+
+const ALL_BUILDS = ['default', 'asyncify', 'jspi'];
+const ASYNC_BUILDS = ['asyncify', 'jspi'];
+
+// Not all browsers support JSPI yet.
+const supportsJSPI = await TestContext.supportsJSPI();
+
+/** @type {Map<string, string[]>} */
+const CONFIGS = new Map([
+  ['', ALL_BUILDS],
+  ['MemoryVFS', ALL_BUILDS],
+  ['AccessHandlePoolVFS', ALL_BUILDS],
+  ['OPFSCoopSyncVFS', ALL_BUILDS],
+  ['MemoryAsyncVFS', ASYNC_BUILDS],
+  ['IDBBatchAtomicVFS', ASYNC_BUILDS],
+  ['IDBMirrorVFS', ASYNC_BUILDS],
+  ['OPFSAdaptiveVFS', ASYNC_BUILDS],
+  ['OPFSAnyContextVFS', ASYNC_BUILDS],
+  ['OPFSPermutedVFS', ASYNC_BUILDS],
+]);
+
+const DISALLOWS_PAGE_SIZE_CHANGE = ['IDBBatchAtomicVFS', 'IDBMirrorVFS', 'OPFSPermutedVFS', 'FLOOR'];
+const NOT_PERSISTENT = ['', 'MemoryVFS', 'MemoryAsyncVFS'];
+const SINGLE_CONNECTION = ['', 'MemoryVFS', 'MemoryAsyncVFS', 'AccessHandlePoolVFS'];
+
+describe('SQL', function() {
+  for (const [config, builds] of CONFIGS) {
+    describe(config, function() {
+      for (const build of builds) {
+        // Skip JSPI tests if the browser does not support it.
+        if (build === 'jspi' && !supportsJSPI) continue;
+
+        describe(build, function() {
+          sqlSpecs(build, config);
+        });
+      }
+    });
+  }
+});
+
+function sqlSpecs(build, config) {
+  const context = new TestContext({ build, config });
+
+  sql_0001(context);
+  sql_0002(context);
+  if (!DISALLOWS_PAGE_SIZE_CHANGE.includes(config)) {
+    // These tests change the page size.
+    sql_0003(context);
+  }
+  if (!NOT_PERSISTENT.includes(config)) {
+    // These tests require persistent storage.
+    sql_0004(context);
+  }
+  if (!SINGLE_CONNECTION.includes(config)) {
+    // These tests require multiple connections.
+    sql_0005(context);
+  }
+}

package/test/sql_0001.js

@@ -0,0 +1,49 @@
+import * as Comlink from 'comlink';
+
+export function sql_0001(context) {
+  describe('sql_0001', function() {
+    let proxy, sqlite3, db;
+    beforeEach(async function() {
+      proxy = await context.create();
+      sqlite3 = proxy.sqlite3;
+      db = await sqlite3.open_v2('demo');
+    });
+
+    afterEach(async function() {
+      await sqlite3.close(db);
+      await context.destroy(proxy);
+    });
+
+    it('should rollback a transaction', async function() {
+      let count;
+      await sqlite3.exec(db, `
+        CREATE TABLE foo (x PRIMARY KEY);
+        INSERT INTO foo VALUES ('foo'), ('bar'), ('baz');
+        SELECT COUNT(*) FROM foo;
+      `, Comlink.proxy(row => count = row[0]));
+      expect(count).toBe(3);
+  
+      count = undefined;
+      await sqlite3.exec(db, `
+        BEGIN TRANSACTION;
+        WITH numbers(n) AS (SELECT 1 UNION ALL SELECT n + 1 FROM numbers LIMIT 100)
+          INSERT INTO foo SELECT * FROM numbers;
+        SELECT COUNT(*) FROM foo;
+      `, Comlink.proxy(row => count = row[0]));
+      expect(count).toBe(103);
+  
+      count = undefined;
+      await sqlite3.exec(db, `
+        ROLLBACK;
+        SELECT COUNT(*) FROM foo;
+      `, Comlink.proxy(row => count = row[0]));
+      expect(count).toBe(3);
+
+      let checkStatus;
+      await sqlite3.exec(db, `
+        PRAGMA integrity_check;
+      `, Comlink.proxy(row => checkStatus = row[0]));
+      expect(checkStatus).toBe('ok');
+    });
+  });
+}

package/test/sql_0002.js

@@ -0,0 +1,52 @@
+import * as Comlink from 'comlink';
+
+export function sql_0002(context) {
+  describe('sql_0002', function() {
+    let proxy, sqlite3, db;
+    beforeEach(async function() {
+      proxy = await context.create();
+      sqlite3 = proxy.sqlite3;
+      db = await sqlite3.open_v2('demo');
+    });
+
+    afterEach(async function() {
+      await sqlite3.close(db);
+      await context.destroy(proxy);
+    });
+
+    it('should vacuum to minimize page count', async function() {
+      await sqlite3.exec(db, `
+        CREATE TABLE t AS
+        WITH numbers(n) AS
+          (SELECT 1 UNION ALL SELECT n + 1 FROM numbers LIMIT 10000)
+          SELECT n FROM numbers;
+      `);
+
+      let nPagesBeforeVacuum;
+      await sqlite3.exec(db, `
+        PRAGMA page_count;
+      `, Comlink.proxy(row => nPagesBeforeVacuum = row[0]));
+
+      await sqlite3.exec(db, `
+        DELETE FROM t WHERE sqrt(n) != floor(sqrt(n));
+      `);
+
+      await sqlite3.exec(db, `
+        VACUUM;
+      `);
+
+      let nPagesAfterVacuum;
+      await sqlite3.exec(db, `
+        PRAGMA page_count;
+      `, Comlink.proxy(row => nPagesAfterVacuum = row[0]));
+
+      expect(nPagesAfterVacuum).toBeLessThan(nPagesBeforeVacuum);
+
+      let checkStatus;
+      await sqlite3.exec(db, `
+        PRAGMA integrity_check;
+      `, Comlink.proxy(row => checkStatus = row[0]));
+      expect(checkStatus).toBe('ok');
+    });
+  });
+}

package/test/sql_0003.js

@@ -0,0 +1,83 @@
+import * as Comlink from 'comlink';
+
+export function sql_0003(context) {
+  describe('sql_0003', function() {
+    let proxy, sqlite3, db;
+    beforeEach(async function() {
+      proxy = await context.create();
+      sqlite3 = proxy.sqlite3;
+      db = await sqlite3.open_v2('demo');
+    });
+
+    afterEach(async function() {
+      await sqlite3.close(db);
+      await context.destroy(proxy);
+    });
+
+    it('should vacuum to decrease page size', async function() {
+      await sqlite3.exec(db, `
+        PRAGMA page_size=8192;
+        CREATE TABLE t AS
+        WITH numbers(n) AS
+          (SELECT 1 UNION ALL SELECT n + 1 FROM numbers LIMIT 10000)
+          SELECT n FROM numbers;
+      `);
+
+      let pageSizeBeforeVacuum;
+      await sqlite3.exec(db, `
+        PRAGMA page_size;
+      `, Comlink.proxy(row => pageSizeBeforeVacuum = row[0]));
+      expect(pageSizeBeforeVacuum).toBe(8192);
+
+      await sqlite3.exec(db, `
+        PRAGMA page_size=4096;
+        VACUUM;
+      `);
+
+      let pageSizeAfterVacuum;
+      await sqlite3.exec(db, `
+        PRAGMA page_size;
+      `, Comlink.proxy(row => pageSizeAfterVacuum = row[0]));
+      expect(pageSizeAfterVacuum).toBe(4096);
+
+      let checkStatus;
+      await sqlite3.exec(db, `
+        PRAGMA integrity_check;
+      `, Comlink.proxy(row => checkStatus = row[0]));
+      expect(checkStatus).toBe('ok');
+    });
+
+    it('should vacuum to increase page size', async function() {
+      await sqlite3.exec(db, `
+        PRAGMA page_size=8192;
+        CREATE TABLE t AS
+        WITH numbers(n) AS
+          (SELECT 1 UNION ALL SELECT n + 1 FROM numbers LIMIT 10000)
+          SELECT n FROM numbers;
+      `);
+
+      let pageSizeBeforeVacuum;
+      await sqlite3.exec(db, `
+        PRAGMA page_size;
+      `, Comlink.proxy(row => pageSizeBeforeVacuum = row[0]));
+      expect(pageSizeBeforeVacuum).toBe(8192);
+
+      await sqlite3.exec(db, `
+        PRAGMA page_size=16384;
+        VACUUM;
+      `);
+
+      let pageSizeAfterVacuum;
+      await sqlite3.exec(db, `
+        PRAGMA page_size;
+      `, Comlink.proxy(row => pageSizeAfterVacuum = row[0]));
+      expect(pageSizeAfterVacuum).toBe(16384);
+
+      let checkStatus;
+      await sqlite3.exec(db, `
+        PRAGMA integrity_check;
+      `, Comlink.proxy(row => checkStatus = row[0]));
+      expect(checkStatus).toBe('ok');
+    });
+  });
+}

package/test/sql_0004.js

@@ -0,0 +1,81 @@
+import * as Comlink from 'comlink';
+
+export function sql_0004(context) {
+  const cleanup = [];
+  beforeEach(async function() {
+    cleanup.splice(0);
+  });
+
+  afterEach(async function() {
+    for (const fn of cleanup) {
+      await fn();
+    }
+  });
+
+  describe('sql_0004', function() {
+    it('should recover after crash', async function() {
+      const proxyA = await context.create();
+      try {
+        const sqlite3 = proxyA.sqlite3;
+        const db = await sqlite3.open_v2('demo');
+        await sqlite3.exec(db, `
+          PRAGMA cache_size=0;
+          CREATE TABLE t(x);
+          INSERT INTO t VALUES (1), (2), (3);
+        `);
+
+        let sum;
+        await sqlite3.exec(db, `
+          SELECT sum(x) FROM t;
+        `, Comlink.proxy(row => sum = row[0]));
+        expect(sum).toBe(6);
+
+        let check;
+        await sqlite3.exec(db, `
+          PRAGMA integrity_check;
+        `, Comlink.proxy(row => check = row[0]));
+        expect(check).toBe('ok');
+
+        // Begin a transaction but don't commit it.
+        await sqlite3.exec(db, `
+          BEGIN TRANSACTION;
+          WITH RECURSIVE cnt(x) AS
+            (SELECT 1 UNION ALL SELECT x+1 FROM cnt LIMIT 10000)
+          INSERT INTO t SELECT * FROM cnt;
+        `);
+      } finally {
+        await context.destroy(proxyA);
+      }
+
+      await new Promise(resolve => setTimeout(resolve, 250));
+
+      const proxyB = await context.create({ reset: false });
+      try {
+        const sqlite3 = proxyB.sqlite3;
+        const db = await sqlite3.open_v2('demo');
+
+        let sum;
+        await sqlite3.exec(db, `
+          SELECT sum(x) FROM t;
+        `, Comlink.proxy(row => sum = row[0]));
+        expect(sum).toBe(6);
+
+        let check;
+        await sqlite3.exec(db, `
+          PRAGMA integrity_check;
+        `, Comlink.proxy(row => check = row[0]));
+        expect(check).toBe('ok');
+
+        await sqlite3.exec(db, `
+          INSERT INTO t VALUES (4), (5);
+        `);
+        await sqlite3.exec(db, `
+          SELECT sum(x) FROM t;
+        `, Comlink.proxy(row => sum = row[0]));
+        expect(sum).toBe(15);
+      } finally {
+        await context.destroy(proxyB);
+      }
+    });
+  });
+}