jsql-neo 6.3.3 → 6.3.5

package/test/dml-constraints.test.js

@@ -0,0 +1,163 @@
+/*
+ * DML 与表约束回归测试。
+ *
+ * 覆盖两类曾静默出错的问题：
+ *   1. 无主键表批量删除删错行 —— 存储层把 id 当 1-based 行号，
+ *      边解析边删会让后续行号整体左移（DELETE ... WHERE id <= 2
+ *      在 5 行表上只删掉 1 行，且留下的是第 2 行）。
+ *   2. UPDATE 改主键/唯一列不校验冲突 —— 直接 Object.assign，
+ *      静默产生两行同主键（MySQL / SQLite 都会报 UNIQUE constraint failed）。
+ *
+ * 每个用例独立建库，避免状态污染。
+ */
+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) : ''); }
+}
+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, 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),
+      scalar: (sql) => executeSQL(db, sql, OPTS).then(r => rowsOf(r)[0][0]),
+      mustFail: async (sql) => {
+        try { await executeSQL(db, sql, OPTS); return '本该报错却成功了'; }
+        catch (e) { return true; }
+      },
+    });
+    if (r === true) ok(name, true);
+    else ok(name, false, r);
+  } catch (e) {
+    ok(name, false, String(e.message || e).slice(0, 120));
+  } finally {
+    try { await db.stop(); } catch (_) { /* ignore */ }
+  }
+}
+
+(async () => {
+  console.log('\n--- 无主键表：批量删除曾删错行 ---');
+  await t('无主键 DELETE 多个连续行', async ({ exec, rows }) => {
+    await exec(`CREATE TABLE t (id INT)`);
+    await exec(`INSERT INTO t VALUES (1),(2),(3),(4),(5)`);
+    await exec(`DELETE FROM t WHERE id <= 2`);
+    return eq(await rows(`SELECT id FROM t ORDER BY id`), [[3], [4], [5]]);
+  });
+  await t('无主键 DELETE IN 列表', async ({ exec, rows }) => {
+    await exec(`CREATE TABLE t (id INT)`);
+    await exec(`INSERT INTO t VALUES (1),(2),(3),(4),(5)`);
+    await exec(`DELETE FROM t WHERE id IN (1,4)`);
+    return eq(await rows(`SELECT id FROM t ORDER BY id`), [[2], [3], [5]]);
+  });
+  await t('无主键 DELETE 单行（回归对照）', async ({ exec, rows }) => {
+    await exec(`CREATE TABLE t (id INT)`);
+    await exec(`INSERT INTO t VALUES (1),(2),(3)`);
+    await exec(`DELETE FROM t WHERE id = 2`);
+    return eq(await rows(`SELECT id FROM t ORDER BY id`), [[1], [3]]);
+  });
+  await t('无主键 DELETE 全部', async ({ exec, rows }) => {
+    await exec(`CREATE TABLE t (id INT)`);
+    await exec(`INSERT INTO t VALUES (1),(2),(3)`);
+    await exec(`DELETE FROM t`);
+    return eq(await rows(`SELECT id FROM t`), []);
+  });
+  await t('有主键 DELETE 多个（回归对照）', async ({ exec, rows }) => {
+    await exec(`CREATE TABLE t (id INT PRIMARY KEY)`);
+    await exec(`INSERT INTO t VALUES (1),(2),(3),(4),(5)`);
+    await exec(`DELETE FROM t WHERE id <= 2`);
+    return eq(await rows(`SELECT id FROM t ORDER BY id`), [[3], [4], [5]]);
+  });
+  await t('无主键 DELETE 后行数正确', async ({ exec, scalar }) => {
+    await exec(`CREATE TABLE t (id INT)`);
+    await exec(`INSERT INTO t VALUES (1),(2),(3)`);
+    const r = await exec(`DELETE FROM t WHERE id > 1`);
+    if (r.affectedRows !== 2) return { affectedRows: r.affectedRows, want: 2 };
+    return eq(await scalar(`SELECT COUNT(*) AS c FROM t`), 1);
+  });
+
+  console.log('\n--- UPDATE 改主键 / 唯一列曾不校验冲突 ---');
+  await t('UPDATE 主键成已存在值 → 报错', async ({ exec, mustFail }) => {
+    await exec(`CREATE TABLE t (id INT PRIMARY KEY, v INT)`);
+    await exec(`INSERT INTO t VALUES (1,10),(2,20)`);
+    return mustFail(`UPDATE t SET id = 1 WHERE id = 2`);
+  });
+  await t('UPDATE 主键冲突后数据未损坏', async ({ exec, rows }) => {
+    await exec(`CREATE TABLE t (id INT PRIMARY KEY, v INT)`);
+    await exec(`INSERT INTO t VALUES (1,10),(2,20),(3,30)`);
+    try { await exec(`UPDATE t SET id = 1 WHERE id = 2`); } catch (_) { /* expected */ }
+    return eq(await rows(`SELECT id, v FROM t ORDER BY id`), [[1, 10], [2, 20], [3, 30]]);
+  });
+  await t('UPDATE 主键成不冲突值 → 成功', async ({ exec, rows }) => {
+    await exec(`CREATE TABLE t (id INT PRIMARY KEY, v INT)`);
+    await exec(`INSERT INTO t VALUES (1,10),(2,20),(3,30)`);
+    await exec(`UPDATE t SET id = 9 WHERE id = 2`);
+    return eq(await rows(`SELECT id, v FROM t ORDER BY id`), [[1, 10], [3, 30], [9, 20]]);
+  });
+  await t('UPDATE 主键为自身值 → 允许', async ({ exec, scalar }) => {
+    await exec(`CREATE TABLE t (id INT PRIMARY KEY, v INT)`);
+    await exec(`INSERT INTO t VALUES (1,10),(9,20)`);
+    await exec(`UPDATE t SET id = 9 WHERE id = 9`);
+    return eq(await scalar(`SELECT COUNT(*) AS c FROM t`), 2);
+  });
+  await t('UPDATE UNIQUE 列成已存在值 → 报错', async ({ exec, mustFail }) => {
+    await exec(`CREATE TABLE t (id INT PRIMARY KEY, e TEXT UNIQUE)`);
+    await exec(`INSERT INTO t VALUES (1,'a'),(2,'b')`);
+    return mustFail(`UPDATE t SET e = 'a' WHERE id = 2`);
+  });
+  await t('UPDATE UNIQUE 列成不冲突值 → 成功', async ({ exec, rows }) => {
+    await exec(`CREATE TABLE t (id INT PRIMARY KEY, e TEXT UNIQUE)`);
+    await exec(`INSERT INTO t VALUES (1,'a'),(2,'b')`);
+    await exec(`UPDATE t SET e = 'c' WHERE id = 2`);
+    return eq(await rows(`SELECT id, e FROM t ORDER BY id`), [[1, 'a'], [2, 'c']]);
+  });
+  await t('UPDATE 非约束列不受影响', async ({ exec, rows }) => {
+    await exec(`CREATE TABLE t (id INT PRIMARY KEY, v INT)`);
+    await exec(`INSERT INTO t VALUES (1,10),(2,20)`);
+    await exec(`UPDATE t SET v = 99 WHERE id = 1`);
+    return eq(await rows(`SELECT id, v FROM t ORDER BY id`), [[1, 99], [2, 20]]);
+  });
+
+  console.log('\n--- 既有约束行为回归对照 ---');
+  await t('INSERT 主键重复 → 报错', async ({ exec, mustFail }) => {
+    await exec(`CREATE TABLE t (id INT PRIMARY KEY)`);
+    await exec(`INSERT INTO t VALUES (1)`);
+    return mustFail(`INSERT INTO t VALUES (1)`);
+  });
+  await t('INSERT NOT NULL 违反 → 报错', async ({ exec, mustFail }) => {
+    await exec(`CREATE TABLE t (id INT, v TEXT NOT NULL)`);
+    return mustFail(`INSERT INTO t VALUES (1,NULL)`);
+  });
+  await t('INSERT UNIQUE 重复 → 报错', async ({ exec, mustFail }) => {
+    await exec(`CREATE TABLE t (id INT, e TEXT UNIQUE)`);
+    await exec(`INSERT INTO t VALUES (1,'a')`);
+    return mustFail(`INSERT INTO t VALUES (2,'a')`);
+  });
+  await t('UNIQUE 允许多个 NULL', async ({ exec, scalar }) => {
+    await exec(`CREATE TABLE t (id INT, e TEXT UNIQUE)`);
+    await exec(`INSERT INTO t VALUES (1,NULL),(2,NULL)`);
+    return eq(await scalar(`SELECT COUNT(*) AS c FROM t`), 2);
+  });
+  await t('删除后主键可复用', async ({ exec, scalar }) => {
+    await exec(`CREATE TABLE t (id INT PRIMARY KEY, v TEXT)`);
+    await exec(`INSERT INTO t VALUES (1,'a')`);
+    await exec(`DELETE FROM t WHERE id = 1`);
+    await exec(`INSERT INTO t VALUES (1,'c')`);
+    return eq(await scalar(`SELECT v FROM t WHERE id = 1`), 'c');
+  });
+
+  console.log(`\n${pass} passed, ${fail} failed`);
+  process.exit(fail === 0 ? 0 : 1);
+})();

