jsql-neo 6.3.5 → 6.3.10

package/test/alter-table.test.js

@@ -0,0 +1,289 @@
+/*
+ * ALTER TABLE 补全测试（RENAME TO / RENAME COLUMN / DROP INDEX）。
+ *
+ * 这三条此前各自以不同方式「看起来成功」：
+ *   - ALTER ... RENAME TO t2   → 返回 ok:true，但表名根本没变
+ *   - ALTER ... RENAME COLUMN  → 解析期就报 "Expected table name, got 'COLUMN'"
+ *   - ALTER ... DROP INDEX idx → 返回 ok:true，索引还在
+ *   - ALTER ... ADD FOREIGN KEY→ 返回 ok:true，什么都没加
+ * 执行器里这三类 op 落在同一个 `default: break`，也就是静默无操作 ——
+ * 比报错更糟，调用方会以为改成功了。
+ *
+ * 现在：能做的真做，做不到的明确报错（外键在这个引擎里没实现）。
+ */
+const fs = require('fs');
+const os = require('os');
+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) : ''); }
+}
+const eq = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+
+async function t(name, fn) {
+  const db = new Database(':memory:');
+  const exec = (sql) => executeSQL(db, sql, OPTS);
+  const rows = async (sql) => (await exec(sql)).rows;
+  const mustFail = async (sql) => {
+    try { await exec(sql); return false; } catch (_) { return true; }
+  };
+  try {
+    const r = await fn({ db, exec, rows, mustFail });
+    ok(name, r === undefined ? true : !!r);
+  } catch (e) {
+    ok(name, false, e.message);
+  }
+}
+
+(async () => {
+  console.log('\n--- RENAME TO ---');
+  await t('改名真的生效，数据不丢', async ({ db, exec, rows }) => {
+    await exec('CREATE TABLE t (id INT PRIMARY KEY, v TEXT)');
+    await exec("INSERT INTO t VALUES (1,'x')");
+    await exec('ALTER TABLE t RENAME TO t2');
+    const tables = (await db.getTables()).slice().sort();
+    return eq(tables, ['t2']) && eq(await rows('SELECT id, v FROM t2'), [[1, 'x']]);
+  });
+
+  await t('旧表名不再可用，新名字可取属性', async ({ db, exec, rows, mustFail }) => {
+    await exec('CREATE TABLE t (id INT PRIMARY KEY)');
+    await exec('ALTER TABLE t RENAME TO t2');
+    const oldGone = await mustFail('SELECT * FROM t');
+    return oldGone && !!db.t2 && db.t === undefined && rows('SELECT * FROM t2') !== null;
+  });
+
+  await t('RENAME AS 也支持', async ({ db, exec }) => {
+    await exec('CREATE TABLE t (id INT PRIMARY KEY)');
+    await exec('ALTER TABLE t RENAME AS t3');
+    return eq((await db.getTables()).slice().sort(), ['t3']);
+  });
+
+  await t('改成已存在的表名 → 报错', async ({ db, exec, mustFail }) => {
+    await exec('CREATE TABLE a (id INT PRIMARY KEY)');
+    await exec('CREATE TABLE b (id INT PRIMARY KEY)');
+    const bad = await mustFail('ALTER TABLE a RENAME TO b');
+    return bad && eq((await db.getTables()).slice().sort(), ['a', 'b']);
+  });
+
+  await t('改名不存在的表 → 报错', async ({ exec, mustFail }) => {
+    return mustFail('ALTER TABLE nope RENAME TO x');
+  });
+
+  await t('改成同名 = 无事发生，不算错', async ({ db, exec }) => {
+    await exec('CREATE TABLE t (id INT PRIMARY KEY)');
+    await exec('ALTER TABLE t RENAME TO t');
+    return eq((await db.getTables()).slice().sort(), ['t']);
+  });
+
+  await t('改名后主键/自增/唯一约束仍然生效', async ({ exec, rows, mustFail }) => {
+    await exec('CREATE TABLE t (id INTEGER PRIMARY KEY AUTOINCREMENT, e TEXT UNIQUE)');
+    await exec("INSERT INTO t (e) VALUES ('a')");
+    await exec('ALTER TABLE t RENAME TO t2');
+    await exec("INSERT INTO t2 (e) VALUES ('b')");
+    const dupPk = await mustFail('INSERT INTO t2 (id, e) VALUES (1, \'c\')');
+    const dupUniq = await mustFail("INSERT INTO t2 (e) VALUES ('a')");
+    const all = await rows('SELECT id, e FROM t2 ORDER BY id');
+    return eq(all, [[1, 'a'], [2, 'b']]) && dupPk && dupUniq;
+  });
+
+  console.log('\n--- RENAME COLUMN ---');
+  await t('改列名真的生效，数据不丢', async ({ exec, rows }) => {
+    await exec('CREATE TABLE t (id INT PRIMARY KEY, a TEXT)');
+    await exec("INSERT INTO t VALUES (1,'x')");
+    await exec('ALTER TABLE t RENAME COLUMN a TO name');
+    return eq(await rows('SELECT id, name FROM t'), [[1, 'x']]);
+  });
+
+  await t('列的先后顺序保持不变', async ({ exec }) => {
+    await exec('CREATE TABLE t (id INT PRIMARY KEY, a TEXT, b TEXT, c TEXT)');
+    await exec('ALTER TABLE t RENAME COLUMN b TO b2');
+    // 直接改 schema 的键会把这一列挪到末尾，SELECT * 的列序就变了
+    return eq((await exec('SELECT * FROM t')).columns, ['id', 'a', 'b2', 'c']);
+  });
+
+  await t('列级约束（NOT NULL / UNIQUE / 主键）跟着走', async ({ exec, mustFail, rows }) => {
+    await exec('CREATE TABLE t (id INT PRIMARY KEY, code TEXT NOT NULL UNIQUE)');
+    await exec("INSERT INTO t VALUES (1,'a')");
+    await exec('ALTER TABLE t RENAME COLUMN code TO code2');
+    const nullBad = await mustFail('INSERT INTO t (id, code2) VALUES (2, NULL)');
+    const dupBad = await mustFail("INSERT INTO t (id, code2) VALUES (3, 'a')");
+    await exec("INSERT INTO t VALUES (4, 'b')");
+    return nullBad && dupBad && eq(await rows('SELECT id, code2 FROM t ORDER BY id'), [[1, 'a'], [4, 'b']]);
+  });
+
+  await t('改列名后自增字段仍认得出来', async ({ exec, rows }) => {
+    await exec('CREATE TABLE t (id INTEGER PRIMARY KEY AUTOINCREMENT, v TEXT)');
+    await exec('ALTER TABLE t RENAME COLUMN id TO sid');
+    await exec("INSERT INTO t (v) VALUES ('a'), ('b')");
+    return eq(await rows('SELECT sid, v FROM t ORDER BY sid'), [[1, 'a'], [2, 'b']]);
+  });
+
+  await t('改列名会同步列上的索引', async ({ exec, rows }) => {
+    await exec('CREATE TABLE t (id INT PRIMARY KEY, a TEXT)');
+    await exec('ALTER TABLE t RENAME COLUMN a TO b');
+    await exec("INSERT INTO t VALUES (1,'x')");
+    // 表对象上的索引是以旧列名建的，改名后按新列名查必须仍然走得到数据
+    return eq(await rows('SELECT id FROM t WHERE b = \'x\''), [[1]]);
+  });
+
+  await t('列不存在 → 报错', async ({ exec, mustFail }) => {
+    await exec('CREATE TABLE t (id INT PRIMARY KEY)');
+    return mustFail('ALTER TABLE t RENAME COLUMN zzz TO yyy');
+  });
+
+  await t('改成已存在的列名 → 报错', async ({ exec, mustFail, rows }) => {
+    await exec('CREATE TABLE t (id INT PRIMARY KEY, a TEXT, b TEXT)');
+    await exec("INSERT INTO t VALUES (1,'x','y')");
+    const bad = await mustFail('ALTER TABLE t RENAME COLUMN b TO a');
+    return bad && eq(await rows('SELECT id, a, b FROM t'), [[1, 'x', 'y']]);
+  });
+
+  await t('RENAME COLUMN 缺 TO → 报错', async ({ exec, mustFail }) => {
+    await exec('CREATE TABLE t (id INT PRIMARY KEY, a TEXT)');
+    return mustFail('ALTER TABLE t RENAME COLUMN a b');
+  });
+
+  await t('改成同名列 = 无事发生', async ({ exec, rows }) => {
+    await exec('CREATE TABLE t (id INT PRIMARY KEY, a TEXT)');
+    await exec("INSERT INTO t VALUES (1,'x')");
+    await exec('ALTER TABLE t RENAME COLUMN a TO a');
+    return eq(await rows('SELECT a FROM t'), [['x']]);
+  });
+
+  console.log('\n--- DROP INDEX / DROP KEY ---');
+  await t('DROP INDEX 真的删掉索引', async ({ db, exec }) => {
+    await exec('CREATE TABLE t (id INT PRIMARY KEY, a TEXT)');
+    await exec('CREATE INDEX idx_a ON t (a)');
+    const before = Object.keys(db.t._indexes).length + Object.keys(db.t._btrees).length;
+    await exec('ALTER TABLE t DROP INDEX idx_a');
+    const after = Object.keys(db.t._indexes).length + Object.keys(db.t._btrees).length;
+    return before > 0 && after < before;
+  });
+
+  await t('DROP KEY 是同一件事的另一种写法', async ({ db, exec }) => {
+    await exec('CREATE TABLE t (id INT PRIMARY KEY, a TEXT)');
+    // 记下建索引前的状态：主键会在 _btrees 里留一个 id 索引，那是该留的
+    const baseline = Object.keys(db.t._indexes).length + Object.keys(db.t._btrees).length;
+    await exec('CREATE INDEX idx_a ON t (a)');
+    const withIndex = Object.keys(db.t._indexes).length + Object.keys(db.t._btrees).length;
+    await exec('ALTER TABLE t DROP KEY idx_a');
+    const after = Object.keys(db.t._indexes).length + Object.keys(db.t._btrees).length;
+    return withIndex > baseline && after === baseline;
+  });
+
+  await t('删索引不影响数据', async ({ exec, rows }) => {
+    await exec('CREATE TABLE t (id INT PRIMARY KEY, a TEXT)');
+    await exec("INSERT INTO t VALUES (1,'x')");
+    await exec('CREATE INDEX idx_a ON t (a)');
+    await exec('ALTER TABLE t DROP INDEX idx_a');
+    return eq(await rows('SELECT id, a FROM t'), [[1, 'x']]);
+  });
+
+  await t('删不存在的索引 → 报错', async ({ exec, mustFail }) => {
+    await exec('CREATE TABLE t (id INT PRIMARY KEY, a TEXT)');
+    return mustFail('ALTER TABLE t DROP INDEX nope');
+  });
+
+  console.log('\n--- 明确报错而不是静默无操作 ---');
+  await t('ADD FOREIGN KEY → 明确报不支持', async ({ exec }) => {
+    await exec('CREATE TABLE t (id INT PRIMARY KEY, a TEXT)');
+    try {
+      await exec('ALTER TABLE t ADD CONSTRAINT fk FOREIGN KEY (a) REFERENCES p(id)');
+      return false;
+    } catch (e) { return /not supported/i.test(e.message) && /foreign key/i.test(e.message); }
+  });
+
+  await t('DROP FOREIGN KEY → 明确报不支持', async ({ exec }) => {
+    await exec('CREATE TABLE t (id INT PRIMARY KEY, a TEXT)');
+    try {
+      await exec('ALTER TABLE t DROP FOREIGN KEY fk');
+      return false;
+    } catch (e) { return /not supported/i.test(e.message) && /foreign key/i.test(e.message); }
+  });
+
+  await t('RENAME INDEX → 明确报不支持并给出替代做法', async ({ exec }) => {
+    await exec('CREATE TABLE t (id INT PRIMARY KEY, a TEXT)');
+    try {
+      await exec('ALTER TABLE t RENAME INDEX i TO j');
+      return false;
+    } catch (e) { return /not supported/i.test(e.message) && /DROP INDEX/i.test(e.message); }
+  });
+
+  console.log('\n--- 多操作与组合 ---');
+  await t('一条语句里多个操作按序执行', async ({ db, exec, rows }) => {
+    await exec('CREATE TABLE t (id INT PRIMARY KEY, a TEXT)');
+    await exec("INSERT INTO t VALUES (1,'x')");
+    await exec('ALTER TABLE t ADD COLUMN b TEXT, RENAME COLUMN a TO a2');
+    const cols = (await exec('SELECT * FROM t')).columns;
+    const r = await rows('SELECT id, a2, b FROM t');
+    return eq(r, [[1, 'x', null]]) && cols.includes('a2') && cols.includes('b');
+  });
+
+  await t('改名后的表可以继续 DDL / DML', async ({ db, exec, rows }) => {
+    await exec('CREATE TABLE t (id INT PRIMARY KEY, v TEXT)');
+    await exec('ALTER TABLE t RENAME TO t2');
+    await exec('ALTER TABLE t2 RENAME COLUMN v TO val');
+    await exec("INSERT INTO t2 VALUES (1,'a')");
+    await exec('CREATE INDEX ix ON t2 (val)');
+    await exec('DELETE FROM t2 WHERE val = \'zzz\'');
+    return eq(await rows('SELECT id, val FROM t2'), [[1, 'a']]);
+  });
+
+  console.log('\n--- 持久化 ---');
+  {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'jsql-alter-'));
+    const file = path.join(dir, 'db.jsql');
+    try {
+      const db = new Database(file, { wal: true, autoSave: false });
+      const exec = (sql) => executeSQL(db, sql, OPTS);
+      await exec('CREATE TABLE t (id INT PRIMARY KEY, a TEXT)');
+      await exec("INSERT INTO t VALUES (1,'x')");
+      await exec('ALTER TABLE t RENAME TO t2');
+      await exec('ALTER TABLE t2 RENAME COLUMN a TO name');
+      await db.save();
+
+      const db2 = new Database(file, { wal: true });
+      const exec2 = (sql) => executeSQL(db2, sql, OPTS);
+      const tables = (await db2.getTables()).slice().sort();
+      const cols = (await exec2('SELECT * FROM t2')).columns;
+      const r = (await exec2('SELECT id, name FROM t2')).rows;
+      ok('重开后表名与列名都保住', eq(tables, ['t2']) && eq(cols, ['id', 'name']) && eq(r, [[1, 'x']]),
+        { tables, cols, r });
+    } catch (e) {
+      ok('重开后表名与列名都保住', false, e.message);
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  }
+
+  console.log('\n--- 目录模式（改名的物理文件也要跟着挪）---');
+  {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'jsql-alterdir-'));
+    try {
+      const db = new Database(dir, { mode: 'disk', autoSave: false });
+      const exec = (sql) => executeSQL(db, sql, OPTS);
+      await exec('CREATE TABLE t (id INT PRIMARY KEY, a TEXT)');
+      await exec("INSERT INTO t VALUES (1,'x')");
+      await exec('ALTER TABLE t RENAME TO t2');
+      const files = fs.readdirSync(dir).filter(f => f.endsWith('.jsql'));
+      const tables = (await db.getTables()).slice().sort();
+      ok('目录模式改名后表列表正确', eq(tables, ['t2']), tables);
+      ok('物理文件名跟着改了', files.some(f => f.includes('t2')) && !files.some(f => /(^|[^2])t\.jsql$/.test(f)), files);
+    } catch (e) {
+      ok('目录模式改名', false, e.message);
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  }
+
+  console.log(`\n${pass} passed, ${fail} failed`);
+  process.exit(fail === 0 ? 0 : 1);
+})().catch(e => { console.error('💥', e); process.exit(1); });

