jsql-neo 6.4.3 → 6.4.5

package/README.md

@@ -3,7 +3,7 @@
 > **One engine to rule them all** — a Rust-powered embedded database that speaks your language:
 > MySQL, PostgreSQL, MongoDB, Redis, SQL, TypeScript, **and the browser**.
 
-> **v6.4.3** — official release build · [github.com/vexify-org/JSQL-neo](https://github.com/vexify-org/JSQL-neo) · [jsql.vexify.top](https://jsql.vexify.top)
+> **v6.4.5** — official release build · [github.com/vexify-org/JSQL-neo](https://github.com/vexify-org/JSQL-neo) · [jsql.vexify.top](https://jsql.vexify.top)
 
 ![Engines](https://img.shields.io/badge/engines-Native%20%7C%20WASM%20%7C%20Pure%20JS-7ee787)
 ![MySQL](https://img.shields.io/badge/protocol-MySQL%20compatible-1f6feb)

package/index.js

@@ -1,5 +1,5 @@
 /**
- * JSQL-NEO v6.4.3 — Rust-Powered Embedded Database (WASM + HTTP)
+ * JSQL-NEO v6.4.5 — Rust-Powered Embedded Database (WASM + HTTP)
  *
  * @example
  * const jsql = require('jsql-neo');

package/lib/sql.js

@@ -2813,6 +2813,40 @@ function rowHasPrefixedKeys(row) {
   return false;
 }
 
+/**
+ * 整棵语句树里有没有出现过「表.列」形式的限定引用。
+ *
+ * executeSelect 会给每一行调用 _prefixRow，把键复制成「表.列」形式。
+ * 单表查询里这些键根本没被引用，10 万行就是 10 万个白造对象
+ * （node --prof 显示占整个查询 30% 的 GC）。
+ *
+ * 但限定引用不一定长在 {type:/column/} 节点里 —— ORDER BY 的 o.column
+ * 就是纯字符串 "t.age"，HAVING / pushdown 的键也是。只扫对象节点会漏，
+ * 漏了就少加前缀，相关子查询和限定列全部解析错。两种形态都要查。
+ *
+ * 消费方清单（摸清这些才敢跳过前缀）：
+ *   1. resolveOperand 的 column 分支 —— 限定引用解析
+ *   2. rowHasPrefixedKeys —— 未知限定符的防自匹配守卫
+ *   3. SELECT * 的 starKeys —— 单表时取 Object.keys(schema)，与行前缀无关
+ *   4. JOIN 右表 —— 多表同名列消歧，本来就强制前缀
+ */
+const QUALIFIED_REF_RE = /^[A-Za-z_][A-Za-z0-9_]*\.[A-Za-z_][A-Za-z0-9_]*$/;
+function hasQualifiedRef(node, depth) {
+  if (!node || typeof node !== "object" || depth > 200) return false;
+  if (Array.isArray(node)) {
+    for (const n of node) if (hasQualifiedRef(n, depth + 1)) return true;
+    return false;
+  }
+  if (node.type === "column" && typeof node.name === "string" && node.name.indexOf(".") !== -1) return true;
+  for (const k in node) {
+    if (k === "ctx" || k === "engine" || k === "session") continue;
+    const v = node[k];
+    if (typeof v === "string") { if (QUALIFIED_REF_RE.test(v)) return true; }
+    else if (v && typeof v === "object" && hasQualifiedRef(v, depth + 1)) return true;
+  }
+  return false;
+}
+
 /**
  * 字符串能否当作数值参与算术运算。
  * MySQL 里 '5' + 5 = 10、'5' + '5' = 10、'abc' + 1 = 1（非数字按 0）。
@@ -6843,10 +6877,25 @@ class SQLExecutor {
             return (a && String(a).includes('.') ? String(a) : `${firstPrefix}.${a}`);
           }).filter(Boolean)
         : null;
+      /*
+       * 曾经试着在「单表 + 无 JOIN」时跳过 _prefixRow 以省掉 10 万次对象分配
+       * （node --prof 显示它占 30% GC）。实测确实快 2~3 倍，但相关子查询
+       * （EXISTS / 标量 / IN）靠 `外层表.列` 引用外层行，没前缀就解析不到，
+       * 而 _collectSubqueries 在这个位置抓不到它们（前面已被改写）。
+       * 收益真实但边界没摸清，先回退，留待摸清后再上。
+       */
+      /*
+       * 单表 + 无 JOIN + 无派生表 + 整棵树没有限定引用时，跳过前缀。
+       * 不缓存到 statement 上：语句对象可能被 prepare() 复用，挂属性会串味。
+       */
+      const needPrefix = isVirtualSource
+        || !!(statement.from.joins && statement.from.joins.length)
+        || hasQualifiedRef(statement, 0);
       let rows = isVirtualSource
         ? rowsAll.rows.map(r => this._prefixRow(r, firstPrefix))
-        : (firstItem._virtualRows ? rowsAll.rows : rowsAll.rows.map(r => this._prefixRow(r, firstPrefix)));
-
+        : (needPrefix || firstItem._virtualRows
+            ? rowsAll.rows.map(r => this._prefixRow(r, firstPrefix))
+            : rowsAll.rows);
       for (const j of statement.from.joins) {
         // 虚拟行（递归 CTE 物化的派生表）要直接取行，不能当普通子查询执行
         const jVirtual = j.item._virtualRows ||
@@ -7132,28 +7181,54 @@ class SQLExecutor {
     if (statement.orderBy) {
       // ORDER BY 项可能是列名字符串、表达式节点，或列的位置序号（ORDER BY 1，1-based）
       const ordNames = statement.columns.map(c => scalarColumnName(c));
-      const ordVal = (row, o) => {
+      /*
+       * 把排序键的解析**预先编译**，比较器里只做数组下标访问。
+       *
+       * 此前每次比较都调 `resolveOperand({type:'column', name}, row, ctx)` ——
+       * 那个对象字面量是每次新建的。6.8 万行排序约 230 万次比较，
+       * 就是 230 万次白白分配，实测占掉整个 ORDER BY 的大半时间
+       * （10 万行 WHERE+ORDER+LIMIT 从 133ms 量级大幅下降）。
+       *
+       * 同时按「投影列名 → 下标」解析；命中就直接 `row[idx]`，
+       * 不再走 resolveOperand 的通用路径。
+       */
+      const ordKeys = statement.orderBy.map(o => {
+        const dir = o.dir === 'asc' ? 1 : -1;
+        // 位置序号：ORDER BY 1
         const pos = (o.column && typeof o.column === 'object' && o.column.type === 'value' && typeof o.column.value === 'number')
           ? o.column.value
           : (typeof o.column === 'number' ? o.column : null);
         if (pos !== null && pos !== undefined) {
           const name = ordNames[pos - 1];
-          if (name !== undefined && name !== null) return resolveOperand({ type: 'column', name }, row, this.ctx);
+          return { dir, at: (name === undefined || name === null) ? () => null : (r) => (r == null ? null : r[name]) };
         }
-        return typeof o.column === 'string'
-          ? resolveOperand({ type: 'column', name: o.column }, row, this.ctx)
-          : resolveOperand(o.column, row, this.ctx);
-      };
+        if (typeof o.column === 'string') {
+          const f = o.column;
+          // 节点对象提到循环外复用 —— 此前每次比较都新建一个 {type:'column',name}
+          const node = { type: 'column', name: f };
+          return {
+            dir,
+            at: (r) => {
+              // 先按字段名直取；取不到再走 resolveOperand（点号路径、表达式等）
+              const v = (r == null) ? undefined : r[f];
+              return v !== undefined ? v : resolveOperand(node, r, this.ctx);
+            },
+          };
+        }
+        return { dir, at: (r) => resolveOperand(o.column, r, this.ctx) };
+      });
+
       const cmp = (a, b) => {
-        for (const o of statement.orderBy) {
-          const av = ordVal(a, o);
-          const bv = ordVal(b, o);
+        for (let i = 0; i < ordKeys.length; i++) {
+          const k = ordKeys[i];
+          const av = k.at(a);
+          const bv = k.at(b);
           if (av === bv || (av === undefined && bv === undefined)) continue;
-          if (av === undefined || av === null) return o.dir === 'asc' ? -1 : 1;
-          if (bv === undefined || bv === null) return o.dir === 'asc' ? 1 : -1;
+          if (av === undefined || av === null) return -1 * k.dir;
+          if (bv === undefined || bv === null) return 1 * k.dir;
           // P2-1: localeCompare 对字符串排序受 locale 影响，应使用简单字符串比较
           const r = typeof av === 'number' && typeof bv === 'number' ? av - bv : (String(av) < String(bv) ? -1 : String(av) > String(bv) ? 1 : 0);
-          if (r !== 0) return o.dir === 'asc' ? r : -r;
+          if (r !== 0) return r * k.dir;
         }
         return 0;
       };
@@ -7252,16 +7327,42 @@ class SQLExecutor {
         if (c.expr === '*') { for (const k of starKeys) cols.push(k.includes('.') ? k.slice(k.indexOf('.') + 1) : k); }
         else cols.push(scalarColumnName(c));
       }
+      /*
+       * 预先编译每列的取值函数。
+       *
+       * 此前循环里每次调用都新建 `{type:'column', name}` 对象字面量，
+       * 10 万行 × N 列就是 10 万 × N 次白分配 —— 实测光 `SELECT id FROM t`
+       * 就要 94ms，其中绝大部分是这个。
+       *
+       * 最常见的「普通列名」直接走属性访问，不再过 resolveOperand 的通用路径；
+       * 取不到值才退回（兼容点号路径、限定引用等）。
+       */
+      const starIdx = [];
+      const colGetters = statement.columns.map((c, ci) => {
+        if (c.expr === '*') { starIdx.push(ci); return null; }
+        if (c.over || (c.scalar && c.scalar.over)) return (r) => windowColumnValue(c, r);
+        if (c.scalar) return (r) => projectScalar(resolveOperand(c.scalar, r, this.ctx));
+        if (c.literal !== undefined) return () => c.literal;
+        if (c.caseExpr) return (r) => projectScalar(evaluateCaseVal(c.caseExpr, r));
+        if (typeof c.expr === 'string') {
+          const f = c.expr;
+          const node = { type: 'column', name: f };
+          return (r) => {
+            const v = (r == null) ? undefined : r[f];
+            return v === undefined ? projectScalar(resolveOperand(node, r, this.ctx)) : projectScalar(v);
+          };
+        }
+        const node2 = { type: 'column', name: c.expr };
+        return (r) => projectScalar(resolveOperand(node2, r, this.ctx));
+      });
+
       const mapped = await this._projectRows(statement, rows, (r) => {
         const out = [];
-        for (const c of statement.columns) {
-          if (c.expr === '*') {
+        for (let ci = 0; ci < colGetters.length; ci++) {
+          const g = colGetters[ci];
+          if (g === null) {
             for (const k of starKeys) out.push(r[k] !== undefined ? r[k] : r[String(k).slice(String(k).indexOf('.') + 1)]);
-          } else if (c.over || (c.scalar && c.scalar.over)) out.push(windowColumnValue(c, r));
-          else if (c.scalar) out.push(projectScalar(resolveOperand(c.scalar, r, this.ctx)));
-          else if (c.literal !== undefined) out.push(c.literal);
-          else if (c.caseExpr) out.push(projectScalar(evaluateCaseVal(c.caseExpr, r)));
-          else out.push(projectScalar(resolveOperand({ type: 'column', name: c.expr }, r, this.ctx)));
+          } else out.push(g(r));
         }
         return out;
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsql-neo",
-  "version": "6.4.3",
+  "version": "6.4.5",
   "description": "JSQL-NEO — Rust-powered embedded database with WASM, REST API, B-Tree indexes, WAL, crash recovery",
   "main": "index.js",
   "types": "index.d.ts",
@@ -46,7 +46,7 @@
   ],
   "scripts": {
     "postinstall": "node postinstall.js",
-    "test": "node test/smoke.js && node test/json-functions.test.js && node test/sql-parser.test.js && node test/readme-audit.test.js && node test/query-opt.test.js && node test/wal-recovery.test.js && node test/mysql-compat-hijack.test.js && node test/dml-constraints.test.js",
+    "test": "node test/smoke.js && node test/native.test.js && node test/json-functions.test.js && node test/sql-parser.test.js && node test/readme-audit.test.js && node test/query-opt.test.js && node test/wal-recovery.test.js && node test/mysql-compat-hijack.test.js && node test/dml-constraints.test.js",
     "test:parser": "node test/sql-parser.test.js",
     "test:btree": "node test/btree.test.js",
     "test:native": "node test/native.test.js",

package/test/mongo-group.test.js

@@ -1,3 +1,17 @@
+/* ⚠️ 已知损坏，未纳入任何 CI 套件（test:all / npm test 都不含本文件）
+ *
+ * 现状：本文件会崩在 `rows is not iterable`（lib/mongo_server.js:541）。
+ * 另外 MongoDB 协议栈与**官方现代 driver 的握手尚未打通** ——
+ * 用官方 mongodb driver 连不上。
+ *
+ * 因此「四协议」目前实际是「一个半」：MySQL 可用；PG / Redis 以库形式
+ * 提供、需自行装配；MongoDB 仅供实验。
+ * 文档已按此更正（doc/why.md、doc/cli.md）。
+ *
+ * 修好前请勿把本文件加进 CI —— 它一崩就会像之前那样掐断 `&&` 链。
+ * 修 MongoDB 需要单独排期，不属于性能/打包类改动。
+ */
+
 // Test: MongoDB $group aggregation operators
 // Directly tests the _dispatch method of createMongoServer
 const { createMongoServer } = require('../lib/mongo_server.js');

package/test/native.test.js

@@ -26,7 +26,7 @@ function ok(name, cond, extra) {
     const ids = await db.insert('users', [{ name: 'Alice', age: 30 }, { name: 'Bob', age: 25 }]);
     ok('batch insert returns ids', Array.isArray(ids) && ids.length === 2, ids);
 
-    const row = db.findById('users', 1);
+    const row = await db.findById('users', 1);
     ok('findById returns flat row', row && row.id === 1 && row.name === 'Alice' && row.age === 30 && !('fields' in row), row);
 
     const rows = await db.find('users', {});
@@ -35,11 +35,11 @@ function ok(name, cond, extra) {
     ok('filter no match', (await db.find('users', { age: 99 })).length === 0);
     ok('count', (await db.count('users')) === 2);
 
-    db.updateByIds('users', [[1, { age: 99 }]]);
+    await db.updateByIds('users', [[1, { age: 99 }]]);
     await new Promise(r => setTimeout(r, 150));
-    ok('updateByIds applied', db.findById('users', 1).age === 99, db.findById('users', 1));
+    ok('updateByIds applied', (await db.findById('users', 1)).age === 99, await db.findById('users', 1));
 
-    db.removeByIds('users', [2]);
+    await db.removeByIds('users', [2]);
     await new Promise(r => setTimeout(r, 150));
     ok('removeByIds applied', (await db.count('users')) === 1, await db.count('users'));
     await db.stop();
@@ -57,12 +57,12 @@ function ok(name, cond, extra) {
     await db.createTable('t3', { id: { type: 'integer', primary_key: true, auto_increment: true }, name: { type: 'string' } });
     await db.insert('t3', { name: 'a' });
     await db.insert('t3', { id: 7, name: 'b' });
-    ok('snake_case pk respected', db.findById('t3', 7).name === 'b', db.findById('t3', 7));
-    ok('explicit pk bumps next id', db.findById('t3', 1).name === 'a');
+    ok('snake_case pk respected', (await db.findById('t3', 7)).name === 'b', await db.findById('t3', 7));
+    ok('explicit pk bumps next id', (await db.findById('t3', 1)).name === 'a');
 
     await db.createTable('cfg', 'key string primary key, value string');
     const cfgIds = await db.insert('cfg', { key: 'a', value: '1' });
-    ok('full shorthand string schema', cfgIds[0] === 'a' && db.findById('cfg', 'a').value === '1', cfgIds);
+    ok('full shorthand string schema', cfgIds[0] === 'a' && (await db.findById('cfg', 'a')).value === '1', cfgIds);
     await db.stop();
   }
 
@@ -112,23 +112,23 @@ function ok(name, cond, extra) {
     const ids = await db.insert('config', [{ key: 'a', value: '1' }, { key: 'b', value: '2' }]);
     ok('non-auto pk insert returns pk values', JSON.stringify(ids) === JSON.stringify(['a', 'b']), ids);
 
-    const a = db.findById('config', 'a');
+    const a = await db.findById('config', 'a');
     ok('findById resolves string pk', a && a.value === '1' && !('fields' in a), a);
-    ok('findById pk miss returns null', db.findById('config', 'nope') === null);
+    ok('findById pk miss returns null', await db.findById('config', 'nope') === null);
 
-    db.updateById('config', 'b', { value: '22' });
+    await db.updateById('config', 'b', { value: '22' });
     await new Promise(r => setTimeout(r, 150));
-    ok('updateById resolves string pk', db.findById('config', 'b').value === '22', db.findById('config', 'b'));
+    ok('updateById resolves string pk', (await db.findById('config', 'b')).value === '22', await db.findById('config', 'b'));
 
-    db.removeById('config', 'a');
+    await db.removeById('config', 'a');
     await new Promise(r => setTimeout(r, 150));
     ok('removeById resolves string pk', (await db.count('config')) === 1, await db.count('config'));
 
-    db.updateByIds('config', [['b', { value: '222' }]]);
+    await db.updateByIds('config', [['b', { value: '222' }]]);
     await new Promise(r => setTimeout(r, 150));
-    ok('updateByIds resolves string pk', db.findById('config', 'b').value === '222', db.findById('config', 'b'));
+    ok('updateByIds resolves string pk', (await db.findById('config', 'b')).value === '222', await db.findById('config', 'b'));
 
-    db.removeByIds('config', ['b']);
+    await db.removeByIds('config', ['b']);
     await new Promise(r => setTimeout(r, 150));
     ok('removeByIds resolves string pk', (await db.count('config')) === 0, await db.count('config'));
     await db.stop();

package/test/regress-5.1.0.js

@@ -90,50 +90,50 @@ function respClient(port) {
   /* ============ Core engine ============ */
   const db = new Database(':memory:', { autoSave: false });
   await db.start();
-  db.createTable('users', { id: 'integer primary key auto_increment', name: 'string', email: 'string unique', age: 'integer' });
-  for (const [n, a] of [['A', 10], ['B', 20], ['C', 30]]) db.insert('users', { name: n, email: n.toLowerCase() + '@x', age: a });
+  await db.createTable('users', { id: 'integer primary key auto_increment', name: 'string', email: 'string unique', age: 'integer' });
+  for (const [n, a] of [['A', 10], ['B', 20], ['C', 30]]) await db.insert('users', { name: n, email: n.toLowerCase() + '@x', age: a });
 
   {
-    const gt = db.find('users', { age: { $gt: 20 } }).map(r => r.name);
+    const gt = (await db.find('users', { age: { $gt: 20 } })).map(r => r.name);
     ok('find $gt excludes boundary', JSON.stringify(gt) === '["C"]', gt);
-    const lt = db.find('users', { age: { $lt: 20 } }).map(r => r.name);
+    const lt = (await db.find('users', { age: { $lt: 20 } })).map(r => r.name);
     ok('find $lt excludes boundary', JSON.stringify(lt) === '["A"]', lt);
   }
 
   {
-    db.removeById('users', 2); // B (id=2) removed, C still id=3
-    ok('removeById with PK count', db.count('users') === 2, db.count('users'));
-    ok('removeById PK lookup null', db.findById('users', 2) === null);
-    ok('removeById B-Tree still consistent', db.find('users', { age: { $gt: 15 } }).length === 1);
+    await db.removeById('users', 2); // B (id=2) removed, C still id=3
+    ok('removeById with PK count', await db.count('users') === 2, await db.count('users'));
+    ok('removeById PK lookup null', await db.findById('users', 2) === null);
+    ok('removeById B-Tree still consistent', (await db.find('users', { age: { $gt: 15 } })).length === 1);
   }
 
   {
-    db.createTable('np', { v: 'string', n: 'integer' });
-    for (let i = 0; i < 10; i++) db.insert('np', { v: 'v' + i, n: i });
-    db.createTable('h', { id: 'integer primary key auto_increment', grp: 'string', val: 'integer' });
-    for (let i = 0; i < 12; i++) db.insert('h', { grp: 'g' + (i % 4), val: i });
+    await db.createTable('np', { v: 'string', n: 'integer' });
+    for (let i = 0; i < 10; i++) await db.insert('np', { v: 'v' + i, n: i });
+    await db.createTable('h', { id: 'integer primary key auto_increment', grp: 'string', val: 'integer' });
+    for (let i = 0; i < 12; i++) await db.insert('h', { grp: 'g' + (i % 4), val: i });
     db._tables.h.createIndex('grp');
 
-    db.removeByIds('np', [1, 2]);
-    ok('removeByIds no-PK rebuilds indexes', db.find('np').length === 8, db.find('np').length);
+    await db.removeByIds('np', [1, 2]);
+    ok('removeByIds no-PK rebuilds indexes', (await db.find('np')).length === 8, (await db.find('np')).length);
 
-    const pre = db.find('h', { grp: 'g1' }).map(r => r.id).sort((a, b) => a - b);
-    db.removeById('h', 1); db.removeById('h', 5); db.removeById('h', 9); // the g0 rows
-    const post = db.find('h', { grp: 'g1' }).map(r => r.id).sort((a, b) => a - b);
+    const pre = (await db.find('h', { grp: 'g1' })).map(r => r.id).sort((a, b) => a - b);
+    await db.removeById('h', 1); await db.removeById('h', 5); await db.removeById('h', 9); // the g0 rows
+    const post = (await db.find('h', { grp: 'g1' })).map(r => r.id).sort((a, b) => a - b);
     ok('hash index survives swap-pop (g1 intact)', JSON.stringify(post) === JSON.stringify(pre), { pre, post });
-    ok('hash index has no stale g0 rows', db.find('h', { grp: 'g0' }).length === 0);
+    ok('hash index has no stale g0 rows', (await db.find('h', { grp: 'g0' })).length === 0);
     let stale = 0;
     for (const list of db._tables.h._indexes.grp.values()) for (const i of list) if (!db._tables.h._rows[i]) stale++;
     ok('hash index zero stale entries', stale === 0, stale);
   }
 
   {
-    db.createTable('docs', { id: 'integer primary key', data: 'string' });
-    db.insert('docs', { id: 1, data: JSON.stringify({ a: { b: 1 }, list: [1, 2, 3] }) });
+    await db.createTable('docs', { id: 'integer primary key', data: 'string' });
+    await db.insert('docs', { id: 1, data: JSON.stringify({ a: { b: 1 }, list: [1, 2, 3] }) });
     db.begin();
-    db.updateById('docs', 1, { data: JSON.stringify({ a: { b: 2 }, list: [9] }) });
+    await db.updateById('docs', 1, { data: JSON.stringify({ a: { b: 2 }, list: [9] }) });
     db.rollback();
-    const d = JSON.parse(db.findById('docs', 1).data);
+    const d = JSON.parse((await db.findById('docs', 1)).data);
     ok('transaction snapshot deep-copies nested object', d.a.b === 1, d);
     ok('transaction snapshot deep-copies arrays', JSON.stringify(d.list) === '[1,2,3]', d.list);
   }
@@ -148,31 +148,31 @@ function respClient(port) {
     ok('parseFieldShorthand default', s3.default === 'x' && s3.type === 'string', s3);
 
     let e = null;
-    try { db.insert('users', { name: 'X', email: 'a@x', age: 1 }); } catch (err) { e = err; }
+    try { await db.insert('users', { name: 'X', email: 'a@x', age: 1 }); } catch (err) { e = err; }
     ok('duplicate unique throws ER_DUP_ENTRY', e && (e.code === 1062 || String(e).includes('1062')), e && (e.code || e.message));
-    db.createTable('pk2', { a: 'integer primary key', b: 'string' });
-    db.insert('pk2', { a: 1, b: 'x' });
+    await db.createTable('pk2', { a: 'integer primary key', b: 'string' });
+    await db.insert('pk2', { a: 1, b: 'x' });
     e = null;
-    try { db.insert('pk2', { a: 1, b: 'y' }); } catch (err) { e = err; }
+    try { await db.insert('pk2', { a: 1, b: 'y' }); } catch (err) { e = err; }
     ok('duplicate primary key throws ER_DUP_ENTRY', e && (e.code === 1062 || String(e).includes('1062')), e && (e.code || e.message));
   }
 
   {
     const r = await migrate.importFromJSON(db, { table: 't1', schema: { id: 'integer primary key' }, rows: [{ id: 1 }, { id: 2 }] });
-    ok('importFromJSON single-table shape', r && db.count('t1') === 2);
+    ok('importFromJSON single-table shape', r && await db.count('t1') === 2);
     let threw = null;
     try { await migrate.importFromJSON(db, { table: 't1', schema: { id: 'integer primary key' }, rows: [{ id: 3 }] }); } catch (err) { threw = err; }
     ok('importFromJSON refuses existing table without overwrite', !!threw, threw && (threw.message || String(threw)));
     await migrate.importFromJSON(db, { table: 't1', schema: { id: 'integer primary key' }, rows: [{ id: 3 }] }, { overwrite: true });
-    ok('importFromJSON overwrite replaces table', db.count('t1') === 1, db.count('t1'));
+    ok('importFromJSON overwrite replaces table', await db.count('t1') === 1, await db.count('t1'));
   }
 
   {
-    db.createTable('lk', { s: 'string' });
-    for (const s of ['a.b', 'axb', 'aXb', 'abc']) db.insert('lk', { s });
-    const m = db.find('lk', { s: { $like: 'a.b' } }).map(r => r.s);
+    await db.createTable('lk', { s: 'string' });
+    for (const s of ['a.b', 'axb', 'aXb', 'abc']) await db.insert('lk', { s });
+    const m = (await db.find('lk', { s: { $like: 'a.b' } })).map(r => r.s);
     ok('$like escapes regex metacharacters', JSON.stringify(m) === '["a.b"]', m);
-    const m2 = db.find('lk', { s: { $like: 'a%b' } }).map(r => r.s);
+    const m2 = (await db.find('lk', { s: { $like: 'a%b' } })).map(r => r.s);
     ok('$like % wildcard still works', JSON.stringify(m2) === '["a.b","axb","aXb"]', m2);
   }
   await db.stop();