package/test/mysql-compat-hijack.test.js

@@ -0,0 +1,87 @@
+/*
+ * require.cache 全局劫持回归测试（P0-1）
+ *
+ * 背景：旧版 enableMySQLCompat() 会遍历 node_modules，把 mysql2 的
+ * require.cache 条目替换成内存兼容层。它靠 process.cwd() 猜路径，
+ * mysql2 通常尚未加载，于是被静默替换 —— 真实 MySQL 连接悄悄改查内存库
+ * 且不报错，表现为「本地跑通、上线全错」。
+ *
+ * 本测试锁定修复后的契约：
+ *   1. 默认调用 enableMySQLCompat() 绝不改动 require.cache
+ *   2. { global: true } 缺少环境变量确认时必须抛错
+ *   3. injectMySQLCompat() 只改写传入对象的引用，不污染全局
+ *   4. 兼容层仍可显式使用
+ */
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+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) : '')); }
+}
+
+// 造一个隔离的假 mysql2，用于验证劫持行为
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'jsql-hijack-'));
+const nm = path.join(tmp, 'node_modules', 'mysql2');
+fs.mkdirSync(nm, { recursive: true });
+fs.writeFileSync(path.join(nm, 'index.js'),
+    'exports.createConnection = function(){ return { __real: true }; };\n' +
+    'exports.createPool = function(){ return { __real: true }; };\n');
+fs.writeFileSync(path.join(nm, 'package.json'),
+    JSON.stringify({ name: 'mysql2', version: '3.0.0', main: 'index.js' }));
+
+const jsql = require('../index.js');
+const mysql2Path = path.join(nm, 'index.js');
+
+try {
+    console.log('--- 1. 默认调用不得劫持 require.cache ---');
+    // 直接检查 index.js 源码不含无条件注入路径
+    const src = fs.readFileSync(path.join(__dirname, '..', 'index.js'), 'utf8');
+    const fnBody = src.slice(src.indexOf('function enableMySQLCompat'));
+    ok('enableMySQLCompat 内部对 global 做了显式判断',
+        /opts\.global\s*!==\s*true/.test(fnBody));
+    ok('危险路径需环境变量确认',
+        /JSQL_NEO_ALLOW_GLOBAL_HIJACK/.test(fnBody));
+
+    console.log('--- 2. 调用后 require.cache 不含被伪造的 mysql2 ---');
+    jsql.enableMySQLCompat();
+    const cached = require.cache[mysql2Path];
+    ok('require.cache 中没有 mysql2 条目', cached === undefined,
+        cached ? '仍被注入' : undefined);
+
+    console.log('--- 3. { global: true } 无环境变量时抛错 ---');
+    let threw = null;
+    try { jsql.enableMySQLCompat({ global: true }); } catch (e) { threw = e; }
+    ok('抛错并说明原因', threw && /require\.cache/.test(threw.message), threw && threw.message);
+    ok('抛错后仍未注入', require.cache[mysql2Path] === undefined);
+
+    console.log('--- 4. 显式注入只影响目标对象 ---');
+    const target = {
+        createConnection: () => ({ __fake: true }),
+        Driver: { createPool: () => ({ __fake: true }) },
+    };
+    const before = target.createConnection;
+    const touched = jsql.injectMySQLCompat(target);
+    ok('injectMySQLCompat 返回 true', touched === true);
+    ok('顶层 createConnection 已被替换', target.createConnection !== before);
+    ok('嵌套 Driver.createPool 已被替换',
+        typeof target.Driver.createPool === 'function' &&
+        target.Driver.createPool !== before);
+    ok('未触碰 require.cache', require.cache[mysql2Path] === undefined);
+
+    console.log('--- 5. 兼容层仍可显式使用 ---');
+    ok('导出 mysql2.createConnection', typeof jsql.mysql2.createConnection === 'function');
+    ok('导出 mysql2.createPool', typeof jsql.mysql2.createPool === 'function');
+    ok('导出 createConnection 快捷方式', typeof jsql.createConnection === 'function');
+    ok('导出 injectMySQLCompat', typeof jsql.injectMySQLCompat === 'function');
+    ok('enableMySQLCompat 默认调用返回兼容层',
+        jsql.enableMySQLCompat() === jsql.mysql2);
+} finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+}
+
+console.log(`\n${pass} passed, ${fail} failed`);
+process.exit(fail === 0 ? 0 : 1);

