jsql-neo 6.3.6 → 6.3.10

package/test/identifier-keywords.test.js

@@ -0,0 +1,140 @@
+/*
+ * 非保留关键字当标识符测试。
+ *
+ * 问题：词法层的 KEYWORDS 表把一些「MySQL 里其实是非保留」的词也标成了 keyword，
+ * 而 parseTableName / parseColumnRef 只认 ident，于是这些最普通的写法被拒：
+ *     CREATE TABLE t (date DATE, text TEXT, count INT)
+ *     SELECT date, count FROM t
+ * 实测 64 个常见列名里有 31 个被拒，其中 date / text / count / engine /
+ * first / after / unsigned / zerofill / spatial / ignore / start
+ * 在 MySQL 里都不是保留字 —— 用户没有理由必须加反引号。
+ *
+ * 修法：不让词法层去区分（parseColumnDef 还依赖 type === 'keyword' 来认类型），
+ * 改在「期望一个名字」的位置放行 NON_RESERVED_KEYWORDS 里的词。
+ * 这与文件里 OVER / PARTITION 那条注释是同一个思路。
+ *
+ * 真正的保留字（TABLE / SELECT / KEY / ORDER / INDEX / GROUP / CASE ...）
+ * 仍然要求反引号 —— 这些用例用来防止放行范围被不小心扩大。
+ */
+const path = require('path');
+
+const ROOT = path.join(__dirname, '..');
+const { Database } = require(path.join(ROOT, 'index.js'));
+const { executeSQL } = require(path.join(ROOT, 'lib/sql.js'));
+
+const OPTS = { safety: false };
+let pass = 0, fail = 0;
+
+function ok(name, cond, extra) {
+  if (cond) { pass++; console.log('[OK]  ', name); }
+  else { fail++; console.log('[FAIL]', name, extra !== undefined ? '-> ' + JSON.stringify(extra).slice(0, 140) : ''); }
+}
+
+(async () => {
+  const db = new Database(':memory:');
+  const q = (sql) => executeSQL(db, sql, OPTS);
+  const rows = async (sql) => (await q(sql)).rows;
+  const okSql = async (sql) => { try { await q(sql); return true; } catch (_) { return false; } };
+
+  console.log('\n--- 非保留关键字可以当列名 ---');
+  const asColumn = ['first', 'after', 'date', 'time', 'datetime', 'timestamp', 'text',
+    'engine', 'ignore', 'spatial', 'unsigned', 'zerofill', 'start', 'count',
+    'number', 'value', 'type', 'state', 'level', 'source', 'data', 'total'];
+  for (const n of asColumn) {
+    ok(`列名 ${n}`, await okSql(`CREATE TABLE c_${n} (id INT PRIMARY KEY, ${n} TEXT)`));
+  }
+
+  console.log('\n--- 非保留关键字可以当表名 ---');
+  for (const n of ['date', 'text', 'count', 'engine', 'first']) {
+    ok(`表名 ${n}`, await okSql(`CREATE TABLE ${n} (id INT PRIMARY KEY)`));
+  }
+
+  console.log('\n--- 建表后能正常读写 ---');
+  {
+    await q('CREATE TABLE events (id INT PRIMARY KEY, date TEXT, text TEXT, count INT, engine TEXT)');
+    await q("INSERT INTO events VALUES (1, '2026-01-01', 'hello', 3, 'innodb')");
+    const r = await rows('SELECT id, date, text, count, engine FROM events');
+    ok('按这些列名查询正常', JSON.stringify(r) === '[[1,"2026-01-01","hello",3,"innodb"]]', r);
+
+    const w = await rows("SELECT id FROM events WHERE date = '2026-01-01' AND count = 3");
+    ok('按这些列名过滤正常', JSON.stringify(w) === '[[1]]', w);
+
+    await q('UPDATE events SET count = 4 WHERE id = 1');
+    ok('按这些列名更新正常', (await rows('SELECT count FROM events'))[0][0] === 4);
+
+    await q('CREATE INDEX idx_date ON events (date)');
+    ok('按这些列名建索引正常', (await rows("SELECT id FROM events WHERE date = '2026-01-01'"))[0][0] === 1);
+  }
+
+  console.log('\n--- ALTER TABLE 上也适用 ---');
+  {
+    await q('CREATE TABLE a1 (id INT PRIMARY KEY)');
+    await q('ALTER TABLE a1 ADD COLUMN date TEXT');
+    await q('ALTER TABLE a1 ADD COLUMN count INT');
+    ok('ADD COLUMN 用非保留关键字', (await q('SELECT * FROM a1')).columns.join(',') === 'id,date,count');
+
+    await q('ALTER TABLE a1 RENAME COLUMN date TO time');
+    ok('RENAME COLUMN 用非保留关键字', (await q('SELECT * FROM a1')).columns.join(',') === 'id,time,count');
+
+    await q('ALTER TABLE a1 DROP COLUMN time');
+    ok('DROP COLUMN 用非保留关键字', (await q('SELECT * FROM a1')).columns.join(',') === 'id,count');
+  }
+
+  console.log('\n--- 主键 / 唯一约束里也能用 ---');
+  {
+    await q('CREATE TABLE k1 (date TEXT PRIMARY KEY, count INT UNIQUE)');
+    await q("INSERT INTO k1 VALUES ('a', 1)");
+    let threw = false;
+    try { await q("INSERT INTO k1 VALUES ('a', 2)"); } catch (_) { threw = true; }
+    ok('非保留关键字作主键仍受约束', threw);
+  }
+
+  console.log('\n--- ORDER BY / GROUP BY / 别名 不受影响 ---');
+  {
+    await q('CREATE TABLE s1 (id INT PRIMARY KEY, count INT, date TEXT)');
+    await q("INSERT INTO s1 VALUES (1,1,'a'),(2,2,'b'),(3,1,'c')");
+    const ob = await rows('SELECT count FROM s1 ORDER BY count DESC, id');
+    ok('ORDER BY 用这些列名', JSON.stringify(ob) === '[[2],[1],[1]]', ob);
+    const gb = await rows('SELECT count, COUNT(*) AS n FROM s1 GROUP BY count ORDER BY count');
+    ok('GROUP BY 用这些列名', JSON.stringify(gb) === '[[1,2],[2,1]]', gb);
+    const al = await rows('SELECT count AS total FROM s1 WHERE id = 2');
+    ok('AS 别名不受影响', JSON.stringify(al) === '[[2]]', al);
+  }
+
+  console.log('\n--- 函数名仍然优先当函数解析 ---');
+  {
+    const one = async (sql) => (await q(sql)).rows[0][0];
+    ok('COUNT(*) 仍是聚合函数', await one('SELECT COUNT(*) FROM (SELECT 1 AS x) t') === 1);
+    ok('MAX() 仍是函数', await one('SELECT MAX(x) FROM (SELECT 1 AS x UNION ALL SELECT 2) t') === 2);
+    ok('MIN() 仍是函数', await one('SELECT MIN(x) FROM (SELECT 1 AS x UNION ALL SELECT 2) t') === 1);
+    ok('SUM() 仍是函数', await one('SELECT SUM(x) FROM (SELECT 3 AS x) t') === 3);
+    ok('DATE() 仍是函数', typeof await one("SELECT DATE('2026-01-01')") === 'string');
+    ok('COUNT() 紧跟括号才是函数', await one('SELECT COUNT(*) FROM (SELECT 1 AS x) t') === 1);
+    ok('裸 count 当列时不吞掉后面的 FROM', await okSql('SELECT count FROM (SELECT 1 AS count) t'));
+  }
+
+  console.log('\n--- 真保留字仍要求反引号（防止放行范围被扩大）---');
+  const reserved = ['key', 'order', 'group', 'index', 'column', 'table',
+    'case', 'when', 'then', 'else', 'end', 'select', 'from', 'where'];
+  for (const n of reserved) {
+    ok(`裸写 ${n} 作列名仍被拒`, !(await okSql(`CREATE TABLE r_${n} (${n} TEXT)`)));
+  }
+  ok('反引号包裹后可用', await okSql('CREATE TABLE r_ok (`key` TEXT, `order` INT)'));
+  {
+    await q('CREATE TABLE r_ok2 (`key` TEXT, `order` INT)');
+    await q("INSERT INTO r_ok2 VALUES ('k', 1)");
+    const r = await rows('SELECT `key`, `order` FROM r_ok2');
+    ok('反引号包裹后可读写', JSON.stringify(r) === '[["k",1]]', r);
+  }
+
+  console.log('\n--- 带点号的限定名 ---');
+  {
+    await q('CREATE TABLE q1 (date TEXT)');
+    await q("INSERT INTO q1 VALUES ('x')");
+    const r = await rows('SELECT q1.date FROM q1');
+    ok('表名.非保留关键字列名', JSON.stringify(r) === '[["x"]]', r);
+  }
+
+  console.log(`\n${pass} passed, ${fail} failed`);
+  process.exit(fail === 0 ? 0 : 1);
+})().catch(e => { console.error('💥', e); process.exit(1); });

