jsql-neo 4.4.3 → 4.5.1

package/index.js

@@ -23,6 +23,39 @@ const migrate = require('./lib/migrate');
 const { WebUI } = require('./lib/web_ui');
 const { RedisServer, createRedisServer } = require('./lib/redis_server');
 
+/**
+ * 全局注入：把项目内 `require('mysql2')` 全部替换为 jsql-neo 内存引擎兼容层。
+ * 调用一次后，TypeORM / Drizzle / MikroORM / Kysely 等直接依赖 mysql2 的库
+ * 无需改代码即可享受本地内存速度。
+ */
+function enableMySQLCompat() {
+  const fs = require('fs');
+  const path = require('path');
+  const seen = new Set();
+  const bases = new Set();
+  if (require.main && Array.isArray(require.main.paths)) {
+    for (const p of require.main.paths) bases.add(p);
+  }
+  if (process.env.NODE_PATH) {
+    for (const p of process.env.NODE_PATH.split(path.delimiter)) if (p) bases.add(p);
+  }
+  bases.add(path.join(process.cwd(), 'node_modules'));
+  const inject = (p, mod) => {
+    try {
+      const resolved = p;
+      if (seen.has(resolved)) return;
+      if (!fs.existsSync(resolved)) return;
+      seen.add(resolved);
+      require.cache[resolved] = { exports: mod, id: resolved, filename: resolved, loaded: true, children: [] };
+    } catch (e) { /* ignore */ }
+  };
+  for (const base of bases) {
+    inject(path.join(base, 'mysql2', 'index.js'), mysqlCompat);
+    inject(path.join(base, 'mysql2', 'promise.js'), mysqlCompat);
+  }
+  return mysqlCompat;
+}
+
 module.exports = {
     JSQL: WasmClient.JSQL,
     NativeJSQL: NativeClient.JSQL,
@@ -45,6 +78,8 @@ module.exports = {
     createConnection: mysqlCompat.createConnection,
     createPool: mysqlCompat.createPool,
     mysql: mysqlCompat,
+    mysql2: mysqlCompat,
+    enableMySQLCompat,
     createMysqlServer,
     MysqlServer,
     // 迁移工具: mysqldump 导入 / JSON / CSV

package/lib/database.js

@@ -1142,9 +1142,46 @@ class Database {
     async start() {
         this._runHooks('onStart', []);
         this._emit('start', {});
+        if (this._dirMode && !this._sigInstalled) {
+            this._sigInstalled = true;
+            Database._installSignalHandler(this);
+        }
         return this;
     }
 
+    /**
+     * 进程退出时兜底刷盘：拦截 SIGINT/SIGTERM，同步落盘脏表后再退出。
+     * 使用静态共享 handler，避免多个数据库实例重复注册/互相覆盖。
+     * @private
+     */
+    static _installSignalHandler(db) {
+        if (!Database._signalHandlerInstalled) {
+            Database._signalHandlerInstalled = true;
+            Database._signalDBs = new Set();
+            const handler = (sig) => {
+                for (const d of Database._signalDBs) {
+                    try {
+                        if (d._dirMode) {
+                            if (d._flushTimer) { clearTimeout(d._flushTimer); d._flushTimer = null; }
+                            d._flushDirty();
+                            d._saveMeta();
+                        }
+                    } catch (e) { /* 兜底失败不阻塞退出 */ }
+                }
+                process.exit(128 + (sig === 'SIGINT' ? 2 : 15));
+            };
+            process.on('SIGINT', handler);
+            process.on('SIGTERM', handler);
+            Database._signalHandler = handler;
+        }
+        Database._signalDBs.add(db);
+    }
+
+    /** 从进程退出兜底集合移除（stop 时调用） */
+    static _uninstallSignalHandler(db) {
+        if (Database._signalDBs) Database._signalDBs.delete(db);
+    }
+
     insert(tableName, data) {
         const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
@@ -1333,11 +1370,16 @@ class Database {
         this._runHooks('onStop', []);
         this._emit('stop', {});
         if (this._dirMode) {
+            if (this._flushTimer) { clearTimeout(this._flushTimer); this._flushTimer = null; }
             try {
                 this._flushDirty();
                 this._saveMeta();
             } catch (e) {}
         }
+        if (this._sigInstalled) {
+            this._sigInstalled = false;
+            Database._uninstallSignalHandler(this);
+        }
         return this;
     }
 

package/lib/mysql_compat.js

@@ -6,19 +6,16 @@
 
 const { executeSQL, applyParams, escapeValue, escapeId } = require('./sql');
 const Database = require('./database');
+const EventEmitter = require('events');
 
 function isQueryResult(r) {
   return !!r && typeof r === 'object' && Array.isArray(r.rows) && Array.isArray(r.columns);
 }
 
-function toResultPacket(r, table) {
+function toResultPacket(r, table, rowsAsArray) {
   if (isQueryResult(r)) {
     const columns = r.columns || [];
-    const rows = (r.rows || []).map(vals => {
-      const obj = {};
-      columns.forEach((c, j) => { obj[c] = vals[j]; });
-      return obj;
-    });
+    const rawRows = r.rows || [];
     const fields = columns.map(name => ({
       name,
       table: table || '',
@@ -27,6 +24,13 @@ function toResultPacket(r, table) {
       flags: 0,
       charsetNr: 45,
     }));
+    const rows = rowsAsArray
+      ? rawRows
+      : rawRows.map(vals => {
+          const obj = {};
+          columns.forEach((c, j) => { obj[c] = vals[j]; });
+          return obj;
+        });
     return { rows, fields };
   }
   return {
@@ -41,8 +45,9 @@ function toResultPacket(r, table) {
   };
 }
 
-class Connection {
+class Connection extends EventEmitter {
   constructor(options = {}) {
+    super();
     this.config = {
       host: options.host || 'localhost',
       port: options.port || 3306,
@@ -56,20 +61,38 @@ class Connection {
     this.database = options.database && typeof options.database === 'object' && !options.filename && typeof options.database.start === 'function'
       ? options.database
       : (options.engine || null);
-    this.filename = options.filename || (typeof options.database === 'string' ? options.database : null);
+    this.filename = options.filename || null;
     this.engine = null;
     this._ownEngine = false;
     this.state = 'disconnected';
+    this.stream = {
+      destroyed: false,
+      writable: true,
+      destroy: () => { this.stream.destroyed = true; },
+    };
+    if (options.host !== undefined || options.database || options.engine || options.filename) {
+      queueMicrotask(() => {
+        this._getEngine().then(() => this.emit('connect'), err => {
+          if (this.listenerCount('error') > 0) this.emit('error', err);
+        });
+      });
+    }
   }
 
   async _getEngine() {
     if (this.engine) return this.engine;
-    if (this.database) {
+    if (this.database && typeof this.database.start === 'function') {
       this.engine = this.database;
-      if (typeof this.engine.start === 'function') await this.engine.start();
+      await this.engine.start();
+    } else if (this._pool) {
+      this.engine = await this._pool._sharedEngineFor(this.config.database || 'default');
+    } else if (this.filename) {
+      this.engine = new Database(this.filename);
+      await this.engine.start();
+      this._ownEngine = true;
     } else {
-      this.engine = new Database(this.filename || ':memory:');
-      if (typeof this.engine.start === 'function') await this.engine.start();
+      this.engine = new Database(':memory:');
+      await this.engine.start();
       this._ownEngine = true;
     }
     this.state = 'connected';
@@ -77,17 +100,21 @@ class Connection {
   }
 
   connect(cb) {
-    const p = this._getEngine().then(() => this);
+    const p = this._getEngine().then(c => {
+      this.emit('connect');
+      return c;
+    });
     if (cb) p.then(c => cb(null, c), err => cb(err));
     return p;
   }
 
-  async query(...args) {
-    let sql, values, cb;
+  query(...args) {
+    let sql, values, cb, rowsAsArray;
     if (typeof args[0] === 'object' && args[0] !== null && typeof args[0].sql === 'string') {
       sql = args[0].sql;
-      values = args[0].values;
-      cb = typeof args[1] === 'function' ? args[1] : null;
+      rowsAsArray = args[0].rowsAsArray === true;
+      values = args[0].values !== undefined ? args[0].values : (Array.isArray(args[1]) ? args[1] : null);
+      cb = typeof args[1] === 'function' ? args[1] : (typeof args[2] === 'function' ? args[2] : null);
     } else {
       sql = args[0];
       values = Array.isArray(args[1]) ? args[1] : null;
@@ -103,7 +130,7 @@ class Connection {
       });
       const results = Array.isArray(r) ? r : [r];
       const last = results[results.length - 1];
-      const packet = toResultPacket(last, last ? last.table : null);
+      const packet = toResultPacket(last, last ? last.table : null, rowsAsArray);
       if (isQueryResult(last)) {
         const arr = [packet.rows, packet.fields];
         arr.rows = packet.rows;
@@ -115,17 +142,34 @@ class Connection {
       arr.fields = null;
       return arr;
     })();
+    const q = new EventEmitter();
+    q.setMaxListeners = EventEmitter.prototype.setMaxListeners;
+    p.then(res => {
+      q.emit('result', res.rows || res[0]);
+      q.emit('fields', res.fields || []);
+    }, err => {
+      if (q.listenerCount('error') > 0) q.emit('error', err);
+    });
     if (cb) {
       p.then(res => {
         if (res && res.rows && res.fields) cb(null, res.rows, res.fields);
         else if (res && res[0] && res[0].insertId !== undefined) cb(null, res[0]);
         else cb(null, res[0]);
       }, err => cb(err));
-      return undefined;
+      return q;
     }
+    p.setMaxListeners = q.setMaxListeners;
     return p;
   }
 
+  execute(sql, values, cb) {
+    if (typeof values === 'function') {
+      cb = values;
+      values = undefined;
+    }
+    return this.query(sql, values, cb);
+  }
+
   beginTransaction(cb) {
     const p = this.query('BEGIN');
     if (cb) p.then(() => cb(null), err => cb(err));
@@ -156,6 +200,8 @@ class Connection {
 
   destroy() {
     this.state = 'destroyed';
+    this.stream.destroy();
+    this.emit('close');
   }
 
   end(cb) {
@@ -164,6 +210,8 @@ class Connection {
         await this.engine.stop();
       }
       this.state = 'closed';
+      this.stream.destroy();
+      this.emit('close');
       return undefined;
     })();
     if (cb) p.then(() => cb(null), err => cb(err));
@@ -184,17 +232,25 @@ class Pool {
     this._connections = [];
     this._waiters = [];
     this._closed = false;
-    this._sharedEngine = null;
+    this._sharedEngines = new Map();
     this._reaper = setInterval(() => this._reapIdle(), Math.max(1000, Math.floor(this.idleTimeout / 10) || 10000));
     this._reaper.unref();
   }
 
+  async _sharedEngineFor(database) {
+    const key = database || 'default';
+    let engine = this._sharedEngines.get(key);
+    if (!engine) {
+      engine = new Database(':memory:');
+      if (typeof engine.start === 'function') await engine.start();
+      this._sharedEngines.set(key, engine);
+    }
+    return engine;
+  }
+
   _createConnection() {
     const conn = new Connection(this.config);
     conn._pool = this;
-    if (!conn.database && !conn.engine && !conn.filename) {
-      conn.database = this._sharedEngine;
-    }
     const origDestroy = conn.destroy.bind(conn);
     conn.destroy = () => {
       this._remove(conn);
@@ -203,14 +259,6 @@ class Pool {
     return conn;
   }
 
-  async _ensureSharedEngine() {
-    if (!this._sharedEngine) {
-      this._sharedEngine = new Database(':memory:');
-      if (typeof this._sharedEngine.start === 'function') await this._sharedEngine.start();
-    }
-    return this._sharedEngine;
-  }
-
   _remove(conn) {
     const idx = this._connections.indexOf(conn);
     if (idx !== -1) this._connections.splice(idx, 1);
@@ -239,7 +287,7 @@ class Pool {
       return Promise.resolve(free);
     }
     if (this._connections.length < this.connectionLimit) {
-      return this._ensureSharedEngine().then(() => {
+      return Promise.resolve().then(() => {
         if (this._connections.length >= this.connectionLimit) {
           return this._waitForConnection();
         }
@@ -321,6 +369,9 @@ class Pool {
       for (const w of this._waiters.splice(0)) w.reject(err);
       const conns = this._connections.splice(0);
       await Promise.allSettled(conns.map(c => c.end()));
+      const engines = Array.from(this._sharedEngines.values());
+      this._sharedEngines.clear();
+      await Promise.allSettled(engines.map(e => (typeof e.stop === 'function' ? e.stop() : null)));
       return undefined;
     })();
     if (cb) p.then(() => cb(null), err => cb(err));
@@ -340,9 +391,21 @@ function createPool(options) {
   return new Pool(options || {});
 }
 
+class RowDataPacket {}
+class OkPacket {}
+class ResultSetHeader {}
+class FieldPacket {}
+
 module.exports = {
   createConnection,
   createPool,
+  createConnectionPromise: () => Promise.resolve(createConnection()),
+  Connection,
+  Pool,
+  RowDataPacket,
+  OkPacket,
+  ResultSetHeader,
+  FieldPacket,
   escape: escapeValue,
   escapeId,
   format: applyParams,

package/lib/mysql_server.js

@@ -104,8 +104,19 @@ function handshakePacket(connectionId, seed) {
   return b.build();
 }
 
-function okPacket(affectedRows = 0, insertId = 0, status = SERVER_STATUS_AUTOCOMMIT) {
-  const b = new PacketBuilder();
+/**
+ * 生成握手 seed：使用可打印 ASCII（33-126），避开 0x00。
+ * 老客户端按 C 字符串读取 seed，若含 \0 会提前截断导致握手失败/断连。
+ */
+function genSeed(len = 20) {
+  const out = Buffer.alloc(len);
+  for (let i = 0; i < len; i++) {
+    out[i] = 33 + Math.floor(Math.random() * 94);
+  }
+  return out;
+}
+
+function okPacket(affectedRows = 0, insertId = 0, status = SERVER_STATUS_AUTOCOMMIT) {  const b = new PacketBuilder();
   b.byte(0x00);
   b.raw(encodeLenenc(affectedRows));
   b.raw(encodeLenenc(insertId));
@@ -364,7 +375,7 @@ class MysqlConnection {
     this.socket = socket;
     this.server = server;
     this.connectionId = ++server._connectionCounter;
-    this.seed = crypto.randomBytes(20);
+    this.seed = genSeed(20);
     this.buffer = Buffer.alloc(0);
     this.sequence = 0;
     this.authenticated = false;

package/lib/native_client.js

@@ -257,14 +257,23 @@ class JSQL {
   _runHooks(hookName, args) {
     const hooks = this._hooks[hookName];
     if (!hooks || hooks.length === 0) return true;
-    for (const fn of hooks) {
-      const r = fn(...args);
-      if (r === false) return false;
-      if (r !== undefined && args.length > 0) {
-        args[0] = r;
+    if (this._inHook) {
+      // 防止插件 hook 内重入 native 调用导致 N-API 崩溃（段错误）
+      throw new Error('ER_PLUGIN_REENTRY: plugin hook "' + hookName + '" re-entered native call; plugin must not call engine methods inside its own hook');
+    }
+    this._inHook = true;
+    try {
+      for (const fn of hooks) {
+        const r = fn(...args);
+        if (r === false) return false;
+        if (r !== undefined && args.length > 0) {
+          args[0] = r;
+        }
       }
+      return true;
+    } finally {
+      this._inHook = false;
     }
-    return true;
   }
 
   async start() {

package/lib/sql.js

@@ -53,7 +53,9 @@ const KEYWORDS = new Set([
   'DATABASES', 'DATABASE', 'DESCRIBE', 'DESC', 'ON', 'DUPLICATE',
   'JOIN', 'LEFT', 'RIGHT', 'INNER', 'OUTER', 'CROSS',
   'GROUP', 'HAVING', 'UNION', 'ALL', 'CASE', 'WHEN', 'THEN', 'ELSE', 'END',
-  'BETWEEN', 'USING', 'FULL', 'UNSIGNED', 'ZEROFILL', 'TRUNCATE', 'COLLATE', 'CHARACTER'
+  'BETWEEN', 'USING', 'FULL', 'UNSIGNED', 'ZEROFILL', 'TRUNCATE', 'COLLATE', 'CHARACTER',
+  'ALTER', 'ADD', 'COLUMN', 'MODIFY', 'CHANGE', 'INDEX', 'FOREIGN', 'REFERENCES',
+  'CONSTRAINT', 'RENAME', 'TO', 'AFTER', 'FIRST', 'ENGINE', 'AUTO_INCREMENT', 'SPATIAL'
 ]);
 
 function tokenize(sql) {
@@ -229,6 +231,7 @@ class Parser {
         if (this.isKeyword('DATABASE', 1)) return this.parseDropDatabase();
         throw new Error('Unsupported DROP statement');
       case 'INSERT': return this.parseInsert();
+      case 'ALTER': return this.parseAlter();
       case 'TRUNCATE': this.expectKeyword('TRUNCATE'); if (this.isKeyword('TABLE')) this.next(); return { type: 'truncate', name: this.parseTableName() };
       case 'SELECT': return this.parseSelect();
       case 'UPDATE': return this.parseUpdate();
@@ -281,16 +284,28 @@ class Parser {
         if (t.value === 'PRIMARY') {
           this.expectKeyword('PRIMARY'); this.expectKeyword('KEY');
           this.expect('op', '(');
-          const pkCol = this.parseTableName();
+          const pkCols = [this.parseTableName()];
+          while (this.peek().type === 'op' && this.peek().value === ',') {
+            this.next();
+            pkCols.push(this.parseTableName());
+          }
           this.expect('op', ')');
-          if (schema[pkCol]) schema[pkCol].primaryKey = true;
+          for (const pkCol of pkCols) {
+            if (schema[pkCol]) schema[pkCol].primaryKey = true;
+          }
           hasPk = true;
         } else {
           this.expectKeyword('UNIQUE');
           this.expect('op', '(');
-          const uCol = this.parseTableName();
+          const uCols = [this.parseTableName()];
+          while (this.peek().type === 'op' && this.peek().value === ',') {
+            this.next();
+            uCols.push(this.parseTableName());
+          }
           this.expect('op', ')');
-          if (schema[uCol]) schema[uCol].unique = true;
+          for (const uCol of uCols) {
+            if (schema[uCol]) schema[uCol].unique = true;
+          }
         }
       } else if (t.type === 'keyword' && t.value === 'CONSTRAINT') {
         this.expectKeyword('CONSTRAINT');
@@ -495,7 +510,7 @@ class Parser {
         else if (!(this.peek().type === 'op' && this.peek().value === ')')) col = this.parseScalar();
         this.expect('op', ')');
         aggregate = { type: 'COUNT', column: col };
-        if (this.isKeyword('AS')) { this.next(); aggregate.alias = this.parseAlias(); }
+        aggregate.alias = this.parseOptionalAlias();
         columns.push({ expr: col, aggregate: 'COUNT', column: col, alias: aggregate.alias });
       } else if (t.type === 'keyword' && ['SUM', 'AVG', 'MIN', 'MAX'].includes(t.value)) {
         this.next();
@@ -504,7 +519,7 @@ class Parser {
         const col = this.parseScalar();
         this.expect('op', ')');
         aggregate = { type: fn, column: col };
-        if (this.isKeyword('AS')) { this.next(); aggregate.alias = this.parseAlias(); }
+        aggregate.alias = this.parseOptionalAlias();
         columns.push({ expr: col, aggregate: fn, column: col, alias: aggregate.alias });
       } else if (t.type === 'op' && t.value === '*') {
         this.next();
@@ -512,14 +527,16 @@ class Parser {
       } else if (t.type === 'keyword' && t.value === 'CASE') {
         const caseExpr = this.parseOperand();
         let alias = null;
-        if (this.isKeyword('AS')) { this.next(); alias = this.parseAlias(); }
+        alias = this.parseOptionalAlias();
         columns.push({ expr: null, caseExpr, alias });
       } else {
         // 列 / 常量 / 函数 / 算术表达式
         const expr = this.parseScalar();
         let alias = null;
-        if (this.isKeyword('AS')) { this.next(); alias = this.parseAlias(); }
-        if (expr.type === 'aggregate') {
+        alias = this.parseOptionalAlias();
+        if (expr.type === 'star') {
+          columns.push({ expr: '*' });
+        } else if (expr.type === 'aggregate') {
           columns.push({ expr: expr.column, aggregate: expr.fn, column: expr.column, alias, scalar: expr });
         } else if (expr.type === 'column') {
           columns.push({ expr: expr.name, scalar: expr, alias });
@@ -641,6 +658,12 @@ class Parser {
     return t.value;
   }
 
+  parseOptionalAlias() {
+    if (this.isKeyword('AS')) { this.next(); return this.parseAlias(); }
+    if (this.peek().type === 'ident') return this.parseAlias();
+    return null;
+  }
+
   parseColumnRef() {
     const t = this.next();
     if (t.type !== 'ident') throw new Error(`Expected column name, got '${t.value}'`);
@@ -718,6 +741,121 @@ class Parser {
     return { type: 'dropDatabase', database: name, ifExists };
   }
 
+  _skipAlterTail() {
+    while (!(this.peek().type === 'eof' || this.peek().value === ';')) {
+      if (this.peek().type === 'op' && this.peek().value === ',') return;
+      if (this.peek().type === 'keyword' && ['ADD', 'DROP', 'MODIFY', 'CHANGE', 'RENAME', 'ENGINE', 'CONVERT', 'DEFAULT'].includes(this.peek().value)) return;
+      this.next();
+    }
+  }
+
+  _skipFirstAfter() {
+    if (this.isKeyword('FIRST')) { this.next(); return; }
+    if (this.isKeyword('AFTER')) { this.next(); if (this.peek().type === 'ident') this.next(); }
+  }
+
+  _parseIndexColumns() {
+    this.expect('op', '(');
+    const columns = [];
+    for (;;) {
+      const col = this.parseTableName();
+      if (this.isKeyword('ASC') || this.isKeyword('DESC')) this.next();
+      columns.push(col);
+      if (this.peek().value === ',') { this.next(); continue; }
+      break;
+    }
+    this.expect('op', ')');
+    return columns;
+  }
+
+  parseAlter() {
+    this.expectKeyword('ALTER');
+    this.expectKeyword('TABLE');
+    const name = this.parseTableName();
+    const ops = [];
+    for (;;) {
+      const t = this.next();
+      if (t.type !== 'keyword') throw new Error(`Expected ALTER operation, got '${t.value}'`);
+      switch (t.value) {
+        case 'ADD': {
+          if (this.isKeyword('COLUMN')) this.next();
+          if (this.isKeyword('INDEX') || this.isKeyword('KEY') || this.isKeyword('UNIQUE') || this.isKeyword('FULLTEXT') || this.isKeyword('SPATIAL')) {
+            const unique = this.isKeyword('UNIQUE');
+            if (unique || this.isKeyword('FULLTEXT') || this.isKeyword('SPATIAL')) this.next();
+            if (this.isKeyword('INDEX') || this.isKeyword('KEY')) this.next();
+            let indexName = null;
+            if (this.peek().type === 'ident') indexName = this.parseTableName();
+            if (this.isKeyword('USING')) { this.next(); this.next(); }
+            const columns = this._parseIndexColumns();
+            ops.push({ op: 'addIndex', columns, unique, name: indexName });
+          } else if (this.isKeyword('PRIMARY')) {
+            this.expectKeyword('PRIMARY'); this.expectKeyword('KEY');
+            if (this.peek().type === 'op' && this.peek().value === '(') {
+              const columns = this._parseIndexColumns();
+              ops.push({ op: 'addPrimary', columns });
+            }
+          } else if (this.isKeyword('CONSTRAINT')) {
+            this.next();
+            if (this.peek().type === 'ident') this.next();
+            if (this.isKeyword('UNIQUE')) { this.next(); }
+            if (this.isKeyword('INDEX') || this.isKeyword('KEY')) { this.next(); if (this.peek().type === 'ident') this.next(); }
+            if (this.isKeyword('FOREIGN')) {
+              this.expectKeyword('FOREIGN'); this.expectKeyword('KEY');
+              const columns = this._parseIndexColumns();
+              this.expectKeyword('REFERENCES');
+              const refTable = this.parseTableName();
+              const refCols = this._parseIndexColumns();
+              this._skipAlterTail();
+              ops.push({ op: 'addForeign', columns, refTable, refCols });
+            } else {
+              const columns = this._parseIndexColumns();
+              ops.push({ op: 'addIndex', columns, unique: true });
+            }
+          } else {
+            const column = this.parseTableName();
+            const def = this.parseColumnDef();
+            this._skipFirstAfter();
+            ops.push({ op: 'addColumn', column, def });
+          }
+          break;
+        }
+        case 'DROP': {
+          if (this.isKeyword('COLUMN')) this.next();
+          if (this.isKeyword('PRIMARY')) { this.expectKeyword('PRIMARY'); this.expectKeyword('KEY'); ops.push({ op: 'dropPrimary' }); break; }
+          if (this.isKeyword('FOREIGN')) { this.next(); this.expectKeyword('KEY'); if (this.peek().type === 'ident') this.next(); ops.push({ op: 'dropIndex' }); break; }
+          if (this.isKeyword('INDEX') || this.isKeyword('KEY')) { this.next(); if (this.peek().type === 'ident') this.next(); ops.push({ op: 'dropIndex' }); break; }
+          const column = this.parseTableName();
+          ops.push({ op: 'dropColumn', column });
+          break;
+        }
+        case 'MODIFY':
+        case 'CHANGE': {
+          if (this.isKeyword('COLUMN')) this.next();
+          const column = this.parseTableName();
+          let newColumn = column;
+          if (t.value === 'CHANGE') newColumn = this.parseTableName();
+          const def = this.parseColumnDef();
+          this._skipFirstAfter();
+          ops.push({ op: t.value === 'CHANGE' ? 'changeColumn' : 'modifyColumn', column, newColumn, def });
+          break;
+        }
+        case 'RENAME': {
+          if (this.isKeyword('TO')) this.next();
+          const newName = this.parseTableName();
+          ops.push({ op: 'rename', newName });
+          break;
+        }
+        default:
+          this._skipAlterTail();
+          break;
+      }
+      if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); continue; }
+      break;
+    }
+    this.optionalTailSemicolon();
+    return { type: 'alterTable', name, ops };
+  }
+
   parseShow() {
     this.expectKeyword('SHOW');
     if (this.isKeyword('TABLES')) {
@@ -861,6 +999,7 @@ class Parser {
       if (this.peek().type === 'op' && this.peek().value === '.') {
         this.next();
         const col = this.next();
+        if (col.type === 'op' && col.value === '*') return { type: 'star', alias: t.value };
         if (col.type !== 'ident') throw new Error(`Expected column name after '.', got '${col.value}'`);
         return { type: 'column', name: t.value + '.' + col.value };
       }
@@ -885,7 +1024,7 @@ class Parser {
     if (t.type === 'sysvar') return { type: 'sysvar', name: t.value };
     if (t.type === 'keyword' && t.value === 'NULL') return { type: 'value', value: null };
     if (t.type === 'keyword' && t.value === 'CASE') return this.parseCase();
-    if (t.type === 'keyword' && this.peek().type === 'op' && this.peek().value === '(') {
+    if (t.type === 'keyword' && !['SUM', 'AVG', 'MIN', 'MAX', 'COUNT'].includes(t.value) && this.peek().type === 'op' && this.peek().value === '(') {
       const name = t.value;
       this.next();
       const args = [];
@@ -1371,9 +1510,69 @@ class SQLExecutor {
         if (this.engine.hasTable(statement.name)) await this.engine.truncate(statement.name);
         return { ok: true, type: 'truncate', table: statement.name, affectedRows: 0 };
       }
+      case 'alterTable': {
+        const table = this.engine._tables ? this.engine._tables[statement.name] : null;
+        if (!table) throw new Error(`Table '${statement.name}' does not exist`);
+        for (const op of statement.ops) {
+          switch (op.op) {
+            case 'addColumn': {
+              table._schema[op.column] = op.def;
+              for (const row of table._rows) if (!(op.column in row)) row[op.column] = null;
+              break;
+            }
+            case 'dropColumn': {
+              delete table._schema[op.column];
+              for (const row of table._rows) delete row[op.column];
+              break;
+            }
+            case 'changeColumn':
+            case 'modifyColumn': {
+              const def = { ...op.def };
+              const prev = table._schema[op.column];
+              if (prev && op.column === op.newColumn) {
+                if (prev.autoIncrement && !def.autoIncrement) def.autoIncrement = true;
+                if (prev.primaryKey && !def.primaryKey) { def.primaryKey = true; def.unique = true; }
+              }
+              table._schema[op.column] = def;
+              if (op.newColumn !== op.column) {
+                table._schema[op.newColumn] = def;
+                delete table._schema[op.column];
+                for (const row of table._rows) {
+                  if (op.column in row) { row[op.newColumn] = row[op.column]; delete row[op.column]; }
+                }
+              }
+              break;
+            }
+            case 'addPrimary': {
+              for (const c of op.columns) { table._schema[c].primaryKey = true; table._schema[c].unique = true; }
+              break;
+            }
+            case 'dropPrimary': {
+              for (const def of Object.values(table._schema)) { if (def && typeof def === 'object') { def.primaryKey = false; } }
+              break;
+            }
+            case 'addIndex': {
+              if (!op.unique) break;
+              for (const c of op.columns) table._schema[c].unique = true;
+              break;
+            }
+            case 'addForeign':
+            case 'dropIndex':
+            case 'rename':
+            default:
+              break;
+          }
+        }
+        await this._rebuildTableCache(table);
+        await this.engine.flush();
+        return { ok: true, type: 'alterTable', table: statement.name, affectedRows: 0 };
+      }
       case 'insert': {
         let dataRows = statement.dataRows;
-        let schema = null;
+        let schema = this.engine.getTableSchema
+          ? await this.engine.getTableSchema(statement.name)
+          : (this.engine._schemas ? this.engine._schemas[statement.name] : null);
+        if (!schema) throw new Error(`Table '${statement.name}' does not exist`);
         const stripDefault = (row) => {
           const out = {};
           for (const [k, v] of Object.entries(row)) {
@@ -1383,14 +1582,15 @@ class SQLExecutor {
           return out;
         };
         if (statement.dataRows) {
-          statement.dataRows = statement.dataRows.map(stripDefault);
+          statement.dataRows = statement.dataRows.map(row => {
+            for (const [c, def] of Object.entries(schema)) {
+              if (def.autoIncrement && (row[c] === null || row[c] === undefined)) delete row[c];
+            }
+            return stripDefault(row);
+          });
           dataRows = statement.dataRows;
         }
         if (dataRows === null && statement.values) {
-          schema = this.engine.getTableSchema
-            ? await this.engine.getTableSchema(statement.name)
-            : (this.engine._schemas ? this.engine._schemas[statement.name] : null);
-          if (!schema) throw new Error(`Table '${statement.name}' does not exist`);
           const colNames = Object.keys(schema);
           const skipAuto = statement.values[0].length < colNames.length;
           dataRows = statement.values.map(vals => {
@@ -1410,11 +1610,6 @@ class SQLExecutor {
           });
           dataRows = dataRows.map(stripDefault);
         }
-        if (!schema) {
-          schema = this.engine.getTableSchema
-            ? await this.engine.getTableSchema(statement.name)
-            : (this.engine._schemas ? this.engine._schemas[statement.name] : null);
-        }
         const pkCols = schema ? Object.keys(schema).filter(k => schema[k].primaryKey) : [];
         let toInsert = dataRows;
         let updated = 0;
@@ -1425,7 +1620,10 @@ class SQLExecutor {
           if (explicit.length > 0) {
             const all = (await this.engine.find(statement.name, {}, { limit: 1e9, offset: 0 })).map(r => normalizeRow(r, schema));
             const pkMap = new Map();
-            for (const row of all) pkMap.set(keyOf(row), row.id);
+            for (const row of all) {
+              const keys = pkCols.map(c => row[c]).filter(v => v !== undefined && v !== null);
+              if (keys.length === pkCols.length) pkMap.set(keyOf(row), keys);
+            }
             const conflicts = [];
             const fresh = [];
             for (const d of dataRows) {
@@ -1443,7 +1641,13 @@ class SQLExecutor {
               for (const { d, existingId } of conflicts) {
                 const data = {};
                 for (const [col, val] of statement.onDuplicate) data[col] = val;
-                this.engine.updateById(statement.name, existingId, data);
+                if (this.engine.updateById && existingId.length === 1) {
+                  this.engine.updateById(statement.name, existingId[0], data);
+                } else if (this.engine.update) {
+                  const filter = {};
+                  pkCols.forEach((c, i) => { filter[c] = existingId[i]; });
+                  this.engine.update(statement.name, filter, data);
+                }
                 updated++;
               }
               await this.engine.flush();
@@ -1681,6 +1885,144 @@ class SQLExecutor {
     return this._readTable(item.table);
   }
 
+  _infoSchemaColumns(view) {
+    const defs = {
+      'tables': ['TABLE_CATALOG', 'TABLE_SCHEMA', 'TABLE_NAME', 'TABLE_TYPE', 'ENGINE', 'VERSION', 'ROW_FORMAT', 'TABLE_ROWS', 'AVG_ROW_LENGTH', 'DATA_LENGTH', 'MAX_DATA_LENGTH', 'INDEX_LENGTH', 'DATA_FREE', 'AUTO_INCREMENT', 'CREATE_TIME', 'UPDATE_TIME', 'CHECK_TIME', 'TABLE_COLLATION', 'CHECKSUM', 'CREATE_OPTIONS', 'TABLE_COMMENT'],
+      'columns': ['TABLE_CATALOG', 'TABLE_SCHEMA', 'TABLE_NAME', 'COLUMN_NAME', 'ORDINAL_POSITION', 'COLUMN_DEFAULT', 'IS_NULLABLE', 'DATA_TYPE', 'CHARACTER_MAXIMUM_LENGTH', 'CHARACTER_OCTET_LENGTH', 'NUMERIC_PRECISION', 'NUMERIC_SCALE', 'DATETIME_PRECISION', 'CHARACTER_SET_NAME', 'COLLATION_NAME', 'COLUMN_TYPE', 'COLUMN_KEY', 'EXTRA', 'PRIVILEGES', 'COLUMN_COMMENT', 'GENERATION_EXPRESSION'],
+      'schemata': ['CATALOG_NAME', 'SCHEMA_NAME', 'DEFAULT_CHARACTER_SET_NAME', 'DEFAULT_COLLATION_NAME', 'SQL_PATH', 'DEFAULT_ENCRYPTION'],
+      'statistics': ['TABLE_CATALOG', 'TABLE_SCHEMA', 'TABLE_NAME', 'NON_UNIQUE', 'INDEX_SCHEMA', 'INDEX_NAME', 'SEQ_IN_INDEX', 'COLUMN_NAME', 'COLLATION', 'CARDINALITY', 'SUB_PART', 'PACKED', 'NULLABLE', 'INDEX_TYPE', 'COMMENT', 'INDEX_COMMENT'],
+      'key_column_usage': ['CONSTRAINT_CATALOG', 'CONSTRAINT_SCHEMA', 'CONSTRAINT_NAME', 'TABLE_CATALOG', 'TABLE_SCHEMA', 'TABLE_NAME', 'COLUMN_NAME', 'ORDINAL_POSITION', 'POSITION_IN_UNIQUE_CONSTRAINT', 'REFERENCED_TABLE_SCHEMA', 'REFERENCED_TABLE_NAME', 'REFERENCED_COLUMN_NAME'],
+      'referential_constraints': ['CONSTRAINT_CATALOG', 'CONSTRAINT_SCHEMA', 'CONSTRAINT_NAME', 'UNIQUE_CONSTRAINT_CATALOG', 'UNIQUE_CONSTRAINT_SCHEMA', 'UNIQUE_CONSTRAINT_NAME', 'MATCH_OPTION', 'UPDATE_RULE', 'DELETE_RULE', 'TABLE_NAME', 'REFERENCED_TABLE_NAME'],
+      'table_constraints': ['CONSTRAINT_CATALOG', 'CONSTRAINT_SCHEMA', 'CONSTRAINT_NAME', 'TABLE_SCHEMA', 'TABLE_NAME', 'CONSTRAINT_TYPE'],
+    };
+    return defs[view] || ['COLUMN_NAME'];
+  }
+
+  _infoSchemaType(def) {
+    const t = String(def.type || '').toLowerCase();
+    const m = { int: 'int', integer: 'int', smallint: 'smallint', mediumint: 'mediumint', bigint: 'bigint', tinyint: 'tinyint', string: 'varchar', varchar: 'varchar', char: 'char', text: 'text', tinytext: 'tinytext', mediumtext: 'mediumtext', longtext: 'longtext', blob: 'blob', float: 'float', double: 'double', real: 'double', decimal: 'decimal', numeric: 'decimal', boolean: 'tinyint', bool: 'tinyint', date: 'date', datetime: 'datetime', timestamp: 'timestamp', time: 'time', year: 'year', json: 'json', enum: 'enum', uuid: 'varchar', binary: 'varbinary' };
+    return m[t] || t || 'varchar';
+  }
+
+  async _infoSchemaRows(view) {
+    const tables = this.engine._tableNames ? Array.from(this.engine._tableNames) : (this.engine.tables ? this.engine.tables() : []);
+    const dbName = 'default';
+    const base = { TABLE_CATALOG: 'def' };
+    if (view === 'tables' || view === 'views') {
+      const out = [];
+      for (const name of tables) {
+        const schema = this.engine.getTableSchema(name) || {};
+        const table = this.engine._tables ? this.engine._tables[name] : null;
+        const rowCount = table && table._rows ? table._rows.length : 0;
+        out.push(Object.assign({}, base, {
+          TABLE_SCHEMA: dbName,
+          TABLE_NAME: name,
+          TABLE_TYPE: view === 'views' ? 'VIEW' : 'BASE TABLE',
+          ENGINE: 'InnoDB',
+          VERSION: 10,
+          ROW_FORMAT: 'Dynamic',
+          TABLE_ROWS: rowCount,
+          AVG_ROW_LENGTH: 0,
+          DATA_LENGTH: 0,
+          MAX_DATA_LENGTH: 0,
+          INDEX_LENGTH: 0,
+          DATA_FREE: 0,
+          AUTO_INCREMENT: table && table._autoIncrement ? table._autoIncrement : null,
+          CREATE_TIME: null,
+          UPDATE_TIME: null,
+          CHECK_TIME: null,
+          TABLE_COLLATION: 'utf8mb4_general_ci',
+          CHECKSUM: null,
+          CREATE_OPTIONS: '',
+          TABLE_COMMENT: '',
+        }));
+      }
+      return out;
+    }
+    if (view === 'columns') {
+      const out = [];
+      for (const name of tables) {
+        const schema = this.engine.getTableSchema(name) || {};
+        let pos = 0;
+        for (const [col, def] of Object.entries(schema)) {
+          pos++;
+          const dataType = this._infoSchemaType(def);
+          const len = def.length != null ? def.length : (def.maxLength != null ? def.maxLength : null);
+          const colType = len != null ? `${dataType}(${len})` : dataType;
+          out.push(Object.assign({}, base, {
+            TABLE_SCHEMA: dbName,
+            TABLE_NAME: name,
+            COLUMN_NAME: col,
+            ORDINAL_POSITION: pos,
+            COLUMN_DEFAULT: def.default !== undefined ? def.default : null,
+            IS_NULLABLE: def.required || def.autoIncrement ? 'NO' : 'YES',
+            DATA_TYPE: dataType,
+            CHARACTER_MAXIMUM_LENGTH: /char|text/.test(dataType) ? len : null,
+            CHARACTER_OCTET_LENGTH: /char|text/.test(dataType) ? (len ? len * 4 : null) : null,
+            NUMERIC_PRECISION: /int|decimal|float|double|numeric/.test(dataType) ? 10 : null,
+            NUMERIC_SCALE: /decimal|numeric/.test(dataType) ? 0 : null,
+            DATETIME_PRECISION: null,
+            CHARACTER_SET_NAME: /char|text/.test(dataType) ? 'utf8mb4' : null,
+            COLLATION_NAME: /char|text/.test(dataType) ? 'utf8mb4_general_ci' : null,
+            COLUMN_TYPE: colType,
+            COLUMN_KEY: def.primaryKey ? 'PRI' : (def.unique ? 'UNI' : ''),
+            EXTRA: def.autoIncrement ? 'auto_increment' : '',
+            PRIVILEGES: 'select,insert,update,references',
+            COLUMN_COMMENT: def.comment || '',
+            GENERATION_EXPRESSION: '',
+          }));
+        }
+      }
+      return out;
+    }
+    if (view === 'schemata') {
+      return [Object.assign({}, base, {
+        SCHEMA_NAME: dbName,
+        CATALOG_NAME: 'def',
+        DEFAULT_CHARACTER_SET_NAME: 'utf8mb4',
+        DEFAULT_COLLATION_NAME: 'utf8mb4_general_ci',
+        SQL_PATH: null,
+        DEFAULT_ENCRYPTION: 'NO',
+      })];
+    }
+    return [];
+  }
+
+  async _rebuildTableCache(table) {
+    const schema = table._schema;
+    table._primaryKey = null;
+    table._autoIncrementField = null;
+    table._dateFields = {};
+    for (const [f, def] of Object.entries(schema)) {
+      if (f === '_softDelete') continue;
+      const isPk = def.primaryKey || def.primary === true;
+      if (isPk && !table._primaryKey) table._primaryKey = f;
+      if (def.autoIncrement) {
+        table._autoIncrementField = f;
+        if (isPk) table._primaryKey = f;
+      }
+      if (['date', 'datetime', 'timestamp', 'time'].includes(def.type)) table._dateFields[f] = def.type;
+    }
+    table._cachedSchemaFields = Object.keys(schema).filter(f => f !== '_softDelete');
+    table._cachedDateFields = Object.keys(table._dateFields);
+    table._cachedUniqueFields = table._cachedSchemaFields.filter(f => schema[f].unique);
+    table._cachedRequiredFields = table._cachedSchemaFields.filter(f => schema[f].required);
+    table._pkIndex = table._primaryKey ? new Map() : null;
+    table._btrees = {};
+    for (const [f, def] of Object.entries(schema)) {
+      if (f === '_softDelete') continue;
+      if (def.primaryKey || def.unique) {
+        table._btrees[f] = new (require('./btree'))(64, true);
+      }
+    }
+    table._rows.forEach((row, idx) => {
+      for (const [f, tree] of Object.entries(table._btrees)) {
+        const v = row[f];
+        if (v !== undefined && v !== null) tree.insert(v, idx);
+      }
+    });
+  }
+
   // 物化表达式树中的子查询：IN (SELECT ...) -> expr.list
   async _materialize(expr) {
     if (!expr || typeof expr !== 'object') return;
@@ -1805,13 +2147,24 @@ class SQLExecutor {
       // 读第一表
       const firstItem = statement.from.tables[0];
       if (firstItem && firstItem.table && String(firstItem.table).toLowerCase().startsWith('information_schema.')) {
+        const view = String(firstItem.table).toLowerCase().split('.')[1];
+        const all = await this._infoSchemaRows(view);
+        const filtered = statement.where ? all.filter(r => evaluateExpr(statement.where, r)) : all;
         const cols = statement.columns.map(c => scalarColumnName(c));
-        return { ok: true, type: 'select', table: null, columns: cols, rows: [], raw: [] };
+        const isStar = cols.length === 1 && cols[0] === '*';
+        let outCols;
+        if (isStar) {
+          outCols = filtered.length > 0 ? Object.keys(filtered[0]) : this._infoSchemaColumns(view);
+        } else {
+          outCols = cols;
+        }
+        const rows = filtered.map(r => outCols.map(c => (c in r ? r[c] : null)));
+        return { ok: true, type: 'select', table: firstItem.table, columns: outCols, rows, raw: filtered };
       }
       let rowsAll;
       if (firstItem.subquery) {
         const res = await this.executeSelect(firstItem.subquery);
-        rowsAll = { rows: this._subQueryRows(res), schema: null };
+        rowsAll = { rows: this._subQueryRows(res), schema: null, columns: res.columns };
       } else {
         rowsAll = await this._readTable(firstItem.table);
       }
@@ -1962,7 +2315,14 @@ class SQLExecutor {
       const schemaKeys = schema ? Object.keys(schema) : [];
       const pkCols = schemaKeys.filter(k => schema && schema[k] && schema[k].primaryKey);
       const pk = pkCols.length > 0 ? pkCols[0] : (schemaKeys[0] || 'id');
-      const cols = schema ? [pk, ...schemaKeys.filter(k => k !== pk)] : Object.keys(all[0] || {}).filter((v, i, a) => a.indexOf(v) === i);
+      let cols;
+      if (schema) {
+        cols = [pk, ...schemaKeys.filter(k => k !== pk)];
+      } else if (rowsAll && rowsAll.columns) {
+        cols = rowsAll.columns;
+      } else {
+        cols = Object.keys(all[0] || {}).filter((v, i, a) => a.indexOf(v) === i);
+      }
       return { ok: true, type: 'select', table: tableName, columns: cols, rows: rows.map(r => cols.map(c => r[c])), raw: rows };
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsql-neo",
-  "version": "4.4.3",
+  "version": "4.5.1",
   "description": "JSQL-NEO — Rust-powered embedded database with WASM, REST API, B-Tree indexes, WAL, crash recovery",
   "main": "index.js",
   "types": "index.d.ts",
@@ -13,6 +13,8 @@
       "default": "./index.js"
     },
     "./cli": "./bin/jsql",
+    "./mysql2": "./lib/mysql_compat.js",
+    "./mysql": "./lib/mysql_compat.js",
     "./wasm/browser.mjs": {
       "types": "./wasm/browser.d.ts",
       "default": "./wasm/browser.mjs"