jsql-neo 6.3.6 → 6.3.10

package/lib/sqlite_compat.js

@@ -81,6 +81,7 @@ class Database {
   close() {
     if (!this.open) return;
     try {
+      // P3-12: close() 不等 worker 保存完——显式等待保存完成
       this._sync('close', []);
     } finally {
       this.open = false;
@@ -285,7 +286,7 @@ class Statement {
 
   run(...params) {
     const r = this._call('run', params.length > 0 ? params : undefined);
-    return r;
+    return { changes: r && r.affectedRows, lastInsertRowid: r && r.insertId, _stmt: this };
   }
 
   get(...params) {

package/lib/sqlite_worker.js

@@ -97,7 +97,8 @@ function cleanResult(r) {
     if (v instanceof Date) out[k] = v.toISOString();
     else if (v === undefined) out[k] = null;
     else if (typeof v === 'object' && v !== null && !Array.isArray(v)) {
-      // 仅保留可 JSON 化的值（防止 Table/内部对象循环引用）
+      // P3-14: 双次 stringify 检查可能导致某些值被错误地过滤
+      // 只检查一次 stringify 是否成功，然后保留原值
       try { JSON.stringify(v); out[k] = v; } catch (e) { out[k] = null; }
     } else out[k] = v;
   }
@@ -123,9 +124,14 @@ async function handleOp(op, args) {
     }
     case 'run': {
       const r = await executeStatement(args[0], args[1]);
+      // P3-13: 非 insert 操作不应回退到上次 insertId
+      const lastId = r && r.type === 'insert' ? Number(r.insertId || 0) : 0;
+      if (r && r.type === 'insert' && r.insertId !== undefined && r.insertId !== null) {
+        _lastInsertId = Number(r.insertId);
+      }
       result = {
         changes: r ? (r.affectedRows || 0) : 0,
-        lastInsertRowid: r && r.type === 'insert' ? Number(r.insertId || 0) : _lastInsertId,
+        lastInsertRowid: lastId,
       };
       break;
     }

package/lib/table.js

@@ -122,7 +122,7 @@ class Table {
         };
         this._softDelete = false;
         this._computedFields = {};
-        this._btreesDirty = false;
+
 
         this._primaryKey = null;
         this._pkIndex = null;
@@ -283,6 +283,13 @@ class Table {
                 }
                 if (def.check && data[field] !== undefined && !def.check(data[field], data)) throw createError('ER_CHECK_CONSTRAINT', this._name + '.' + field);
             }
+            // 主键唯一性检查（主键可能不在 _cachedUniqueFields 中）
+            if (this._primaryKey && data[this._primaryKey] !== undefined && data[this._primaryKey] !== null) {
+                const pkVal = data[this._primaryKey];
+                if (this._pkIndex && this._pkIndex.has(pkVal)) {
+                    throw createError('ER_DUP_ENTRY', String(pkVal), this._primaryKey);
+                }
+            }
             for (const fk of foreignKeys) {
                 if (data[fk.field] !== undefined && data[fk.field] !== null) {
                     const refTable = this._resolveTable(fk.table);
@@ -303,7 +310,11 @@ class Table {
             this._rows.push(Object.assign({}, data));
             if (this._pkIndex && this._primaryKey) {
                 const pkVal = data[this._primaryKey];
-                if (pkVal !== undefined && pkVal !== null) this._pkIndex.set(pkVal, rowIdx);
+                if (pkVal !== undefined && pkVal !== null) {
+                    // P1-1: insertMany 主键重复检查
+                    if (this._pkIndex.has(pkVal)) throw createError('ER_DUP_ENTRY', String(pkVal), this._primaryKey);
+                    this._pkIndex.set(pkVal, rowIdx);
+                }
             }
             for (const [field, tree] of Object.entries(this._btrees)) {
                 const val = data[field];
@@ -369,7 +380,6 @@ class Table {
             }
             return null;
         }
-        this._ensureBTrees();
         if (this._btrees[this._primaryKey]) {
             const indices = this._btrees[this._primaryKey].search(id);
             if (indices.length > 0) {
@@ -442,7 +452,6 @@ class Table {
         if (this._pkIndex) {
             rowIndex = this._pkIndex.get(id);
         } else {
-            this._ensureBTrees();
             if (this._btrees[this._primaryKey]) {
                 const indices = this._btrees[this._primaryKey].search(id);
                 rowIndex = indices.length > 0 ? indices[0] : undefined;
@@ -539,7 +548,6 @@ class Table {
         if (this._pkIndex) {
             rowIndex = this._pkIndex.get(id);
         } else {
-            this._ensureBTrees();
             if (this._btrees[this._primaryKey]) {
                 const indices = this._btrees[this._primaryKey].search(id);
                 rowIndex = indices.length > 0 ? indices[0] : undefined;
@@ -587,8 +595,28 @@ class Table {
     }
 
     removeSoft(query = {}) {
-        this._softDelete = true;
-        return this.remove(query);
+        if (!this._softDelete) throw createError('ER_NOT_SUPPORTED', 'Soft delete is not enabled');
+        const matched = this._applyFilterOptimized(this._getVisibleRows(), query);
+        let count = 0;
+        const now = new Date().toISOString();
+        for (const row of matched) {
+            const index = this._rows.indexOf(row);
+            if (index === -1) continue;
+            this._removeFromIndexes(index, row);
+            row._deleted = true;
+            row._deletedAt = now;
+            this._addToIndexes(index, row);
+            count++;
+        }
+        if (count > 0) {
+            this._dirty = true;
+            this._db._markDirty(this._name);
+            for (const hook of this._hooks.afterRemove) {
+                hook(query, count);
+            }
+            this._db._emitChange('remove', this._name, { query, count, soft: true });
+        }
+        return count;
     }
 
     _findRowIndex(id) {
@@ -628,6 +656,7 @@ class Table {
         }
         this._indexes = {};
         this._autoIncrement = 0;
+        // P1-13: truncate 不应重置软删除模式——保留原值
         this._dirty = true;
         this._db._markDirty(this._name);
         return count;
@@ -640,6 +669,10 @@ class Table {
     addColumn(field, definition) {
         if (this._schema[field]) throw createError('ER_DUP_FIELDNAME', field);
         this._schema[field] = definition;
+        // P1-14: 更新缓存字段列表，使新列的 unique/required 约束生效
+        if (!this._cachedSchemaFields.includes(field)) this._cachedSchemaFields.push(field);
+        if (definition.unique && !this._cachedUniqueFields.includes(field)) this._cachedUniqueFields.push(field);
+        if (definition.required && !this._cachedRequiredFields.includes(field)) this._cachedRequiredFields.push(field);
         if (definition.default !== undefined) {
             this._defaults[field] = definition.default;
             for (const row of this._rows) {
@@ -666,6 +699,15 @@ class Table {
             this._btrees[field] = new BTree(64, true);
             this._rebuildBTree(field);
         }
+        // P1-8: 添加主键列时设置 _primaryKey 并重建 pkIndex
+        if (definition.primaryKey) {
+            this._primaryKey = field;
+            if (this._pkIndex) this._pkIndex.clear();
+            for (let i = 0; i < this._rows.length; i++) {
+                const val = this._rows[i][field];
+                if (val !== undefined && val !== null) this._pkIndex.set(val, i);
+            }
+        }
         this._dirty = true;
         this._db._markDirty(this._name);
         return this;
@@ -684,7 +726,11 @@ class Table {
         for (const row of this._rows) {
             delete row[field];
         }
-        if (this._primaryKey === field) this._primaryKey = null;
+        // P1-8: 删除主键列时清空 pkIndex
+        if (this._primaryKey === field) {
+            this._primaryKey = null;
+            if (this._pkIndex) this._pkIndex.clear();
+        }
         if (this._autoIncrementField === field) this._autoIncrementField = null;
         this._dirty = true;
         this._db._markDirty(this._name);
@@ -703,6 +749,11 @@ class Table {
         if (this._btrees[oldName]) {
             this._btrees[newName] = this._btrees[oldName];
             delete this._btrees[oldName];
+            this._btrees[newName].clear();
+            for (let i = 0; i < this._rows.length; i++) {
+                const val = this._rows[i][newName];
+                if (val !== undefined && val !== null) this._btrees[newName].insert(val, i);
+            }
         }
         for (const row of this._rows) {
             row[newName] = row[oldName];
@@ -721,9 +772,13 @@ class Table {
         if (definition.default !== undefined) this._defaults[field] = definition.default;
         this._checkConstraints = this._checkConstraints.filter(c => c.field !== field);
         if (definition.check) this._checkConstraints.push({ field, fn: definition.check });
-        if (definition.primaryKey || definition.unique) {
-            if (!this._btrees[field]) this._btrees[field] = new BTree(64, true);
-            this._rebuildBTree(field);
+        if (definition.primaryKey !== undefined || definition.unique !== undefined) {
+            if (definition.primaryKey || definition.unique) {
+                if (!this._btrees[field]) this._btrees[field] = new BTree(64, true);
+                this._rebuildBTree(field);
+            } else {
+                delete this._btrees[field];
+            }
         }
         this._dirty = true;
         this._db._markDirty(this._name);
@@ -817,20 +872,6 @@ class Table {
         }
     }
 
-    _ensureBTrees() {
-        if (!this._btreesDirty) return;
-        this._btreesDirty = false;
-        for (const field of Object.keys(this._btrees)) {
-            this._btrees[field].clear();
-        }
-        for (let i = 0; i < this._rows.length; i++) {
-            const row = this._rows[i];
-            for (const [field, tree] of Object.entries(this._btrees)) {
-                const v = row[field];
-                if (v !== undefined && v !== null) tree.insert(v, i);
-            }
-        }
-    }
 
     _rebuildAllBTrees() {
         for (const field of Object.keys(this._btrees)) {
@@ -881,7 +922,6 @@ class Table {
     }
 
     _applyFilterOptimized(rows, query) {
-        this._ensureBTrees();
         for (const [field, condition] of Object.entries(query)) {
             if (field === '$or' || field === '$and' || field === '$not') continue;
             if (typeof condition !== 'object' || condition === null || Array.isArray(condition) || condition instanceof RegExp) {
@@ -940,6 +980,8 @@ class Table {
     _applyFilter(rows, query) {
         const result = [];
         for (let i = 0; i < rows.length; i++) {
+            // 软删除行不应出现在任何查询结果中
+            if (this._softDelete && rows[i]._deleted) continue;
             if (this._matchRow(rows[i], query)) {
                 result.push(rows[i]);
             }

package/lib/tui.js

@@ -13,7 +13,7 @@ const os = require('os');
 const Database = require('./database');
 const { executeSQL } = require('./sql');
 
-const HISTORY_FILE = path.join(os.homedir(), '.jsql-history');
+const HISTORY_FILE = path.join(os.homedir(), '.jsql-history.' + process.pid);
 const MAX_HISTORY = 500;
 
 /* ---------- ANSI helpers ---------- */

package/lib/web_ui.js

@@ -141,9 +141,17 @@ class WebUI {
     return fs.readdirSync(this.dataDir)
       .filter(f => f.endsWith('.json'))
       .map(f => {
-        let tables = 0;
-        try { tables = Object.keys(JSON.parse(fs.readFileSync(path.join(this.dataDir, f), 'utf8')).__schema__ || {}).length; } catch (_) {}
-        return { name: f.slice(0, -5), tables };
+        try {
+          const stat = fs.statSync(path.join(this.dataDir, f));
+          // 只读前 4KB：schema 头部包含 __schema__ 定义，尾部数据不需要
+          const fd = fs.openSync(path.join(this.dataDir, f), 'r');
+          const buf = Buffer.alloc(4096);
+          fs.readSync(fd, buf, 0, 4096, 0);
+          fs.closeSync(fd);
+          const match = buf.toString('utf8').match(/"__schema__"\s*:\s*\{([^}]*)\}/);
+          const tables = match ? (match[1].match(/"/g) || []).length / 2 : 0;
+          return { name: f.slice(0, -5), tables };
+        } catch (_) { return { name: f.slice(0, -5), tables: 0 }; }
       });
   }
 
@@ -188,12 +196,20 @@ class WebUI {
         res.writeHead(204, h);
         return res.end();
       }
-      if (this.authToken && url.pathname.startsWith('/api/')) {
-        const provided = req.headers.authorization || '';
-        const token = provided.startsWith('Bearer ') ? provided.slice(7) : '';
-        if (token !== this.authToken) {
+      // API 认证：必须设置 authToken（从环境变量或构造选项）。
+      // 仅当显式 noAuth: true 时允许无认证访问（仅本地开发用）。
+      if (url.pathname.startsWith('/api/')) {
+        if (!this.noAuth && !this.authToken) {
           res.writeHead(401, { 'Content-Type': 'application/json' });
-          return res.end(JSON.stringify({ ok: false, error: 'unauthorized' }));
+          return res.end(JSON.stringify({ ok: false, error: 'API auth not configured' }));
+        }
+        if (this.authToken) {
+          const provided = req.headers.authorization || '';
+          const token = provided.startsWith('Bearer ') ? provided.slice(7) : '';
+          if (token !== this.authToken) {
+            res.writeHead(401, { 'Content-Type': 'application/json' });
+            return res.end(JSON.stringify({ ok: false, error: 'unauthorized' }));
+          }
         }
       }
       if (url.pathname === '/api/databases' && req.method === 'GET') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsql-neo",
-  "version": "6.3.6",
+  "version": "6.3.10",
   "description": "JSQL-NEO — Rust-powered embedded database with WASM, REST API, B-Tree indexes, WAL, crash recovery",
   "main": "index.js",
   "types": "index.d.ts",
@@ -51,10 +51,17 @@
     "test:btree": "node test/btree.test.js",
     "test:native": "node test/native.test.js",
     "test:regress": "node test/regress-5.1.0.js",
-    "test:all": "node test/smoke.js && node test/sql-parser.test.js && node test/readme-audit.test.js && node test/native.test.js && node test/native-multi-instance.test.js && node test/wal-recovery.test.js && node test/mysql-compat-hijack.test.js && node test/wasm.test.js && node test/coverage.js && node test/regress-5.1.0.js && node test/join.test.js && node test/btree.test.js && node test/dml-constraints.test.js",
+    "test:all": "node test/smoke.js && node test/sql-parser.test.js && node test/readme-audit.test.js && node test/native.test.js && node test/native-multi-instance.test.js && node test/wal-recovery.test.js && node test/mysql-compat-hijack.test.js && node test/wasm.test.js && node test/coverage.js && node test/regress-5.1.0.js && node test/join.test.js && node test/btree.test.js && node test/dml-constraints.test.js && node test/savepoint.test.js && node test/alter-table.test.js && node test/null-semantics.test.js && node test/identifier-keywords.test.js && node test/recursive-cte.test.js && node test/index-ddl.test.js",
     "test:coverage": "c8 --all --include='lib/**' --exclude='lib/web_ui.js' --reporter=text --reporter=lcov node test/coverage.js",
     "test:orms": "node examples/orms/run-all.js",
-    "test:dml": "node test/dml-constraints.test.js"
+    "test:dml": "node test/dml-constraints.test.js",
+    "test:cte": "node test/recursive-cte.test.js",
+    "test:index": "node test/index-ddl.test.js",
+    "test:mongo": "node test/mongo-group.test.js",
+    "test:savepoint": "node test/savepoint.test.js",
+    "test:alter": "node test/alter-table.test.js",
+    "test:ident": "node test/identifier-keywords.test.js",
+    "test:null": "node test/null-semantics.test.js"
   },
   "keywords": [
     "database",

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