package/test/index-ddl.test.js

@@ -0,0 +1,203 @@
+/*
+ * 索引管理测试（CREATE INDEX / CREATE UNIQUE INDEX / DROP INDEX）。
+ *
+ * 此前 DROP INDEX 一律报「not supported」，根因是两层语义错配：
+ *   - 标准 SQL 的 `DROP INDEX idx` 不带表名，而存储层 Table.dropIndex(field)
+ *     收的是**列名** —— 索引名被当列名传，必然找不到
+ *   - CREATE INDEX 是逐列建索引（复合索引 a,b 各建一个），
+ *     但删除时只清首列，复合索引会残留一半
+ * 另外还修了 CREATE INDEX 顺带往 SELECT 输出里塞一个 `id` 列的问题。
+ */
+const path = require('path');
+
+const ROOT = path.join(__dirname, '..');
+const { Database, JSQL, NativeJSQL } = require(path.join(ROOT, 'index.js'));
+const { executeSQL } = require(path.join(ROOT, 'lib/sql.js'));
+
+const OPTS = { safety: false };
+let pass = 0, fail = 0;
+
+function ok(name, cond, extra) {
+  if (cond) { pass++; console.log('[OK]  ', name); }
+  else { fail++; console.log('[FAIL]', name, extra !== undefined ? '-> ' + JSON.stringify(extra).slice(0, 120) : ''); }
+}
+const rowsOf = r => (Array.isArray(r) ? r[0] : r).rows;
+const eq = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+
+async function t(name, fn) {
+  const db = new Database(':memory:');
+  try {
+    const r = await fn({
+      exec: (sql) => executeSQL(db, sql, OPTS),
+      rows: (sql) => executeSQL(db, sql, OPTS).then(rowsOf),
+      tbl: () => db._ensureTable('t'),
+      db,
+    });
+    if (r === true) ok(name, true);
+    else ok(name, false, r);
+  } catch (e) {
+    ok(name, false, String(e.message || e).slice(0, 110));
+  } finally {
+    try { await db.stop(); } catch (_) { /* ignore */ }
+  }
+}
+const idxFields = (t) => Object.keys(t._indexes || {}).sort();
+
+(async () => {
+  console.log('\n--- CREATE INDEX ---');
+  await t('单列索引建后可查', async ({ exec, tbl, rows }) => {
+    await exec(`CREATE TABLE t (a INT, b TEXT)`);
+    await exec(`CREATE INDEX idx_a ON t(a)`);
+    if (!idxFields(tbl()).includes('a')) return { fields: idxFields(tbl()) };
+    return eq(await rows(`SELECT b FROM t WHERE a = 1`), []);
+  });
+  await t('复合索引逐列建', async ({ exec, tbl }) => {
+    await exec(`CREATE TABLE t (a INT, b TEXT, c INT)`);
+    await exec(`CREATE UNIQUE INDEX idx_ab ON t(a,b)`);
+    return eq(idxFields(tbl()), ['a', 'b']);
+  });
+  await t('多索引并存', async ({ exec, tbl }) => {
+    await exec(`CREATE TABLE t (a INT, b TEXT, c INT)`);
+    await exec(`CREATE INDEX i1 ON t(a)`);
+    await exec(`CREATE INDEX i2 ON t(b)`);
+    await exec(`CREATE INDEX i3 ON t(c)`);
+    return eq(idxFields(tbl()), ['a', 'b', 'c']);
+  });
+  await t('建索引不影响查询结果', async ({ exec, rows }) => {
+    await exec(`CREATE TABLE t (a INT, b TEXT)`);
+    await exec(`INSERT INTO t VALUES (1,'x'),(2,'y'),(3,'z')`);
+    const before = await rows(`SELECT a, b FROM t ORDER BY a`);
+    await exec(`CREATE INDEX idx_a ON t(a)`);
+    return eq(await rows(`SELECT a, b FROM t ORDER BY a`), before);
+  });
+  await t('建索引前后 SELECT * 列一致', async ({ exec, rows }) => {
+    // 注意：CREATE TABLE t (a INT, b TEXT) 本身会补一个自增主键 id，
+    // 所以基线是 ['id','a','b']，不是 ['a','b']。要验证的是「建索引不改变列集」。
+    await exec(`CREATE TABLE t (a INT, b TEXT)`);
+    await exec(`INSERT INTO t VALUES (1,'x')`);
+    const before = await rows(`SELECT * FROM t`);
+    await exec(`CREATE INDEX idx_a ON t(a)`);
+    return eq(await rows(`SELECT * FROM t`), before);
+  });
+  await t('索引对查询正确性无影响（重复值）', async ({ exec, rows }) => {
+    await exec(`CREATE TABLE t (a INT, b TEXT)`);
+    await exec(`INSERT INTO t VALUES (1,'x'),(1,'y'),(2,'z')`);
+    await exec(`CREATE INDEX idx_a ON t(a)`);
+    return eq(await rows(`SELECT b FROM t WHERE a = 1 ORDER BY b`), [['x'], ['y']]);
+  });
+
+  console.log('\n--- DROP INDEX ---');
+  await t('DROP INDEX 按索引名删（不带表名）', async ({ exec, tbl }) => {
+    await exec(`CREATE TABLE t (a INT, b TEXT)`);
+    await exec(`CREATE INDEX idx_a ON t(a)`);
+    await exec(`DROP INDEX idx_a`);
+    return eq(idxFields(tbl()), []);
+  });
+  await t('DROP INDEX 后查询仍正确', async ({ exec, rows, tbl }) => {
+    await exec(`CREATE TABLE t (a INT, b TEXT)`);
+    await exec(`INSERT INTO t VALUES (1,'x'),(2,'y')`);
+    await exec(`CREATE INDEX idx_a ON t(a)`);
+    await exec(`DROP INDEX idx_a`);
+    if (idxFields(tbl()).length) return { leftover: idxFields(tbl()) };
+    return eq(await rows(`SELECT b FROM t WHERE a = 2`), [['y']]);
+  });
+  await t('DROP INDEX 复合索引清掉全部列', async ({ exec, tbl }) => {
+    await exec(`CREATE TABLE t (a INT, b TEXT, c INT)`);
+    await exec(`CREATE UNIQUE INDEX idx_ab ON t(a,b)`);
+    await exec(`DROP INDEX idx_ab`);
+    // 此前只删首列，b 会残留
+    return eq(idxFields(tbl()), []);
+  });
+  await t('DROP INDEX 只删指定的，其余保留', async ({ exec, tbl }) => {
+    await exec(`CREATE TABLE t (a INT, b TEXT, c INT)`);
+    await exec(`CREATE INDEX i1 ON t(a)`);
+    await exec(`CREATE INDEX i2 ON t(b)`);
+    await exec(`CREATE INDEX i3 ON t(c)`);
+    await exec(`DROP INDEX i2`);
+    return eq(idxFields(tbl()), ['a', 'c']);
+  });
+  await t('DROP INDEX IF EXISTS 不存在的索引 → skipped', async ({ exec }) => {
+    await exec(`CREATE TABLE t (a INT)`);
+    const r = await exec(`DROP INDEX IF EXISTS nope`);
+    return r.skipped === true;
+  });
+  await t('DROP INDEX 不存在的索引 → 报错', async ({ exec }) => {
+    await exec(`CREATE TABLE t (a INT)`);
+    let threw = false;
+    try { await exec(`DROP INDEX nope`); } catch (_) { threw = true; }
+    return threw;
+  });
+  await t('DROP INDEX t.idx 形式', async ({ exec, tbl }) => {
+    await exec(`CREATE TABLE t (a INT)`);
+    await exec(`CREATE INDEX idx_a ON t(a)`);
+    await exec(`DROP INDEX t.idx_a`);
+    return eq(idxFields(tbl()), []);
+  });
+  await t('删除后索引可重建', async ({ exec, tbl }) => {
+    await exec(`CREATE TABLE t (a INT)`);
+    await exec(`CREATE INDEX i1 ON t(a)`);
+    await exec(`DROP INDEX i1`);
+    await exec(`CREATE INDEX i2 ON t(a)`);
+    return eq(idxFields(tbl()), ['a']);
+  });
+  await t('DROP TABLE 不受残留索引影响', async ({ exec, rows }) => {
+    await exec(`CREATE TABLE t (a INT)`);
+    await exec(`CREATE INDEX i1 ON t(a)`);
+    await exec(`DROP INDEX i1`);
+    await exec(`DROP TABLE t`);
+    let threw = false;
+    try { await exec(`SELECT * FROM t`); } catch (_) { threw = true; }
+    return threw;
+  });
+  await t('建索引不破坏已有数据', async ({ exec, rows }) => {
+    await exec(`CREATE TABLE t (a INT, b TEXT)`);
+    await exec(`INSERT INTO t VALUES (1,'x'),(2,'y'),(3,'z')`);
+    await exec(`CREATE INDEX idx_a ON t(a)`);
+    await exec(`DROP INDEX idx_a`);
+    return eq(await rows(`SELECT a, b FROM t ORDER BY a`), [[1, 'x'], [2, 'y'], [3, 'z']]);
+  });
+
+  console.log('\n--- 三个 engine 行为一致 ---');
+  // JSQL(wasm) / NativeJSQL 的索引由 Rust 侧二进制管理，JS 层看不到 _indexes，
+  // 也没有 createIndex/dropIndex 钩子 —— DDL 会明确报「不支持」而不是静默成功。
+  // 这里验证 Database（JS 引擎）的索引可建可删，并确认另外两个报的是明确的错。
+  {
+    const db = new Database(':memory:');
+    try {
+      await executeSQL(db, `CREATE TABLE t (a INT, b TEXT)`, OPTS);
+      await executeSQL(db, `CREATE INDEX idx_a ON t(a)`, OPTS);
+      const built = !!db._ensureTable('t')._indexes.a;
+      const r = await executeSQL(db, `DROP INDEX idx_a`, OPTS);
+      const left = Object.keys(db._ensureTable('t')._indexes).length;
+      ok('Database 建/删索引', built && r.ok === true && left === 0, { built, left });
+    } catch (e) {
+      ok('Database 建/删索引', false, String(e.message).slice(0, 80));
+    } finally { try { await db.stop(); } catch (_) { /* ignore */ } }
+  }
+  for (const [name, mk] of [
+    ['JSQL', () => new JSQL({ mode: 'memory' })],
+    ['NativeJSQL', () => new NativeJSQL({ mode: 'memory' })],
+  ]) {
+    const db = await mk();
+    if (db.start) await db.start();
+    try {
+      await executeSQL(db, `CREATE TABLE t (a INT)`, OPTS);
+      let msg = '', failed = false;
+      try { await executeSQL(db, `CREATE INDEX i ON t(a)`, OPTS); } catch (e) { failed = true; msg = String(e.message); }
+      // 要么真支持（CREATE 成功且 DROP 也成功），要么给明确的「不支持」——
+      // 最糟的是 CREATE 静默成功让人以为索引生效了。
+      if (failed) {
+        ok(`${name} 索引 DDL 明确报不支持`, /not supported/i.test(msg), msg.slice(0, 60));
+      } else {
+        let dropOk = false, dropMsg = '';
+        try { await executeSQL(db, `DROP INDEX i`, OPTS); dropOk = true; } catch (e) { dropMsg = String(e.message); }
+        ok(`${name} 索引 DDL 成对可用`, dropOk, dropMsg.slice(0, 60));
+      }
+    } catch (e) {
+      ok(`${name} 索引 DDL`, false, String(e.message).slice(0, 80));
+    } finally { try { await db.stop(); } catch (_) { /* ignore */ } }
+  }
+
+  console.log(`\n${pass} passed, ${fail} failed`);
+  process.exit(fail === 0 ? 0 : 1);
+})();