package/test/dml-constraints.test.js

@@ -13,7 +13,7 @@
 const path = require('path');
 
 const ROOT = path.join(__dirname, '..');
-const { Database } = require(path.join(ROOT, 'index.js'));
+const { Database, JSQL, NativeJSQL } = require(path.join(ROOT, 'index.js'));
 const { executeSQL } = require(path.join(ROOT, 'lib/sql.js'));
 
 const OPTS = { safety: false };
@@ -130,6 +130,46 @@ async function t(name, fn) {
     return eq(await rows(`SELECT id, v FROM t ORDER BY id`), [[1, 99], [2, 20]]);
   });
 
+  // 三个 engine 都要拦住 —— 修复曾只加在 lib/database.js，
+  // 而 JSQL（wasm）走 lib/wasm_client.js、NativeJSQL 走 lib/native_client.js，
+  // 各自的 updateById 是独立实现。
+  console.log('\n--- UPDATE 冲突校验：三个 engine 都要拦住 ---');
+  const engines = [
+    ['JSQL(wasm)', () => new JSQL({ mode: 'memory' })],
+    ['NativeJSQL', () => new NativeJSQL({ mode: 'memory' })],
+    ['Database', () => new Database(':memory:')],
+  ];
+  for (const [name, mk] of engines) {
+    await t(`${name} UPDATE 主键冲突 → 报错且数据完好`, async () => {
+      const db = await mk();
+      if (db.start) await db.start();
+      try {
+        const exec = (sql) => executeSQL(db, sql, OPTS);
+        await exec(`CREATE TABLE e (id INT PRIMARY KEY, v INT)`);
+        await exec(`INSERT INTO e VALUES (1,10),(2,20),(3,30)`);
+        let threw = false;
+        try { await exec(`UPDATE e SET id = 1 WHERE id = 2`); } catch (_) { threw = true; }
+        const after = (await exec(`SELECT id, v FROM e ORDER BY id`)).rows;
+        // 改不冲突的值必须仍然可用
+        await exec(`UPDATE e SET id = 9 WHERE id = 2`);
+        const ok = (await exec(`SELECT id FROM e ORDER BY id`)).rows;
+        return threw && eq(after, [[1, 10], [2, 20], [3, 30]]) && eq(ok, [[1], [3], [9]]);
+      } finally { try { await db.stop(); } catch (_) { /* ignore */ } }
+    });
+    await t(`${name} UPDATE UNIQUE 冲突 → 报错`, async () => {
+      const db = await mk();
+      if (db.start) await db.start();
+      try {
+        const exec = (sql) => executeSQL(db, sql, OPTS);
+        await exec(`CREATE TABLE q (id INT PRIMARY KEY, e TEXT UNIQUE)`);
+        await exec(`INSERT INTO q VALUES (1,'a'),(2,'b')`);
+        let threw = false;
+        try { await exec(`UPDATE q SET e = 'a' WHERE id = 2`); } catch (_) { threw = true; }
+        return threw && eq((await exec(`SELECT e FROM q ORDER BY id`)).rows, [['a'], ['b']]);
+      } finally { try { await db.stop(); } catch (_) { /* ignore */ } }
+    });
+  }
+
   console.log('\n--- 既有约束行为回归对照 ---');
   await t('INSERT 主键重复 → 报错', async ({ exec, mustFail }) => {
     await exec(`CREATE TABLE t (id INT PRIMARY KEY)`);

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