package/test/native-multi-instance.test.js

@@ -0,0 +1,139 @@
+/*
+ * native 多实例回归测试（P0-2）
+ *
+ * 背景：6.3.3 及以前 native 层是 `thread_local! static ENGINE`，
+ * 整个进程只有一个 HybridEngine。于是：
+ *   new Database(dirA) → new Database(dirB)
+ * 会把 dirA 的所有表 clear() 掉（HybridEngine::open 无条件 clear），
+ * 同进程无法持有两个独立数据库 —— 对自称「嵌入式数据库」是硬伤。
+ *
+ * 6.3.4 改为句柄注册表：jsqlInstanceNew() 分配句柄，
+ * 所有操作走 jsqlXxxH(handle, ...)；旧的 jsqlXxx() 走保留的默认实例 0。
+ *
+ * 若加载的是旧版预编译二进制（无 jsqlInstanceNew），整套多实例断言跳过，
+ * 但向后兼容路径仍需验证。
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const native = require('../native/jsql-neo-native.node');
+const { JSQL } = require('../lib/native_client.js');
+
+let pass = 0, fail = 0, skip = 0;
+function ok(name, cond, extra) {
+    if (cond) { pass++; console.log('[OK]   ' + name); }
+    else { fail++; console.log('[FAIL] ' + name + (extra !== undefined ? ' → ' + JSON.stringify(extra) : '')); }
+}
+function skipTest(name, why) { skip++; console.log('[SKIP] ' + name + ' — ' + why); }
+
+const tmp = (tag) => fs.mkdtempSync(path.join(os.tmpdir(), 'jsql-native-' + tag + '-'));
+const SCHEMA = { id: { type: 'integer', primaryKey: true }, tag: { type: 'string' } };
+const hasHandles = typeof native.jsqlInstanceNew === 'function';
+
+(async () => {
+    console.log('--- 1. native 二进制能力探测 ---');
+    console.log('    句柄版 API: ' + (hasHandles ? '可用' : '不可用（旧版二进制）'));
+    ok('二进制可加载', !!native);
+    ok('旧版无句柄 API 仍存在（向后兼容）', typeof native.jsqlOpen === 'function');
+
+    if (hasHandles) {
+        console.log('--- 2. 两个独立引擎实例互不干扰（核心回归）---');
+        const dA = tmp('A'), dB = tmp('B');
+        const SC = JSON.stringify(SCHEMA);
+        const hA = native.jsqlInstanceNew();
+        native.jsqlOpenH(hA, dA, 'hybrid');
+        native.jsqlCreateTableH(hA, 't', SC);
+        native.jsqlInsertH(hA, 't', JSON.stringify([{ tag: 'A1' }]));
+        native.jsqlInsertH(hA, 't', JSON.stringify([{ tag: 'A2' }]));
+
+        // 关键：此时再开第二个库，旧版会把 A 的表全部清空
+        const hB = native.jsqlInstanceNew();
+        native.jsqlOpenH(hB, dB, 'hybrid');
+        native.jsqlCreateTableH(hB, 't', SC);
+        native.jsqlInsertH(hB, 't', JSON.stringify([{ tag: 'B1' }]));
+
+        ok('两个句柄不同', hA !== hB, { hA, hB });
+        ok('A 的数据未被 B 的 open() 清空', parseInt(native.jsqlCountH(hA, 't'), 10) === 2,
+            native.jsqlCountH(hA, 't'));
+        ok('B 的数据独立', parseInt(native.jsqlCountH(hB, 't'), 10) === 1,
+            native.jsqlCountH(hB, 't'));
+        const aRows = JSON.parse(native.jsqlFindH(hA, 't', '', 10, 0)).map(r => r.fields.tag);
+        const bRows = JSON.parse(native.jsqlFindH(hB, 't', '', 10, 0)).map(r => r.fields.tag);
+        ok('A 数据内容正确', JSON.stringify(aRows) === '["A1","A2"]', aRows);
+        ok('B 数据内容正确', JSON.stringify(bRows) === '["B1"]', bRows);
+
+        console.log('--- 3. 实例计数与销毁 ---');
+        ok('显式实例数为 2', native.jsqlInstanceCount() === 2, native.jsqlInstanceCount());
+        native.jsqlCloseH(hA); native.jsqlCloseH(hB);
+        JSON.parse(native.jsqlInstanceFree(hA));
+        JSON.parse(native.jsqlInstanceFree(hB));
+        ok('free 后实例归零', native.jsqlInstanceCount() === 0, native.jsqlInstanceCount());
+        ok('访问已销毁实例返回错误而非崩溃',
+            /no such database instance/.test(native.jsqlCountH(hA, 't')),
+            native.jsqlCountH(hA, 't'));
+        fs.rmSync(dA, { recursive: true, force: true });
+        fs.rmSync(dB, { recursive: true, force: true });
+    } else {
+        skipTest('多实例句柄测试', '旧版预编译二进制无 jsqlInstanceNew');
+    }
+
+    console.log('--- 4. 默认实例向后兼容（无句柄 API）---');
+    {
+        const dD = tmp('D');
+        const r = JSON.parse(native.jsqlOpen(dD, 'hybrid'));
+        ok('jsqlOpen 走默认实例可用', r.ok === true, r);
+        native.jsqlCreateTable('t', JSON.stringify(SCHEMA));
+        native.jsqlInsert('t', JSON.stringify([{ tag: 'legacy' }]));
+        ok('jsqlCount 默认实例可读', native.jsqlCount('t') === '1', native.jsqlCount('t'));
+        const rows = JSON.parse(native.jsqlFind('t', '', 10, 0)).map(r => r.fields.tag);
+        ok('默认实例数据正确', JSON.stringify(rows) === '["legacy"]', rows);
+        native.jsqlClose();
+        fs.rmSync(dD, { recursive: true, force: true });
+    }
+
+    console.log('--- 5. JS 层：两个 NativeJSQL 并存 ---');
+    {
+        const dA = tmp('jsA'), dB = tmp('jsB');
+        const A = new JSQL({ path: dA, mode: 'hybrid' });
+        const B = new JSQL({ path: dB, mode: 'hybrid' });
+        await A.start();
+        await B.start();
+        if (!hasHandles) {
+            // 旧版二进制没有句柄 API，两个 JS 实例会落到同一个默认实例上，
+            // 此时建同名表必然冲突 —— 只能验证「回退到单实例」这个事实本身。
+            ok('旧版二进制下回退单实例（_handle 为 null）', A._handle === null && B._handle === null);
+            skipTest('JS 层多实例并存测试', '旧版预编译二进制无 jsqlInstanceNew，两实例共享默认实例');
+            await A.stop();
+            await B.stop();
+        } else {
+        ok('JS 层已启用多实例', A._multiInstance === true);
+        ok('两实例句柄不同', A._handle !== B._handle, { a: A._handle, b: B._handle });
+        await A.createTable('t', SCHEMA);
+        await A.insert('t', { tag: 'A1' });
+        await A.insert('t', { tag: 'A2' });
+        await B.createTable('t', SCHEMA);
+        await B.insert('t', { tag: 'B1' });
+
+        const ca = await A.count('t'), cb = await B.count('t');
+        ok('A 保留自己的 2 行', ca === 2, ca);
+        ok('B 有自己的 1 行', cb === 1, cb);
+        const ra = (await A.find('t', {})).map(r => r.tag);
+        ok('A 数据内容正确', JSON.stringify(ra) === '["A1","A2"]', ra);
+
+        await B.createTable('only_b', { id: { type: 'integer', primaryKey: true } });
+        let aSeesB = true;
+        try { await A.find('only_b', {}); aSeesB = false; } catch (e) { aSeesB = true; }
+        ok('A 看不到 B 独有的表', aSeesB);
+
+        await A.stop();
+        await B.stop();
+        ok('stop 释放句柄', A._handle === null && B._handle === null);
+        }   // else: hasHandles
+        fs.rmSync(dA, { recursive: true, force: true });
+        fs.rmSync(dB, { recursive: true, force: true });
+    }
+
+    console.log(`\n${pass} passed, ${fail} failed${skip ? ', ' + skip + ' skipped' : ''}`);
+    process.exit(fail === 0 ? 0 : 1);
+})().catch(e => { console.error('FATAL', e); process.exit(1); });

package/test/readme-audit.test.js

@@ -528,6 +528,31 @@ async function main() {
     ok('null bulk $-1', JSON.stringify((p('*2\r\n$3\r\nGET\r\n$-1\r\n') || {}).args) === '[null]');
   }
 
+  console.log('--- 版本号一致性（package.json 是唯一真相）---');
+  {
+    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
+    const raw = fs.readFileSync(path.join(__dirname, '..', 'README.md'), 'utf8');
+    const v = pkg.version;
+    ok('package.json 版本号格式合法', /^\d+\.\d+\.\d+$/.test(v), v);
+
+    // README 头部横幅必须与 package.json 一致
+    const banner = raw.match(/^> \*\*v(\d+\.\d+\.\d+)\*\*/m);
+    ok('README 顶部版本横幅与 package.json 一致', banner && banner[1] === v,
+      banner ? `README=${banner[1]} package=${v}` : '未找到顶部横幅');
+
+    // 所有 "jsql-neo vX.Y.Z" / "文档版本：vX.Y.Z" 形式的版本声明都必须等于当前版本
+    const claims = [...raw.matchAll(/(?:jsql-neo v|文档版本：v|ver=)(\d+\.\d+\.\d+)/g)]
+      .map(m => m[1]);
+    const stale = [...new Set(claims.filter(c => c !== v))];
+    ok('README 无陈旧版本号声明', stale.length === 0, stale);
+
+    // index.js 头部注释也必须同步
+    const idx = fs.readFileSync(path.join(__dirname, '..', 'index.js'), 'utf8');
+    const hdr = idx.match(/JSQL-NEO v(\d+\.\d+\.\d+)/);
+    ok('index.js 头部版本注释与 package.json 一致', hdr && hdr[1] === v,
+      hdr ? `index.js=${hdr[1]} package=${v}` : '未找到版本注释');
+  }
+
   console.log(`\n${pass} passed, ${fail} failed`);
   process.exit(fail === 0 ? 0 : 1);
 }