package/test/mongo-group.test.js

@@ -0,0 +1,105 @@
+// Test: MongoDB $group aggregation operators
+// Directly tests the _dispatch method of createMongoServer
+const { createMongoServer } = require('../lib/mongo_server.js');
+
+let pass = 0, fail = 0;
+const ok = (name, cond, extra) => {
+  if (cond) { pass++; console.log('[OK]', name); }
+  else { fail++; console.log('[FAIL]', name, extra !== undefined ? '→ ' + JSON.stringify(extra) : ''); }
+};
+
+// Build a test server with a pre-populated collection
+const srv = createMongoServer({ port: 0, noAuth: true, dataDir: ':memory:' });
+srv.listen(() => {
+  (async () => {
+    // Get the engine and pre-populate
+    const engine = await srv._getEngine();
+    engine.createTable('sales', { schema: { _id: { type: 'integer' }, item: { type: 'string' }, qty: { type: 'integer' }, price: { type: 'integer' } } });
+    const table = engine._ensureTable('sales');
+    table._rows = [
+      { _id: 1, item: 'A', qty: 10, price: 5 },
+      { _id: 2, item: 'B', qty: 5, price: 10 },
+      { _id: 3, item: 'A', qty: 3, price: 5 },
+      { _id: 4, item: 'B', qty: 7, price: 10 },
+    ];
+
+    // --- Test 1: $group with $sum on field (the bug we're fixing) ---
+    let r = await srv._dispatch('aggregate', {
+      aggregate: 'sales',
+      pipeline: [{ '$group': { _id: '$item', total: { '$sum': '$qty' } } }],
+      '$db': 'test'
+    });
+    const batch1 = r.cursor ? r.cursor.firstBatch : [];
+    const byItem = {};
+    for (const row of batch1) byItem[row._id] = row.total;
+    ok('$group $sum on field (item:A)', byItem['A'] === 13, byItem);
+    ok('$group $sum on field (item:B)', byItem['B'] === 12, byItem);
+
+    // --- Test 2: $group with $sum:1 (count) ---
+    r = await srv._dispatch('aggregate', {
+      aggregate: 'sales',
+      pipeline: [{ '$group': { _id: '$item', count: { '$sum': 1 } } }],
+      '$db': 'test'
+    });
+    const batch2 = r.cursor ? r.cursor.firstBatch : [];
+    const byCount = {};
+    for (const row of batch2) byCount[row._id] = row.count;
+    ok('$group $sum:1 count (item:A)', byCount['A'] === 2, byCount);
+    ok('$group $sum:1 count (item:B)', byCount['B'] === 2, byCount);
+
+    // --- Test 3: $group with $avg ---
+    r = await srv._dispatch('aggregate', {
+      aggregate: 'sales',
+      pipeline: [{ '$group': { _id: '$item', avgQty: { '$avg': '$qty' } } }],
+      '$db': 'test'
+    });
+    const batch3 = r.cursor ? r.cursor.firstBatch : [];
+    const byAvg = {};
+    for (const row of batch3) byAvg[row._id] = row.avgQty;
+    ok('$group $avg on field (item:A)', byAvg['A'] === 6.5, byAvg);
+    ok('$group $avg on field (item:B)', byAvg['B'] === 6, byAvg);
+
+    // --- Test 4: $group with $min / $max ---
+    r = await srv._dispatch('aggregate', {
+      aggregate: 'sales',
+      pipeline: [{ '$group': { _id: '$item', minQty: { '$min': '$qty' }, maxQty: { '$max': '$qty' } } }],
+      '$db': 'test'
+    });
+    const batch4 = r.cursor ? r.cursor.firstBatch : [];
+    const byRange = {};
+    for (const row of batch4) byRange[row._id] = { min: row.minQty, max: row.maxQty };
+    ok('$group $min (item:A)', byRange['A'] && byRange['A'].min === 3, byRange);
+    ok('$group $min (item:B)', byRange['B'] && byRange['B'].min === 5, byRange);
+    ok('$group $max (item:A)', byRange['A'] && byRange['A'].max === 10, byRange);
+    ok('$group $max (item:B)', byRange['B'] && byRange['B'].max === 7, byRange);
+
+    // --- Test 5: existing $sum:1 still works ---
+    r = await srv._dispatch('aggregate', {
+      aggregate: 'sales',
+      pipeline: [{ '$group': { _id: '$item', cnt: { '$sum': 1 } } }],
+      '$db': 'test'
+    });
+    const batch5 = r.cursor ? r.cursor.firstBatch : [];
+    const byCnt = {};
+    for (const row of batch5) byCnt[row._id] = row.cnt;
+    ok('$group $sum:1 (count) still works', byCnt['A'] === 2 && byCnt['B'] === 2, byCnt);
+
+    // --- Test 6: $group with $sum on a different field ---
+    r = await srv._dispatch('aggregate', {
+      aggregate: 'sales',
+      pipeline: [{ '$group': { _id: '$item', totalPrice: { '$sum': '$price' } } }],
+      '$db': 'test'
+    });
+    const batch6 = r.cursor ? r.cursor.firstBatch : [];
+    const byPrice = {};
+    for (const row of batch6) byPrice[row._id] = row.totalPrice;
+    ok('$group $sum on different field (price)', byPrice['A'] === 10 && byPrice['B'] === 20, byPrice);
+
+    srv.close();
+    console.log(fail === 0 ? '\nALL TESTS PASSED' : `\n${fail} FAILURES`);
+    process.exit(fail === 0 ? 0 : 1);
+  })().catch(e => {
+    console.error('FATAL:', e.message, e.stack);
+    process.exit(1);
+  });
+});

