jsql-neo 4.4.2 → 4.5.0

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/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/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();
@@ -495,7 +498,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 +507,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 +515,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 +646,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 +729,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 +987,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 };
       }
@@ -1371,9 +1498,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 +1570,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 +1598,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;
@@ -1681,6 +1864,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 +2126,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 +2294,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.2",
+  "version": "4.5.0",
   "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"
@@ -20,7 +22,8 @@
     "./wasm/browser_bg.mjs": "./wasm/browser_bg.mjs",
     "./wasm/browser.d.ts": "./wasm/browser.d.ts",
     "./wasm/*": "./wasm/*",
-    "./lib/*": "./lib/*",
+    "./lib/*.js": "./lib/*.js",
+    "./lib/*": "./lib/*.js",
     "./package.json": "./package.json"
   },
   "bin": {