jsql-neo 6.3.5 → 6.3.10

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); });

package/test/recursive-cte.test.js

@@ -0,0 +1,123 @@
+/*
+ * 递归 CTE（WITH RECURSIVE）测试。
+ *
+ * 此前解析层能识别（recursive:true、UNION ALL 结构都对），
+ * 但执行时把 CTE 的自身引用内联成子查询，导致报 no such column；
+ * 修好后又暴露三个问题，逐个都曾让结果错误：
+ *   1. 虚拟行被加了表名前缀 → 递归项里的 `n+1` 取不到值
+ *   2. 每轮把全部累积行喂回递归项 → 行数按轮递增（1..5 得到 1,2,2,3,2,3,…）
+ *   3. 只限制迭代次数不够，行数翻倍会先打爆内存（实测 OOM）
+ */
+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 { parseSQL } = 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);
+
+/** 每个用例独立 :memory: 库，避免状态污染 */
+async function t(name, sql, expect, engineName) {
+  const db = engineName === 'JSQL' ? new JSQL({ mode: 'memory' })
+    : engineName === 'NativeJSQL' ? new NativeJSQL({ mode: 'memory' })
+      : new Database(':memory:');
+  try {
+    if (db.start) await db.start();
+    const got = rowsOf(await executeSQL(db, sql, OPTS));
+    if (eq(got, expect)) ok(name, true);
+    else ok(name, false, { got, expect });
+  } catch (e) {
+    ok(name, false, String(e.message || e).slice(0, 100));
+  } finally {
+    try { await db.stop(); } catch (_) { /* ignore */ }
+  }
+}
+
+(async () => {
+  console.log('\n--- 解析 ---');
+  {
+    const a = parseSQL('WITH RECURSIVE c(n) AS (SELECT 1 UNION ALL SELECT n+1 FROM c WHERE n<5) SELECT * FROM c');
+    ok('识别 RECURSIVE', a.recursive === true, a.recursive);
+    ok('记录显式列名', JSON.stringify(a.ctes[0].columns) === '["n"]', a.ctes[0].columns);
+    ok('记录 UNION ALL', a.ctes[0].select.union && a.ctes[0].select.union.all === true);
+    // RECURSIVE 放在第一个 CTE 之后也接受
+    const b = parseSQL('WITH k AS (SELECT 1 AS m), RECURSIVE c(n) AS (SELECT 1 UNION ALL SELECT n+1 FROM c WHERE n<3) SELECT * FROM c');
+    ok('CTE 之间的 RECURSIVE 也能解析', b.ctes.length === 2, b.ctes.length);
+  }
+
+  console.log('\n--- 基本递归 ---');
+  await t('计数 1..5', 'WITH RECURSIVE c(n) AS (SELECT 1 UNION ALL SELECT n+1 FROM c WHERE n<5) SELECT * FROM c',
+    [[1], [2], [3], [4], [5]]);
+  await t('1..10 求和 = 55', 'WITH RECURSIVE c(n) AS (SELECT 1 UNION ALL SELECT n+1 FROM c WHERE n<10) SELECT SUM(n) AS s FROM c',
+    [[55]]);
+  await t('倒计数 3..1', 'WITH RECURSIVE c(n) AS (SELECT 3 UNION ALL SELECT n-1 FROM c WHERE n>1) SELECT * FROM c',
+    [[3], [2], [1]]);
+  await t('显式列名 + 外层过滤',
+    'WITH RECURSIVE c(x) AS (SELECT 1 UNION ALL SELECT x+1 FROM c WHERE x<3) SELECT * FROM c WHERE x>1',
+    [[2], [3]]);
+  await t('UNION（去重）终止',
+    'WITH RECURSIVE c(n) AS (SELECT 1 UNION SELECT 1 FROM c WHERE n<3) SELECT * FROM c',
+    [[1]]);
+  await t('多列递归',
+    'WITH RECURSIVE c(a,b) AS (SELECT 1,1 UNION ALL SELECT a+1,b+a FROM c WHERE a<4) SELECT * FROM c',
+    [[1, 1], [2, 2], [3, 4], [4, 7]]);
+  await t('外层聚合递归结果',
+    'WITH RECURSIVE c(n) AS (SELECT 1 UNION ALL SELECT n+1 FROM c WHERE n<4) SELECT COUNT(*) AS k, MAX(n) AS mx FROM c',
+    [[4, 4]]);
+  await t('多锚点分支（UNION 链 > 2 节）',
+    'WITH RECURSIVE c(n) AS (SELECT 1 UNION ALL SELECT 2 UNION ALL SELECT n+1 FROM c WHERE n<3) SELECT * FROM c',
+    [[1], [2], [2], [3], [3]]);
+  await t('日期序列',
+    `WITH RECURSIVE d(x) AS (SELECT DATE('2026-01-01') UNION ALL SELECT DATE_ADD(x, INTERVAL 1 DAY) FROM d WHERE x < DATE('2026-01-04')) SELECT * FROM d`,
+    [['2026-01-01'], ['2026-01-02'], ['2026-01-03'], ['2026-01-04']]);
+  await t('递归 CTE 与普通 JOIN',
+    'WITH c(n) AS (SELECT 1 UNION ALL SELECT n+1 FROM c WHERE n<3) SELECT c1.n, c2.n FROM c c1, c c2 WHERE c2.n = c1.n + 1 ORDER BY c1.n',
+    [[1, 2], [2, 3]]);
+  await t('递归 CTE 可被外层引用多次',
+    'WITH c(n) AS (SELECT 1 UNION ALL SELECT n+1 FROM c WHERE n<3) SELECT (SELECT COUNT(*) FROM c) AS a, (SELECT MAX(n) FROM c) AS b',
+    [[3, 3]]);
+
+  console.log('\n--- 安全性：无限递归必须有兜底 ---');
+  {
+    const db = new Database(':memory:');
+    const t0 = Date.now();
+    let got = null, err = null;
+    try {
+      // WHERE 恒真 → 无限增长
+      got = rowsOf(await executeSQL(db, 'WITH RECURSIVE c(n) AS (SELECT 1 UNION ALL SELECT n+1 FROM c) SELECT COUNT(*) AS k FROM c', OPTS));
+    } catch (e) { err = e; }
+    ok('无限递归不 OOM、不挂死（有限时间内返回）', err !== null || (got && got[0][0] > 0), err ? String(err.message).slice(0, 60) : got);
+    ok('兜底在 30s 内返回', Date.now() - t0 < 30000, ((Date.now() - t0) / 1000).toFixed(1) + 's');
+    await db.stop();
+  }
+
+  console.log('\n--- 非递归 CTE 回归对照 ---');
+  await t('普通 CTE 不受影响', 'WITH x AS (SELECT 1 AS n) SELECT * FROM x', [[1]]);
+  await t('普通 CTE 引用前一个',
+    'WITH a AS (SELECT 1 AS m), b AS (SELECT m+1 AS n FROM a) SELECT * FROM b', [[2]]);
+  await t('普通 CTE 显式列名',
+    'WITH x(q) AS (SELECT 5) SELECT q FROM x', [[5]]);
+  await t('非递归 UNION ALL 正常',
+    'SELECT 1 AS n UNION ALL SELECT 2', [[1], [2]]);
+  await t('UNION 去重正常', 'SELECT 1 AS n UNION SELECT 1', [[1]]);
+  await t('INTERSECT / EXCEPT 正常',
+    'SELECT 1 AS n UNION SELECT 2 INTERSECT SELECT 1', [[1]]);
+
+  console.log('\n--- 三个 engine 一致性 ---');
+  for (const eng of ['JSQL', 'NativeJSQL', 'Database']) {
+    await t(`${eng} 递归 CTE`, 'WITH RECURSIVE c(n) AS (SELECT 1 UNION ALL SELECT n+1 FROM c WHERE n<4) SELECT * FROM c',
+      [[1], [2], [3], [4]], eng);
+  }
+
+  console.log(`\n${pass} passed, ${fail} failed`);
+  process.exit(fail === 0 ? 0 : 1);
+})();