jsql-neo 4.2.0 → 4.3.0

package/README.md

@@ -1,9 +1,6 @@
-# JSQL-NEO v4.2.0
+# JSQL-NEO v4.0.1
 
-Rust-powered embedded database with **three engines + SQL + MySQL-compatible server + Redis-style storage** in one npm package.
-
-> **Docs & Help:** [https://help.vexify.top](https://help.vexify.top)  
-> **GitHub:** [https://github.com/vexify-org/JSQL-neo](https://github.com/vexify-org/JSQL-neo)
+Rust-powered embedded database with **three engines + SQL + Redis-style storage** in one npm package.
 
 ## Engines
 
@@ -33,54 +30,7 @@ await jsql.executeSQL(db, 'DELETE FROM users WHERE id = 2');
 await db.stop();
 ```
 
-Supported SQL: `CREATE/DROP TABLE` (incl. `IF [NOT] EXISTS`), `CREATE/DROP DATABASE`, `USE` / `SHOW DATABASES` / `SHOW TABLES [FROM db]`, `INSERT` (multi-row, `ON DUPLICATE KEY UPDATE`), `SELECT` (`WHERE` / `ORDER BY` / `LIMIT` / `OFFSET` / `GROUP BY` / `HAVING` / aggregates `COUNT`/`SUM`/`AVG`/`MIN`/`MAX` / `DISTINCT` / `JOIN` / `UNION [ALL]` / `CASE WHEN` / subqueries `IN (…)` & scalar `(SELECT …)` / `BETWEEN`/`LIKE`/`IS NULL`), `UPDATE`, `DELETE`, `BEGIN`/`COMMIT`/`ROLLBACK`, prepared statements with `?` placeholders.
-
-Type names accept MySQL aliases: `INTEGER/INT/BIGINT/TINYINT/SMALLINT`, `STRING/TEXT/VARCHAR(n)/CHAR(n)`, `FLOAT/DOUBLE/REAL/NUMERIC/DECIMAL`, `BOOLEAN/BOOL`, `DATE/DATETIME/TIMESTAMP`, `JSON/OBJECT/ARRAY`.
-
-## MySQL-Compatible Server (multi-database)
-
-A native MySQL protocol server on TCP 3306 — any `mysql` / `mysql2` / GUI client connects directly.
-
-```bash
-npx jsql server start --port 3306 --data-dir ./data        # 后台常驻
-npx jsql server status                                     # 状态
-npx jsql server stop                                       # 停止
-```
-
-**Multi-database & 一键建表:** each database is an independent directory (`<dataDir>/<db>`).
-
-```sql
--- 随意连接即可直接建表（自动落到默认库 default）
-CREATE TABLE users (id INTEGER PRIMARY KEY AUTO_INCREMENT, name VARCHAR(50));
-
--- 一条 SQL 跨库建库+建表（库不存在自动创建）
-CREATE TABLE shop.orders (id INTEGER PRIMARY KEY, amount FLOAT, `user` STRING);
-
--- 连接时指定尚不存在的库会自动创建：mysql -uroot -D mydb
--- 查询/增删改也能带库前缀：INSERT INTO shop.orders ..., SELECT * FROM shop.orders, SHOW TABLES FROM shop;
-```
-
-- 连接指定未存在的库 → **自动建库**，无需先 `CREATE DATABASE`
-- 未 `USE` 任何库 → 落到默认库，可直接 `CREATE TABLE`
-- 全量多库 DDL/DML 支持 `db.table` 点号语法 + `SHOW TABLES FROM db`
-- **多用户 + 库级权限**: 每个用户可配置可访问的数据库白名单（`{ user: { password, databases: [...] } }`）
-
-```json
-{ "port": 3306, "dataDir": "/var/lib/jsql",
-  "auth": { "admin": { "password": "secret", "databases": ["shop", "blog"] }, "reader": "readpass" } }
-```
-
-## Transactions
-
-```js
-db.begin();            // 默认 REPEATABLE_READ：begin 时保存行快照
-db.insert('t', { id: 2 });
-db.rollback();         // 删除新增、还原更新、恢复自增 —— 回滚生效
-db.begin(); db.insert('t', { id: 3 }); db.commit();
-// 也支持 SQL：BEGIN ... COMMIT / ROLLBACK
-```
-
-`begin(isolationLevel)` 可选 `'REPEATABLE_READ'`（快照回滚，默认）或 `'READ_COMMITTED'`（仅回滚自增）。
+Supported: `CREATE/DROP TABLE`, `INSERT` (multi-row, `ON DUPLICATE KEY UPDATE`), `SELECT` (`WHERE`/`ORDER BY`/`LIMIT`/`OFFSET`/`GROUP BY`/`HAVING`/aggregates), `UPDATE`, `DELETE`, prepared statements with `?` placeholders.
 
 ## Redis-Style Storage Modes
 
@@ -154,58 +104,62 @@ db.save();
 | `updateById(table, id, data)` | ✅ | ✅ | ✅ | O(1) PK update |
 | `removeById(table, id)` | ✅ | ✅ | ✅ | O(1) PK delete |
 | `dropTable(name)` | ✅ | ✅ | ✅ | Remove table |
-| `insertMany(table, items)` | ✅ | ✅ | ✅ | Batch insert |
-| `update(table, query, updates)` | ✅ | ✅ | ✅ | Batch update by query |
-| `delete(table, query)` | ✅ | ✅ | ✅ | Batch delete by query |
-| `truncate(table)` | ✅ | ✅ | ✅ | Delete all rows |
-| `begin()/commit()/rollback()` | ✅ | ✅ | ✅ | Transactions (snapshot rollback) |
 | `executeSQL(db, sql, params?)` | ✅ | ✅ | ✅ | Run SQL statements |
 
 ## Schema Field Options
 
 ```js
 {
-  type: 'string' | 'integer' | 'float' | 'boolean' | 'date' | 'object' | 'array',
-  primaryKey: true,       // PK field (auto-indexed) — `primary: true` 也接受
+  type: 'string' | 'integer' | 'float' | 'boolean',
+  primaryKey: true,       // PK field (auto-indexed)
   autoIncrement: true,    // Auto-generate integer PK
-  unique: true,           // Unique constraint (auto-indexed)
   length: 32,             // Max string length
   default: 'value',       // Default value
-  nullable: true,         // Allow null
-  required: true,         // Not-null constraint
-  foreignKey: { table, field, onDelete },  // FK constraint
-  check: (val) => bool,   // CHECK constraint
-  computed: (row) => val  // Computed field
+  nullable: true          // Allow null
 }
 ```
 
+## ORM Compatibility
+
+The MySQL-compatible server mode accepts standard MySQL clients, so popular Node.js ORMs work without a plugin. Tested against a live `createMysqlServer()` instance:
+
+| ORM | Version | Results |
+|-----|---------|---------|
+| [Sequelize](https://sequelize.org) | v6 | ✅ 10/10 — connect, authenticate, sync (CREATE TABLE), create, bulkCreate, find, count, update, destroy, MAX() |
+| [Knex](https://knexjs.org) | v3 | ✅ 9/9 — schema builder, insert, select, where + orderBy, count, update, delete, raw `SELECT VERSION()` |
+| [TypeORM](https://typeorm.io) | v0.3 | ✅ 8/8 — initialize, synchronize, save, findOne, find, count, update, delete |
+
+```js
+// Sequelize
+const { Sequelize, DataTypes } = require('sequelize');
+const sequelize = new Sequelize('default', 'root', '', {
+  host: '127.0.0.1', port: 33306, dialect: 'mysql',
+});
+
+// Knex
+const knex = require('knex')({
+  client: 'mysql2',
+  connection: { host: '127.0.0.1', port: 33306, user: 'root', database: 'default' },
+});
+
+// TypeORM
+const ds = new DataSource({
+  type: 'mysql',
+  host: '127.0.0.1', port: 33306, username: 'root', database: 'default',
+  synchronize: true, entities: [User],
+});
+```
+
+Supported for ORM compatibility: prepared statements (`COM_STMT_PREPARE`/`EXECUTE`), binary protocol result sets, `SHOW COLUMNS` / `SHOW INDEX` / `SHOW CREATE TABLE` / `SHOW VARIABLES` / `SHOW GRANTS`, `information_schema` queries, `START TRANSACTION`, `TRUNCATE TABLE`, `SET` statements, scalar functions (`VERSION()`, `NOW()`, `CONCAT()`, `IFNULL()`, ...), and MySQL DDL forms (`int unsigned`, `auto_increment`, `ENGINE=InnoDB`, `DEFAULT CHARSET`).
+
 ## Features
 
-**Engines & Storage**
-- Three engines with one shared API: Native (N-API Rust, fastest), WASM (wasm-pack, zero native deps), Pure JS (`Database`)
-- Redis-style storage modes: `memory` / `hybrid` (async flush + LRU eviction + lazy reload) / `disk` (fast flush, memory as cache)
-- Atomic per-table files (`<dir>/<table>.jsql.json` + `meta.json`, tmp + rename)
-- WAL + snapshot crash recovery
-- O(1) primary-key hash index (`FxHashMap` / `Map`) + B-Tree range indexes
-
-**SQL**
-- Full statement coverage: DDL / DML / SELECT (aggregates, `GROUP BY`/`HAVING`, `JOIN`, `UNION`, `CASE WHEN`, subqueries) / transactions
-- Prepared statements with `?` placeholders
-- MySQL type-name aliases + `db.table` cross-database syntax + `SHOW TABLES FROM db`
-
-**MySQL Server & CLI**
-- MySQL protocol server (TCP 3306), compatible with `mysql`/`mysql2`/GUI clients
-- Multi-database (one dir per DB), auto-create on connect / on `db.table` usage, default-DB fallback for one-click `CREATE TABLE`
-- Multi-user authentication with per-database access lists (`1044`/`1049` enforcement)
-- `jsql server start/stop/status` background daemon with graceful shutdown
-
-**Data API**
-- Typed schema with constraints: PK / auto-increment / unique / required / length / default / FK / CHECK / computed fields
-- Batch insert / update / delete, cursor-based pagination, upsert
-- Transactions with snapshot rollback (default `REPEATABLE_READ`)
-- CSV import/export, JSON schema validation, soft delete, versioning, views, triggers, attachable databases
-- Hooks & change events (`beforeInsert`/`afterUpdate`/…) for plugins and audit
-
-**Security**
-- SQL injection hardening: comments/`LOAD_FILE`/dangerous statements blocked by default, ReDoS-safe regex
-- Rate-limited auth (max auth fails), oversized-row protection, safe name/path validation (`..` blocked)
+- Three engines: Native (N-API Rust), WASM (wasm-pack Rust), Pure JS (local JSON)
+- SQL engine with prepared statements
+- Redis-style hybrid/disk storage: memory-first + async flush + LRU eviction + lazy reload
+- O(1) primary key hash index (`FxHashMap` / `Map`)
+- B-Tree indexing for range queries
+- WAL + snapshot crash recovery (server engine)
+- Batch insert / update / delete
+- Cursor-based pagination
+- Transaction support (server engine)

package/lib/mysql_server.js

@@ -8,7 +8,7 @@ const net = require('net');
 const crypto = require('crypto');
 const path = require('path');
 const fs = require('fs');
-const { executeSQL, parseSQL, splitStatements } = require('./sql');
+const { executeSQL, parseSQL, splitStatements, applyParams } = require('./sql');
 const Database = require('./database');
 
 const SERVER_VERSION = '8.0.0-jsql-neo';
@@ -62,6 +62,13 @@ function parseLenenc(buf, offset) {
   return { value: buf.readUInt32LE(offset + 1), size: 5 };
 }
 
+function readLenenc(buf, offset) {
+  const { value, size } = parseLenenc(buf, offset);
+  if (value === null) return { value: null, off: offset + size };
+  const str = buf.slice(offset + size, offset + size + value).toString('utf8');
+  return { value: str, off: offset + size + value };
+}
+
 class PacketBuilder {
   constructor() {
     this.bufs = [];
@@ -224,6 +231,100 @@ function resultSetPacket(result, tableSchema, baseSeq, rawRow) {
   return { packets, sequence };
 }
 
+function binaryResultSetPacket(result, tableSchema, baseSeq) {
+  const packets = [];
+  let sequence = baseSeq || 0;
+  const push = (buf) => {
+    const header = Buffer.alloc(4);
+    header.writeUIntLE(buf.length, 0, 3);
+    header[3] = sequence;
+    sequence++;
+    packets.push(header);
+    packets.push(buf);
+  };
+
+  const inferType = (name, value) => {
+    if (tableSchema && tableSchema[name]) return columnTypeFromSchema(tableSchema[name]);
+    if (value === null || value === undefined) return MYSQL_TYPE_NULL;
+    if (typeof value === 'number') return Number.isInteger(value) ? MYSQL_TYPE_LONGLONG : MYSQL_TYPE_DOUBLE;
+    if (typeof value === 'boolean') return MYSQL_TYPE_TINY;
+    if (typeof value === 'object') return MYSQL_TYPE_JSON;
+    return MYSQL_TYPE_VAR_STRING;
+  };
+
+  const cols = result.columns || [];
+  push(encodeLenenc(cols.length));
+  const sampleRow = (result.rows && result.rows[0]) || null;
+  const types = [];
+  for (let ci = 0; ci < cols.length; ci++) {
+    let sample;
+    if (sampleRow !== null) {
+      if (Array.isArray(sampleRow)) sample = sampleRow[ci];
+      else sample = sampleRow[cols[ci]];
+    }
+    const t = inferType(cols[ci], sample);
+    types.push(t);
+    push(columnDefinition({ name: cols[ci], table: result.table || '', type: t, length: 1024 }));
+  }
+  push(eofPacket());
+
+  const encodeValue = (v, type) => {
+    if (v === null || v === undefined) return null;
+    if (type === MYSQL_TYPE_LONG || type === MYSQL_TYPE_LONGLONG || type === MYSQL_TYPE_DOUBLE) {
+      const num = Number(v);
+      if (type === MYSQL_TYPE_DOUBLE) {
+        const b = Buffer.alloc(8); b.writeDoubleLE(num, 0); return b;
+      }
+      if (Number.isInteger(num) && num <= 2147483647 && num >= -2147483648) {
+        const b = Buffer.alloc(4); b.writeInt32LE(num, 0); return b;
+      }
+      const b = Buffer.alloc(8); b.writeBigInt64LE(BigInt(Math.trunc(num)), 0); return b;
+    }
+    if (type === MYSQL_TYPE_TINY) {
+      const b = Buffer.alloc(1); b.writeInt8(v ? 1 : 0, 0); return b;
+    }
+    if (type === MYSQL_TYPE_DATE || type === MYSQL_TYPE_DATETIME) {
+      const s = String(v);
+      const m = s.match(/^(\d{4})-(\d{2})-(\d{2})(?:[ T](\d{2}):(\d{2}):(\d{2}))?/);
+      if (!m) return encodeLenencString(String(v));
+      const hasTime = !!m[4];
+      const buf = hasTime ? Buffer.alloc(8) : Buffer.alloc(5);
+      let off = 0;
+      buf[off++] = hasTime ? 7 : 4;
+      buf.writeUInt16LE(parseInt(m[1], 10), off); off += 2;
+      buf[off++] = parseInt(m[2], 10);
+      buf[off++] = parseInt(m[3], 10);
+      if (hasTime) {
+        buf[off++] = parseInt(m[4], 10);
+        buf[off++] = parseInt(m[5], 10);
+        buf[off++] = parseInt(m[6], 10);
+      }
+      return buf;
+    }
+    return encodeLenencString(typeof v === 'object' ? JSON.stringify(v) : v);
+  };
+
+  for (const row of result.rows || []) {
+    const parts = [Buffer.from([0x00])];
+    const nb = Buffer.alloc(Math.ceil(cols.length / 8));
+    const encoded = [];
+    for (let i = 0; i < cols.length; i++) {
+      const v = Array.isArray(row) ? row[i] : row[cols[i]];
+      if (v === null || v === undefined) {
+        nb[Math.floor(i / 8)] |= (1 << (i % 8));
+        encoded.push(null);
+      } else {
+        encoded.push(encodeValue(v, types[i]));
+      }
+    }
+    parts.push(nb);
+    for (const e of encoded) if (e !== null) parts.push(e);
+    push(Buffer.concat(parts));
+  }
+  push(eofPacket());
+  return { packets, sequence };
+}
+
 class MysqlConnection {
   constructor(socket, server) {
     this.socket = socket;
@@ -236,6 +337,8 @@ class MysqlConnection {
     this.user = null;
     this.authFails = 0;
     this.multiStatements = false;
+    this._stmts = new Map();
+    this._stmtSeq = 0;
     if (server.handshakeTimeout > 0) {
       this._authTimer = setTimeout(() => {
         if (!this.authenticated) {
@@ -335,6 +438,11 @@ class MysqlConnection {
         case 0x11: this._handleChangeUser(body, cmdSeq); break; // COM_CHANGE_USER
         case 0x0e: this._send(okPacket()); break; // COM_PING
         case 0x1f: this._send(okPacket()); break; // COM_RESET_CONNECTION
+        case 0x16: this._handleStmtPrepare(body); break; // COM_STMT_PREPARE
+        case 0x17: this._handleStmtExecute(body); break; // COM_STMT_EXECUTE
+        case 0x18: break; // COM_STMT_SEND_LONG_DATA (忽略)
+        case 0x19: this._handleStmtClose(body); break; // COM_STMT_CLOSE
+        case 0x1a: this._send(okPacket()); break; // COM_STMT_RESET
         case 0x0a: { // COM_PROCESS_INFO
           const seq = this.sequence;
           this.sequence = (this.sequence + 1) & 0xff;
@@ -474,10 +582,173 @@ class MysqlConnection {
     }
   }
 
-  _handleQuery(sql) {
+  countPlaceholders(sql) {
+    let n = 0;
+    let inStr = null;
+    for (let i = 0; i < sql.length; i++) {
+      const c = sql[i];
+      if (inStr) {
+        if (c === '\\' && i + 1 < sql.length) { i++; continue; }
+        if (c === inStr) inStr = null;
+        continue;
+      }
+      if (c === "'" || c === '"' || c === '`') { inStr = c; continue; }
+      if (c === '?' && sql[i + 1] === '?') { i++; continue; }
+      if (c === '?') n++;
+    }
+    return n;
+  }
+
+  _handleStmtPrepare(body) {
+    try {
+      const sql = body.toString('utf8');
+      const numParams = this.countPlaceholders(sql);
+      let numColumns = 0;
+      try {
+        const stmt = parseSQL(sql);
+        if (stmt && stmt.type === 'select' && stmt.columns) numColumns = stmt.columns.length;
+      } catch (e) { /* 无法解析的 SQL 仍可 prepare */ }
+      const stmtId = ++this._stmtSeq;
+      this._stmts.set(stmtId, { sql, numParams, numColumns });
+
+      const pkt = Buffer.alloc(12);
+      let off = 0;
+      pkt[off++] = 0x00;
+      pkt.writeUInt32LE(stmtId, off); off += 4;
+      pkt.writeUInt16LE(numColumns, off); off += 2;
+      pkt.writeUInt16LE(numParams, off); off += 2;
+      pkt[off++] = 0x00;
+      pkt.writeUInt16LE(0, off);
+      this._send(pkt);
+
+      if (numParams > 0) {
+        for (let i = 0; i < numParams; i++) {
+          this._send(columnDefinition({ name: '?', type: MYSQL_TYPE_VAR_STRING }));
+        }
+        this._send(eofPacket());
+      }
+      if (numColumns > 0) {
+        for (let i = 0; i < numColumns; i++) {
+          this._send(columnDefinition({ name: 'col' + (i + 1), type: MYSQL_TYPE_VAR_STRING }));
+        }
+        this._send(eofPacket());
+      }
+    } catch (e) {
+      this._send(errPacket(toMysqlErrno(e), e.message));
+    }
+  }
+
+  _handleStmtClose(body) {
+    if (body.length >= 4) {
+      const stmtId = body.readUInt32LE(0);
+      this._stmts.delete(stmtId);
+    }
+  }
+
+  _handleStmtExecute(body) {
+    try {
+      if (body.length < 9) throw new Error('malformed COM_STMT_EXECUTE');
+      const stmtId = body.readUInt32LE(0);
+      const stmt = this._stmts.get(stmtId);
+      if (!stmt) {
+        this._send(errPacket(1243, 'Unknown prepared statement handler (' + stmtId + ') given to mysqld_stmt_execute'));
+        return;
+      }
+      const flags = body[4];
+      const iteration = body.readUInt32LE(5);
+      let values = null;
+      if (stmt.numParams > 0) {
+        let off = 9;
+        const numParams = stmt.numParams;
+        const nullBitmapLen = Math.ceil(numParams / 8);
+        if (body.length < off + nullBitmapLen) throw new Error('malformed COM_STMT_EXECUTE params');
+        const nullBitmap = body.slice(off, off + nullBitmapLen);
+        off += nullBitmapLen;
+        if (off >= body.length) throw new Error('malformed COM_STMT_EXECUTE params');
+        const newParamsBound = body[off];
+        off += 1;
+        let types = stmt.types;
+        if (newParamsBound & 0x01) {
+          if (body.length < off + numParams * 2) throw new Error('malformed COM_STMT_EXECUTE types');
+          types = [];
+          for (let i = 0; i < numParams; i++) types.push(body.readUInt16LE(off + i * 2));
+          stmt.types = types;
+          off += numParams * 2;
+        }
+        if (!types) throw new Error('Parameter types unknown for prepared statement');
+        values = [];
+        for (let i = 0; i < numParams; i++) {
+          const isNull = nullBitmap[Math.floor(i / 8)] & (1 << (i % 8));
+          if (isNull) { values.push(null); continue; }
+          const type = types[i] & 0xff;
+          const parsed = this._readParamValue(body, off, type);
+          values.push(parsed.value);
+          off = parsed.off;
+        }
+      }
+      this._handleQuery(stmt.sql, values !== null && values.length > 0 ? values : undefined);
+    } catch (e) {
+      this._send(errPacket(toMysqlErrno(e), e.message));
+    }
+  }
+
+  _readParamValue(buf, off, type) {
+    switch (type) {
+      case MYSQL_TYPE_NULL: return { value: null, off };
+      case 0x01: { const v = buf.readInt8(off); return { value: v, off: off + 1 }; } // TINY
+      case 0x02: { const v = buf.readInt16LE(off); return { value: v, off: off + 2 }; } // SHORT
+      case 0x03: { const v = buf.readInt32LE(off); return { value: v, off: off + 4 }; } // LONG
+      case 0x08: { const v = buf.readBigInt64LE(off); return { value: Number(v), off: off + 8 }; } // LONGLONG
+      case 0x04: { const v = buf.readFloatLE(off); return { value: v, off: off + 4 }; } // FLOAT
+      case MYSQL_TYPE_DOUBLE: { const v = buf.readDoubleLE(off); return { value: v, off: off + 8 }; }
+      case 0x0a: case 0x07: case 0x0b: case MYSQL_TYPE_DATETIME: { // DATE/TIMESTAMP/DATETIME/TIME
+        const len = buf[off];
+        off += 1;
+        if (len === 0) return { value: null, off };
+        let value;
+        if (type === 0x0b) { // TIME
+          let sign = 1;
+          let p = off;
+          if (buf[p] !== 0) sign = -1;
+          p += 1;
+          const days = buf.readUInt32LE(p); p += 4;
+          const hour = buf[p++];
+          const min = buf[p++];
+          const sec = buf[p++];
+          value = sign * (days * 24 + hour) + ':' + String(min).padStart(2, '0') + ':' + String(sec).padStart(2, '0');
+        } else {
+          let p = off;
+          const year = buf.readUInt16LE(p); p += 2;
+          const month = buf[p++];
+          const day = buf[p++];
+          let hour = 0, minute = 0, second = 0;
+          if (len >= 7) { hour = buf[p++]; minute = buf[p++]; second = buf[p++]; }
+          value = String(year).padStart(4, '0') + '-' + String(month).padStart(2, '0') + '-' + String(day).padStart(2, '0');
+          if (len >= 7) value += ' ' + String(hour).padStart(2, '0') + ':' + String(minute).padStart(2, '0') + ':' + String(second).padStart(2, '0');
+        }
+        off += len;
+        return { value, off };
+      }
+      case 0xfc: case 0xfd: case 0xfe: case 0xf9: case 0xf6: { // BLOB / VAR_STRING / STRING / ...
+        const { value, off: noff } = readLenenc(buf, off);
+        return { value, off: noff };
+      }
+      case 0xf0: { // NULL
+        return { value: null, off };
+      }
+      default: {
+        const { value, off: noff } = readLenenc(buf, off);
+        return { value, off: noff };
+      }
+    }
+  }
+
+  _handleQuery(sql, values) {
     (async () => {
       try {
-        const statements = splitStatements(sql);
+        const hasParams = values !== undefined && values !== null && values.length > 0;
+        const processedSql = hasParams ? applyParams(sql, values) : sql;
+        const statements = splitStatements(processedSql);
         if (statements.length > 1 && !this.multiStatements) {
           throw new Error(`too many statements (${statements.length} > 1)`);
         }
@@ -534,14 +805,18 @@ class MysqlConnection {
             safety: this.server.safety,
             maxStatements: 1,
           });
-          if (r.type === 'select' || r.type === 'showTables' || r.type === 'showDatabases' || r.type === 'describe') {
+          if (r.type === 'select' || r.type === 'showTables' || r.type === 'showDatabases' || r.type === 'describe'
+            || r.type === 'showColumns' || r.type === 'showIndex' || r.type === 'showCreateTable'
+            || r.type === 'showVariables' || r.type === 'showStatus' || r.type === 'showGrants' || r.type === 'showWarnings') {
             let schema = null;
             if (r.table) {
               schema = engine.getTableSchema
                 ? await engine.getTableSchema(r.table)
                 : (engine._schemas ? engine._schemas[r.table] : null);
             }
-            const { packets, sequence } = resultSetPacket(r, schema, this.sequence);
+            const { packets, sequence } = hasParams
+              ? binaryResultSetPacket(r, schema, this.sequence)
+              : resultSetPacket(r, schema, this.sequence);
             this.sequence = sequence;
             this.socket.write(Buffer.concat(packets));
           } else {
@@ -630,6 +905,10 @@ class MysqlServer {
       }
     };
     collect(stmt);
+    const isInfoSchema = tables.some(t => t && String(t).toLowerCase().startsWith('information_schema.'));
+    if (isInfoSchema) {
+      return { engine: await this._getEngine(currentDb), sql };
+    }
     let db = null;
     for (const t of tables) {
       if (t && t.indexOf('.') !== -1) {