jsql-neo 4.2.0 → 4.4.0

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';
@@ -31,6 +31,7 @@ const MYSQL_TYPE_TINY = 1, MYSQL_TYPE_LONG = 3, MYSQL_TYPE_LONGLONG = 8,
   MYSQL_TYPE_JSON = 245, MYSQL_TYPE_NULL = 6;
 
 function encodeLenenc(value) {
+  if (typeof value === 'bigint') value = Number(value);
   if (value === null) return Buffer.from([0xfb]);
   if (value < 0xfb) return Buffer.from([value]);
   if (value <= 0xffff) {
@@ -62,6 +63,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 = [];
@@ -128,7 +136,38 @@ function toMysqlErrno(e) {
   if (e && typeof e.code === 'number') return e.code;
   const m = e && e.message ? String(e.message).match(/^(ER_[A-Z_]+)/) : null;
   if (m) {
-    const known = { ER_DUP_ENTRY: 1062, ER_NO_SUCH_TABLE: 1146, ER_TABLE_EXISTS: 1050, ER_PARSE_ERROR: 1064 };
+    const known = {
+      ER_DUP_ENTRY: 1062,
+      ER_NO_SUCH_TABLE: 1146,
+      ER_TABLE_EXISTS: 1050,
+      ER_TABLE_EXISTS_ERROR: 1050,
+      ER_PARSE_ERROR: 1064,
+      ER_BAD_FIELD_ERROR: 1054,
+      ER_BAD_NULL_ERROR: 1048,
+      ER_ACCESS_DENIED_ERROR: 1045,
+      ER_DBACCESS_DENIED_ERROR: 1044,
+      ER_BAD_DB_ERROR: 1049,
+      ER_WRONG_DB_NAME: 1102,
+      ER_WRONG_TABLE_NAME: 1103,
+      ER_WRONG_COLUMN_NAME: 1166,
+      ER_DATA_TOO_LONG: 1406,
+      ER_OUT_OF_RANGE: 1264,
+      ER_CHECK_CONSTRAINT: 3819,
+      ER_NO_DEFAULT_FOR_FIELD: 1364,
+      ER_CANT_DROP_FIELD_OR_KEY: 1091,
+      ER_CANT_DROP_DATABASE: 1008,
+      ER_EMPTY_QUERY: 1065,
+      ER_UNKNOWN_TABLE: 1109,
+      ER_NON_UNIQ_ERROR: 1052,
+      ER_WRONG_FIELD_WITH_GROUP: 1055,
+      ER_WRONG_VALUE_COUNT_ON_ROW: 1136,
+      ER_MISSING_TABLE: 1052,
+      ER_SP_DOES_NOT_EXIST: 1305,
+      ER_NOT_SUPPORTED_YET: 1235,
+      ER_LOCK_DEADLOCK: 1213,
+      ER_LOCK_WAIT_TIMEOUT: 1205,
+      ER_UNKNOWN_ERROR: 1105,
+    };
     if (known[m[1]]) return known[m[1]];
   }
   return 1105;
@@ -224,6 +263,102 @@ 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) {
+        if (!Number.isFinite(num)) return encodeLenencString(String(v));
+        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;
+      }
+      if (!Number.isFinite(num)) return encodeLenencString(String(v));
+      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 +371,16 @@ class MysqlConnection {
     this.user = null;
     this.authFails = 0;
     this.multiStatements = false;
+    this._stmts = new Map();
+    this._stmtSeq = 0;
+    this.session = {
+      lastInsertId: 0,
+      rowCount: 0,
+      foundRows: 0,
+      connectionId: server._connectionCounter,
+      currentDb: null,
+      sysvars: {},
+    };
     if (server.handshakeTimeout > 0) {
       this._authTimer = setTimeout(() => {
         if (!this.authenticated) {
@@ -335,6 +480,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 +624,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)`);
         }
@@ -533,18 +846,30 @@ class MysqlConnection {
             allowComments: this.server.allowComments,
             safety: this.server.safety,
             maxStatements: 1,
+            session: this.session,
           });
-          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') {
+            this.session.foundRows = (r.raw && r.raw.length !== undefined) ? r.raw.length : (r.rows ? r.rows.length : 0);
             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 {
+            if (r.type === 'insert') {
+              this.session.lastInsertId = r.insertId;
+              this.session.rowCount = r.affectedRows;
+            } else if (r.type === 'update' || r.type === 'delete' || r.type === 'truncate') {
+              this.session.rowCount = r.affectedRows;
+            }
             this._send(okPacket(r.affectedRows || 0, r.insertId || 0));
           }
         }
@@ -630,6 +955,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) {