jsql-neo 4.2.0-beta.1 → 4.3.0

package/README.md

@@ -1,10 +1,7 @@
-# JSQL-NEO v4.1.1
+# JSQL-NEO v4.0.1
 
 Rust-powered embedded database with **three engines + SQL + 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)
-
 ## Engines
 
 | Engine | Entry | Use Case |
@@ -122,6 +119,39 @@ db.save();
 }
 ```
 
+## 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
 
 - Three engines: Native (N-API Rust), WASM (wasm-pack Rust), Pure JS (local JSON)

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) {