package/test/sql-parser.test.js

@@ -584,6 +584,195 @@ const rowsOf = (r) => (Array.isArray(r) ? r[0] : r).rows;
     ok('分组 + ORDER BY + LIMIT 只返回 1 行', lim.rows.length === 1 && lim.rows[0][0] === 'ops', lim.rows);
   }
 
+  /* ---- 括号分组后接运算符：曾报 Unexpected token '*' ---- */
+  console.log('\n--- BUG 修复: 括号分组参与后续运算 ---');
+  {
+    const run = async (sql) => executeSQL(engine, sql, OPTS);
+    // parseNot 的括号分组分支：解析到 ')' 就闭合返回，运算符留在流里
+    const cases = [
+      ['SELECT (1+2)*3 AS v', 9],
+      ['SELECT (3)*4 AS v', 12],
+      ['SELECT (1+2)*(3+4) AS v', 21],
+      ['SELECT (1+2)/2 AS v', 1.5],
+      ['SELECT 10-(2+3) AS v', 5],
+      ['SELECT (2+3)%2 AS v', 1],
+      ['SELECT (1+2)+3 AS v', 6],
+      ['SELECT ((1+2))*3 AS v', 9],      // 嵌套括号
+      ['SELECT (1+2) AS v', 3],         // 无运算符（回归对照）
+      ['SELECT 2*(3+4) AS v', 14],       // ( 在右操作数位置（回归对照）
+    ];
+    for (const [sql, expect] of cases) {
+      let got = null, err = null;
+      try { got = (await run(sql)).rows[0][0]; } catch (e) { err = e; }
+      ok(`${sql} = ${expect}`, err === null && got === expect,
+        err ? String(err.message || err) : got);
+    }
+
+    // WHERE 里的括号同样要能参与比较
+    const w = await run(`SELECT name FROM emp WHERE (sal + 100) > 350 ORDER BY sal DESC`);
+    ok('WHERE (sal+100) > 350 括号参与比较',
+      w.rows.length === 2 && w.rows[0][0] === 'c' && w.rows[1][0] === 'd', w.rows);
+  }
+
+  /* ---- 聚合参与算术：SUM(x)/COUNT(*) 这类写法曾直接报错 ---- */
+  console.log('\n--- BUG 修复: 聚合函数参与算术运算 ---');
+  {
+    const run = async (sql) => executeSQL(engine, sql, OPTS);
+    // mock emp: eng(sal 100,200) / ops(sal 300,300)
+    // 全表 SUM=900 COUNT=4 AVG=225 MIN=100 MAX=300
+    const cases = [
+      ['SELECT SUM(sal)/COUNT(*) AS avg FROM emp', 225],   // 算平均值的标准写法
+      ['SELECT SUM(sal)-MIN(sal) AS range FROM emp', 800], // 极差
+      ['SELECT MAX(sal)*2 AS m FROM emp', 600],
+      ['SELECT SUM(sal)+1 AS s FROM emp', 901],
+      ['SELECT COUNT(*)*100 AS c FROM emp', 400],
+      ['SELECT SUM(sal)/COUNT(*) FROM emp', 225],         // 无别名
+    ];
+    for (const [sql, expect] of cases) {
+      let got = null, err = null;
+      try { got = (await run(sql)).rows[0][0]; } catch (e) { err = e; }
+      ok(`${sql} = ${expect}`, err === null && got === expect,
+        err ? String(err.message || err) : got);
+    }
+
+    // 分组场景：分组路径也要能算 SUM/COUNT
+    const g = await run(`SELECT dept, SUM(sal)/COUNT(*) AS avg FROM emp GROUP BY dept ORDER BY avg DESC`);
+    ok('分组 + SUM/COUNT 每组各自的平均',
+      g.rows.length === 2 && g.rows[0][0] === 'ops' && g.rows[0][1] === 300
+      && g.rows[1][1] === 150, g.rows);
+
+    // 与其它聚合混用不能互相破坏
+    const m = await run(`SELECT SUM(sal)/COUNT(*) AS avg, MAX(sal) AS mx, MIN(sal) AS mn FROM emp`);
+    ok('SUM/COUNT 与 MAX/MIN 并存', m.rows[0][0] === 225 && m.rows[0][1] === 300 && m.rows[0][2] === 100, m.rows);
+
+    // 原有路径回归对照（不带运算符）
+    const s = await run(`SELECT SUM(sal) AS s, COUNT(*) AS c, AVG(sal) AS a FROM emp`);
+    ok('SUM/COUNT/AVG 单独使用不受影响', s.rows[0][0] === 900 && s.rows[0][1] === 4 && s.rows[0][2] === 225, s.rows);
+  }
+
+  /* ---- TIMESTAMPDIFF 整月差：曾按日历月差高估 ---- */
+  console.log('\n--- BUG 修复: TIMESTAMPDIFF 整月差语义 ---');
+  {
+    const run = async (sql) => executeSQL(engine, sql, OPTS);
+    // MySQL：先算日历月差，再按「结束日的日 < 起始日的日」退一档。
+    // 只算日历月差会高估，且 YEAR 同样受影响。
+    const cases = [
+      // [SQL 片段, 期望, 描述]
+      [`TIMESTAMPDIFF(MONTH,'2026-01-31','2026-03-01')`, 1, '月末出发不足整月'],
+      [`TIMESTAMPDIFF(MONTH,'2026-01-15','2026-03-14')`, 1, '差一月零29天不满两月'],
+      [`TIMESTAMPDIFF(MONTH,'2026-01-01','2026-03-01')`, 2, '月初对齐'],
+      [`TIMESTAMPDIFF(MONTH,'2026-01-15','2026-03-15')`, 2, '同日对齐'],
+      [`TIMESTAMPDIFF(YEAR,'2020-06-15','2026-06-14')`, 5, 'YEAR 差一天不满整年'],
+      [`TIMESTAMPDIFF(YEAR,'2020-06-15','2026-06-15')`, 6, 'YEAR 整年'],
+      [`TIMESTAMPDIFF(QUARTER,'2026-01-01','2026-07-01')`, 2, 'QUARTER 整季'],
+      [`TIMESTAMPDIFF(DAY,'2026-01-01','2026-03-01')`, 59, 'DAY 不受影响'],
+    ];
+    for (const [expr, expect, desc] of cases) {
+      let got = null, err = null;
+      try { got = (await run(`SELECT ${expr} AS v`)).rows[0][0]; } catch (e) { err = e; }
+      ok(`${desc}: ${expr} = ${expect}`, err === null && got === expect,
+        err ? String(err.message || err) : got);
+    }
+  }
+
+  /* ---- 隐式类型转换：+ 必须是算术而非字符串拼接 ---- */
+  console.log('\n--- BUG 修复: 算术运算中的隐式类型转换 ---');
+  {
+    const run = async (sql) => executeSQL(engine, sql, OPTS);
+    // 语义已用 Python sqlite3 实测核对：'5'+5=10、'abc'+1=1、'a'+'b'=0
+    const cases = [
+      [`SELECT '5' + 5 AS v`, 10, '数字字符串 + 数字'],
+      [`SELECT 5 + '5' AS v`, 10, '数字 + 数字字符串'],
+      [`SELECT '5' + '5' AS v`, 10, '两个数字字符串'],
+      [`SELECT '2.5' * 2 AS v`, 5, '数字字符串乘法'],
+      [`SELECT '10' - 4 AS v`, 6, '数字字符串减法'],
+      [`SELECT 'abc' + 1 AS v`, 1, '非数字按 0（MySQL/SQLite 语义）'],
+      [`SELECT 'a' + 'b' AS v`, 0, '两侧都非数字返 0'],
+      [`SELECT 1 + 2 AS v`, 3, '纯数字回归对照'],
+    ];
+    for (const [sql, expect, desc] of cases) {
+      let got = null, err = null;
+      try { got = (await run(sql)).rows[0][0]; } catch (e) { err = e; }
+      ok(`${desc}: ${sql} = ${expect}`, err === null && got === expect,
+        err ? String(err.message || err) : got);
+    }
+
+    // CAST(... AS SIGNED) 是 MySQL 整型别名，此前未列入整型分支，
+    // 导致 CAST('12abc' AS SIGNED) 原样返回字符串
+    const cast = [
+      [`SELECT CAST('12abc' AS SIGNED) AS v`, 12, 'SIGNED 取数字前缀'],
+      [`SELECT CAST('abc' AS SIGNED) AS v`, 0, 'SIGNED 非数字返 0'],
+      [`SELECT CAST(12.9 AS SIGNED) AS v`, 12, 'SIGNED 截断小数'],
+      [`SELECT CAST(12.9 AS INTEGER) AS v`, 12, 'INTEGER 回归对照'],
+    ];
+    for (const [sql, expect, desc] of cast) {
+      let got = null, err = null;
+      try { got = (await run(sql)).rows[0][0]; } catch (e) { err = e; }
+      ok(`${desc}: ${sql} = ${expect}`, err === null && got === expect,
+        err ? String(err.message || err) : got);
+    }
+  }
+
+  /* ---- CASE WHEN 裸值条件 + 补齐缺失的 MySQL 函数 ---- */
+  console.log('\n--- BUG 修复: CASE 裸值条件 / SIGN / TRUNCATE / SUBSTRING_INDEX ---');
+  {
+    const run = async (sql) => executeSQL(engine, sql, OPTS);
+    const one = async (sql) => (await run(sql)).rows[0][0];
+
+    // 搜索形式 CASE 的条件可能是裸值/裸列，此前 parseComparison 只收比较式
+    const caseCases = [
+      [`SELECT CASE WHEN 1 THEN 'a' ELSE 'b' END AS v`, 'a', 'CASE WHEN 裸数字'],
+      [`SELECT CASE WHEN 0 THEN 'a' ELSE 'b' END AS v`, 'b', 'CASE WHEN 假'],
+      [`SELECT CASE WHEN NULL THEN 'a' ELSE 'b' END AS v`, 'b', 'CASE WHEN NULL 走 ELSE'],
+      [`SELECT CASE WHEN 1=1 THEN 'a' ELSE 'b' END AS v`, 'a', 'CASE WHEN 比较式'],
+      [`SELECT CASE WHEN 1 IN (1,2) THEN 'y' ELSE 'n' END AS v`, 'y', 'CASE WHEN IN'],
+      [`SELECT CASE 2 WHEN 2 THEN 'y' ELSE 'n' END AS v`, 'y', 'CASE 简单形式'],
+    ];
+    for (const [sql, expect, desc] of caseCases) {
+      let got = null, err = null;
+      try { got = await one(sql); } catch (e) { err = e; }
+      ok(`${desc}`, err === null && got === expect, err ? String(err.message || err) : got);
+    }
+
+    // 缺失的 MySQL 函数
+    const fnCases = [
+      ['SIGN(-9)', -1, 'SIGN 负'], ['SIGN(9)', 1, 'SIGN 正'], ['SIGN(0)', 0, 'SIGN 零'],
+      ['TRUNCATE(3.987,2)', 3.98, 'TRUNCATE 截断而非四舍五入'],
+      ['TRUNCATE(-3.987,2)', -3.98, 'TRUNCATE 负数'],
+      [`SUBSTRING_INDEX('a.b.c','.',2)`, 'a.b', 'SUBSTRING_INDEX 取左'],
+      [`SUBSTRING_INDEX('a.b.c','.',-1)`, 'c', 'SUBSTRING_INDEX 取右'],
+      [`SUBSTRING_INDEX('a.b.c','.',0)`, '', 'SUBSTRING_INDEX 取 0 段'],
+    ];
+    for (const [expr, expect, desc] of fnCases) {
+      let got = null, err = null;
+      try { got = await one(`SELECT ${expr} AS v`); } catch (e) { err = e; }
+      ok(`${desc}: ${expr} = ${JSON.stringify(expect)}`, err === null && got === expect,
+        err ? String(err.message || err) : got);
+    }
+  }
+
+  /* ---- 列级 CHECK 约束：此前直接报 CREATE TABLE 语法错误 ---- */
+  console.log('\n--- BUG 修复: 列级 CHECK 约束解析 ---');
+  {
+    // 表级 CHECK 早已能解析（同样只是跳过），列级却会报
+    //   Expected ',' or ')' in CREATE TABLE, got 'CHECK'
+    // 因为 parseColumnDef 的 default 分支直接 return def，把 CHECK 留在流里。
+    // CHECK 刻意不在 KEYWORDS 里（避免影响同名标识符），要用 isWord 匹配。
+    const ddls = [
+      `CREATE TABLE ck1 (a INT CHECK(a > 0))`,
+      `CREATE TABLE ck2 (a INT CHECK(a > 0), b TEXT)`,
+      `CREATE TABLE ck3 (a INT NOT NULL CHECK(a > 0))`,
+      `CREATE TABLE ck4 (a TEXT, b INT CHECK(b > 0))`,
+      `CREATE TABLE ck5 (a INT, CHECK(a > 0))`,       // 表级（回归对照）
+      `CREATE TABLE ck6 (a INT UNIQUE CHECK(a > 0))`,
+    ];
+    for (const ddl of ddls) {
+      let err = null;
+      try { parseSQL(ddl); } catch (e) { err = e; }
+      ok(`可解析：${ddl}`, err === null, err ? String(err.message || err) : '');
+    }
+  }
+
   console.log(`\n${pass} passed, ${fail} failed`);
   process.exit(fail === 0 ? 0 : 1);
 })();