package/test/null-semantics.test.js

@@ -0,0 +1,126 @@
+/*
+ * 标量函数的 NULL 语义测试（COALESCE / GREATEST / LEAST / CONCAT / CONCAT_WS）。
+ *
+ * 这一批全是「静默算错」——不抛异常、不影响其他测试，只有拿标准答案逐条对照才暴露。
+ *
+ * 三处偏差：
+ *   1. COALESCE 全部取不到值时返回 undefined。而 undefined 在结果行里会
+ *      让整个键消失（JSON.stringify 直接丢掉），等于这一列凭空不见。
+ *      IFNULL 返回的是 null，两者不一致。
+ *   2. GREATEST / LEAST 直接拿 JS 的 > / < 比较，而 JS 里 null 会强转成 0 ——
+ *      GREATEST(NULL,1) 得 1、LEAST(NULL,1) 得 null，这一对函数自相矛盾。
+ *   3. CONCAT 把 NULL 当成空串。而本引擎其余所有标量函数（UPPER / LENGTH /
+ *      TRIM / ABS / SUBSTRING / REPLACE ...）遇到 NULL 一律返回 NULL，
+ *      CONCAT 是唯一的例外；MySQL 也是返回 NULL。
+ *      把 NULL 当空串会拼出一个「看起来正常」的错值：
+ *      CONCAT(first,' ',last) 里 last 为 NULL 时得到 "John " 而不是 NULL，
+ *      缺失的字段就此被掩盖。
+ *   4. CONCAT_WS 的分隔符为 NULL 时会悄悄退回逗号（MySQL 返回 NULL）。
+ *      CONCAT_WS 本身跳过 NULL 参数是对的，这个行为要保住。
+ */
+const path = require('path');
+
+const ROOT = path.join(__dirname, '..');
+const { Database } = require(path.join(ROOT, 'index.js'));
+const { executeSQL } = require(path.join(ROOT, 'lib/sql.js'));
+
+const OPTS = { safety: false };
+let pass = 0, fail = 0;
+
+function ok(name, cond, extra) {
+  if (cond) { pass++; console.log('[OK]  ', name); }
+  else { fail++; console.log('[FAIL]', name, extra !== undefined ? '-> ' + JSON.stringify(extra).slice(0, 140) : ''); }
+}
+
+(async () => {
+  const db = new Database(':memory:');
+  const q = (sql) => executeSQL(db, sql, OPTS);
+  /** 取第一行第一列，并如实区分 null / undefined —— 这正是本组的重点 */
+  const one = async (sql) => {
+    const r = await q(sql);
+    return r.rows[0][0];
+  };
+  const isNull = async (sql) => (await one(sql)) === null;
+
+  console.log('\n--- COALESCE ---');
+  ok('COALESCE(NULL, NULL) 是 null 而不是 undefined', await isNull('SELECT COALESCE(NULL, NULL)'),
+    await one('SELECT COALESCE(NULL, NULL)'));
+  ok('COALESCE 返回 null 时结果行里键仍在（不被 JSON 丢掉）',
+    JSON.stringify((await q('SELECT COALESCE(NULL, NULL) AS c')).rows) === '[[null]]',
+    (await q('SELECT COALESCE(NULL, NULL) AS c')).rows);
+  ok('COALESCE(NULL, 1)', await one('SELECT COALESCE(NULL, 1)') === 1);
+  ok('COALESCE(1, NULL)', await one('SELECT COALESCE(1, NULL)') === 1);
+  ok('COALESCE 取第一个非 NULL', await one('SELECT COALESCE(NULL, NULL, 3, 4)') === 3);
+  ok('COALESCE 与 IFNULL 对全 NULL 的处理一致',
+    (await isNull('SELECT COALESCE(NULL, NULL)')) && (await isNull('SELECT IFNULL(NULL, NULL)')));
+  ok('COALESCE 传 0 不会跳过（0 不是 NULL）', await one('SELECT COALESCE(0, 9)') === 0);
+  ok('COALESCE 传空串不会跳过', await one("SELECT COALESCE('', 'x')") === '');
+  // 引擎按 MySQL 语义把布尔字面量归一成 0/1，而不是 JS 的 false/true
+  ok('COALESCE 传 FALSE 不会跳过（返回 0，不是 NULL）', await one('SELECT COALESCE(FALSE, 9)') === 0);
+
+  console.log('\n--- GREATEST / LEAST ---');
+  ok('GREATEST(NULL, 1) 返回 NULL', await isNull('SELECT GREATEST(NULL, 1)'));
+  ok('LEAST(NULL, 1) 返回 NULL', await isNull('SELECT LEAST(NULL, 1)'));
+  ok('两者对 NULL 的处理一致（此前 GREATEST 得 1、LEAST 得 null）',
+    (await isNull('SELECT GREATEST(NULL, 1)')) === (await isNull('SELECT LEAST(NULL, 1)')));
+  ok('GREATEST(NULL, NULL)', await isNull('SELECT GREATEST(NULL, NULL)'));
+  ok('LEAST(NULL, NULL)', await isNull('SELECT LEAST(NULL, NULL)'));
+  ok('GREATEST 正常取最大', await one('SELECT GREATEST(3, 1, 2)') === 3);
+  ok('LEAST 正常取最小', await one('SELECT LEAST(3, 1, 2)') === 1);
+  ok('GREATEST 单参数', await one('SELECT GREATEST(5)') === 5);
+  ok('LEAST 单参数', await one('SELECT LEAST(5)') === 5);
+  ok('GREATEST 带负数', await one('SELECT GREATEST(-5, -10)') === -5);
+  ok('LEAST 带负数', await one('SELECT LEAST(-5, -10)') === -10);
+  ok('GREATEST 不把 0 当 NULL', await one('SELECT GREATEST(0, -1)') === 0);
+
+  console.log('\n--- CONCAT ---');
+  ok('CONCAT 遇到 NULL 返回 NULL', await isNull("SELECT CONCAT('a', NULL, 'b')"));
+  ok('NULL 在首位也返回 NULL', await isNull("SELECT CONCAT(NULL, 'a')"));
+  ok('NULL 在末位也返回 NULL', await isNull("SELECT CONCAT('a', NULL)"));
+  ok('全 NULL 返回 NULL', await isNull('SELECT CONCAT(NULL, NULL)'));
+  ok('正常拼接不受影响', await one("SELECT CONCAT('a', 'b', 'c')") === 'abc');
+  ok('数字会转成字符串', await one("SELECT CONCAT('n=', 42)") === 'n=42');
+  ok('空串不是 NULL', await one("SELECT CONCAT('a', '', 'b')") === 'ab');
+  ok('0 不是 NULL', await one("SELECT CONCAT('a', 0)") === 'a0');
+  ok('CONCAT 与其余标量函数的 NULL 行为一致',
+    (await isNull("SELECT CONCAT('a', NULL)")) && (await isNull('SELECT UPPER(NULL)')));
+
+  console.log('\n--- CONCAT_WS ---');
+  ok('CONCAT_WS 跳过 NULL 参数（与 CONCAT 相反）',
+    await one("SELECT CONCAT_WS('-', 'a', NULL, 'b')") === 'a-b');
+  ok('CONCAT_WS 全 NULL 参数给空串',
+    await one("SELECT CONCAT_WS('-', NULL, NULL)") === '');
+  ok('CONCAT_WS 分隔符为 NULL → 返回 NULL（此前悄悄退回逗号）',
+    await isNull("SELECT CONCAT_WS(NULL, 'a', 'b')"));
+  ok('CONCAT_WS 正常分隔', await one("SELECT CONCAT_WS(',', 'a', 'b', 'c')") === 'a,b,c');
+  ok('CONCAT_WS 单参数即原值', await one("SELECT CONCAT_WS('-', 'a')") === 'a');
+  ok('CONCAT_WS 空串分隔符', await one("SELECT CONCAT_WS('', 'a', 'b')") === 'ab');
+
+  console.log('\n--- 与其余标量函数的一致性（回归护栏）---');
+  const nullPropagating = [
+    'UPPER(NULL)', 'LOWER(NULL)', 'LENGTH(NULL)', 'TRIM(NULL)', 'ABS(NULL)',
+    'ROUND(NULL, 1)', 'SUBSTRING(NULL, 1, 1)', "REPLACE(NULL, 'a', 'b')",
+    "INSTR(NULL, 'a')", 'SQRT(NULL)', 'CONCAT(NULL)',
+  ];
+  for (const expr of nullPropagating) {
+    ok(`${expr} 传播 NULL`, await isNull(`SELECT ${expr}`));
+  }
+
+  console.log('\n--- 表数据上验证 ---');
+  {
+    await q('CREATE TABLE people (id INT PRIMARY KEY, first TEXT, last TEXT)');
+    await q("INSERT INTO people VALUES (1,'John','Doe'),(2,'Jane',NULL)");
+    const rows = (await q('SELECT id, CONCAT(first, " ", last) AS full_name FROM people ORDER BY id')).rows;
+    ok('拼接缺字段的行得到 NULL 而不是 "Jane "',
+      JSON.stringify(rows) === '[[1,"John Doe"],[2,null]]', rows);
+
+    const co = (await q("SELECT COALESCE(last, first) AS v FROM people ORDER BY id")).rows;
+    ok('COALESCE 在表数据上正常兜底', JSON.stringify(co) === '[["Doe"],["Jane"]]', co);
+
+    const mx = (await q('SELECT GREATEST(id, 1) AS g, LEAST(id, 1) AS l FROM people ORDER BY id')).rows;
+    ok('GREATEST / LEAST 在表数据上正常', JSON.stringify(mx) === '[[1,1],[2,1]]', mx);
+  }
+
+  console.log(`\n${pass} passed, ${fail} failed`);
+  process.exit(fail === 0 ? 0 : 1);
+})().catch(e => { console.error('💥', e); process.exit(1); });