orcaq 1.0.32 → 1.1.1

package/.output/server/node_modules/mysql2/lib/packets/binary_row.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const Types = require('../constants/types');
+const Packet = require('../packets/packet');
+
+const binaryReader = new Array(256);
+
+class BinaryRow {
+  constructor(columns) {
+    this.columns = columns || [];
+  }
+
+  static toPacket(columns, encoding) {
+    // throw new Error('Not implemented');
+    const sequenceId = 0; // TODO remove, this is calculated now in connecton
+    let length = 0;
+    columns.forEach((val) => {
+      if (val === null || typeof val === 'undefined') {
+        ++length;
+        return;
+      }
+      length += Packet.lengthCodedStringLength(val.toString(10), encoding);
+    });
+
+    length = length + 2;
+
+    const buffer = Buffer.allocUnsafe(length + 4);
+    const packet = new Packet(sequenceId, buffer, 0, length + 4);
+    packet.offset = 4;
+
+    packet.writeInt8(0);
+
+    let bitmap = 0;
+    let bitValue = 1;
+    columns.forEach((parameter) => {
+      if (parameter.type === Types.NULL) {
+        bitmap += bitValue;
+      }
+      bitValue *= 2;
+      if (bitValue === 256) {
+        packet.writeInt8(bitmap);
+        bitmap = 0;
+        bitValue = 1;
+      }
+    });
+    if (bitValue !== 1) {
+      packet.writeInt8(bitmap);
+    }
+
+    columns.forEach((val) => {
+      if (val === null) {
+        packet.writeNull();
+        return;
+      }
+      if (typeof val === 'undefined') {
+        packet.writeInt8(0);
+        return;
+      }
+      packet.writeLengthCodedString(val.toString(10), encoding);
+    });
+    return packet;
+  }
+
+  // TODO: complete list of types...
+  static fromPacket(fields, packet) {
+    const columns = new Array(fields.length);
+    packet.readInt8(); // TODO check it's 0
+    const nullBitmapLength = Math.floor((fields.length + 7 + 2) / 8);
+    // TODO: read and interpret null bitmap
+    packet.skip(nullBitmapLength);
+    for (let i = 0; i < columns.length; ++i) {
+      columns[i] = binaryReader[fields[i].columnType].apply(packet);
+    }
+    return new BinaryRow(columns);
+  }
+}
+
+// TODO: replace with constants.MYSQL_TYPE_*
+binaryReader[Types.DECIMAL] = Packet.prototype.readLengthCodedString;
+binaryReader[1] = Packet.prototype.readInt8; // tiny
+binaryReader[2] = Packet.prototype.readInt16; // short
+binaryReader[3] = Packet.prototype.readInt32; // long
+binaryReader[4] = Packet.prototype.readFloat; // float
+binaryReader[5] = Packet.prototype.readDouble; // double
+binaryReader[6] = Packet.prototype.assertInvalid; // null, should be skipped vie null bitmap
+binaryReader[7] = Packet.prototype.readTimestamp; // timestamp, http://dev.mysql.com/doc/internals/en/prepared-statements.html#packet-ProtocolBinary::MYSQL_TYPE_TIMESTAMP
+binaryReader[8] = Packet.prototype.readInt64; // long long
+binaryReader[9] = Packet.prototype.readInt32; // int24
+binaryReader[10] = Packet.prototype.readTimestamp; // date
+binaryReader[11] = Packet.prototype.readTime; // time, http://dev.mysql.com/doc/internals/en/prepared-statements.html#packet-ProtocolBinary::MYSQL_TYPE_TIME
+binaryReader[12] = Packet.prototype.readDateTime; // datetime, http://dev.mysql.com/doc/internals/en/prepared-statements.html#packet-ProtocolBinary::MYSQL_TYPE_DATETIME
+binaryReader[13] = Packet.prototype.readInt16; // year
+binaryReader[Types.VAR_STRING] = Packet.prototype.readLengthCodedString; // var string
+
+module.exports = BinaryRow;

package/.output/server/node_modules/mysql2/lib/packets/binlog_dump.js

@@ -0,0 +1,33 @@
+'use strict';
+
+// http://dev.mysql.com/doc/internals/en/com-binlog-dump.html#packet-COM_BINLOG_DUMP
+
+const Packet = require('../packets/packet');
+const CommandCodes = require('../constants/commands');
+
+// TODO: add flag to constants
+// 0x01 - BINLOG_DUMP_NON_BLOCK
+// send EOF instead of blocking
+class BinlogDump {
+  constructor(opts) {
+    this.binlogPos = opts.binlogPos || 0;
+    this.serverId = opts.serverId || 0;
+    this.flags = opts.flags || 0;
+    this.filename = opts.filename || '';
+  }
+
+  toPacket() {
+    const length = 15 + Buffer.byteLength(this.filename, 'utf8'); // TODO: should be ascii?
+    const buffer = Buffer.allocUnsafe(length);
+    const packet = new Packet(0, buffer, 0, length);
+    packet.offset = 4;
+    packet.writeInt8(CommandCodes.BINLOG_DUMP);
+    packet.writeInt32(this.binlogPos);
+    packet.writeInt16(this.flags);
+    packet.writeInt32(this.serverId);
+    packet.writeString(this.filename);
+    return packet;
+  }
+}
+
+module.exports = BinlogDump;

package/.output/server/node_modules/mysql2/lib/packets/binlog_query_statusvars.js

@@ -0,0 +1,115 @@
+'use strict';
+
+// http://dev.mysql.com/doc/internals/en/query-event.html
+
+const keys = {
+  FLAGS2: 0,
+  SQL_MODE: 1,
+  CATALOG: 2,
+  AUTO_INCREMENT: 3,
+  CHARSET: 4,
+  TIME_ZONE: 5,
+  CATALOG_NZ: 6,
+  LC_TIME_NAMES: 7,
+  CHARSET_DATABASE: 8,
+  TABLE_MAP_FOR_UPDATE: 9,
+  MASTER_DATA_WRITTEN: 10,
+  INVOKERS: 11,
+  UPDATED_DB_NAMES: 12,
+  MICROSECONDS: 3,
+};
+
+module.exports = function parseStatusVars(buffer) {
+  const result = {};
+  let offset = 0;
+  let key, length, prevOffset;
+  while (offset < buffer.length) {
+    key = buffer[offset++];
+    switch (key) {
+      case keys.FLAGS2:
+        result.flags = buffer.readUInt32LE(offset);
+        offset += 4;
+        break;
+      case keys.SQL_MODE:
+        // value is 8 bytes, but all dcumented flags are in first 4 bytes
+        result.sqlMode = buffer.readUInt32LE(offset);
+        offset += 8;
+        break;
+      case keys.CATALOG:
+        length = buffer[offset++];
+        result.catalog = buffer.toString('utf8', offset, offset + length);
+        offset += length + 1; // null byte after string
+        break;
+      case keys.CHARSET:
+        result.clientCharset = buffer.readUInt16LE(offset);
+        result.connectionCollation = buffer.readUInt16LE(offset + 2);
+        result.serverCharset = buffer.readUInt16LE(offset + 4);
+        offset += 6;
+        break;
+      case keys.TIME_ZONE:
+        length = buffer[offset++];
+        result.timeZone = buffer.toString('utf8', offset, offset + length);
+        offset += length; // no null byte
+        break;
+      case keys.CATALOG_NZ:
+        length = buffer[offset++];
+        result.catalogNz = buffer.toString('utf8', offset, offset + length);
+        offset += length; // no null byte
+        break;
+      case keys.LC_TIME_NAMES:
+        result.lcTimeNames = buffer.readUInt16LE(offset);
+        offset += 2;
+        break;
+      case keys.CHARSET_DATABASE:
+        result.schemaCharset = buffer.readUInt16LE(offset);
+        offset += 2;
+        break;
+      case keys.TABLE_MAP_FOR_UPDATE:
+        result.mapForUpdate1 = buffer.readUInt32LE(offset);
+        result.mapForUpdate2 = buffer.readUInt32LE(offset + 4);
+        offset += 8;
+        break;
+      case keys.MASTER_DATA_WRITTEN:
+        result.masterDataWritten = buffer.readUInt32LE(offset);
+        offset += 4;
+        break;
+      case keys.INVOKERS:
+        length = buffer[offset++];
+        result.invokerUsername = buffer.toString(
+          'utf8',
+          offset,
+          offset + length
+        );
+        offset += length;
+        length = buffer[offset++];
+        result.invokerHostname = buffer.toString(
+          'utf8',
+          offset,
+          offset + length
+        );
+        offset += length;
+        break;
+      case keys.UPDATED_DB_NAMES:
+        length = buffer[offset++];
+        // length - number of null-terminated strings
+        result.updatedDBs = []; // we'll store them as array here
+        for (; length; --length) {
+          prevOffset = offset;
+          // fast forward to null terminating byte
+          while (buffer[offset++] && offset < buffer.length) {
+            // empty body, everything inside while condition
+          }
+          result.updatedDBs.push(
+            buffer.toString('utf8', prevOffset, offset - 1)
+          );
+        }
+        break;
+      case keys.MICROSECONDS:
+        result.microseconds =
+          // REVIEW: INVALID UNKNOWN VARIABLE!
+          buffer.readInt16LE(offset) + (buffer[offset + 2] << 16);
+        offset += 3;
+    }
+  }
+  return result;
+};

package/.output/server/node_modules/mysql2/lib/packets/change_user.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const CommandCode = require('../constants/commands.js');
+const ClientConstants = require('../constants/client.js');
+const Packet = require('../packets/packet.js');
+const auth41 = require('../auth_41.js');
+const CharsetToEncoding = require('../constants/charset_encodings.js');
+
+// https://dev.mysql.com/doc/internals/en/com-change-user.html#packet-COM_CHANGE_USER
+class ChangeUser {
+  constructor(opts) {
+    this.flags = opts.flags;
+    this.user = opts.user || '';
+    this.database = opts.database || '';
+    this.password = opts.password || '';
+    this.passwordSha1 = opts.passwordSha1;
+    this.authPluginData1 = opts.authPluginData1;
+    this.authPluginData2 = opts.authPluginData2;
+    this.connectAttributes = opts.connectAttrinutes || {};
+    let authToken;
+    if (this.passwordSha1) {
+      authToken = auth41.calculateTokenFromPasswordSha(
+        this.passwordSha1,
+        this.authPluginData1,
+        this.authPluginData2
+      );
+    } else {
+      authToken = auth41.calculateToken(
+        this.password,
+        this.authPluginData1,
+        this.authPluginData2
+      );
+    }
+    this.authToken = authToken;
+    this.charsetNumber = opts.charsetNumber;
+  }
+
+  // TODO
+  // ChangeUser.fromPacket = function(packet)
+  // };
+  serializeToBuffer(buffer) {
+    const isSet = (flag) => this.flags & ClientConstants[flag];
+    const packet = new Packet(0, buffer, 0, buffer.length);
+    packet.offset = 4;
+    const encoding = CharsetToEncoding[this.charsetNumber];
+    packet.writeInt8(CommandCode.CHANGE_USER);
+    packet.writeNullTerminatedString(this.user, encoding);
+    if (isSet('SECURE_CONNECTION')) {
+      packet.writeInt8(this.authToken.length);
+      packet.writeBuffer(this.authToken);
+    } else {
+      packet.writeBuffer(this.authToken);
+      packet.writeInt8(0);
+    }
+    packet.writeNullTerminatedString(this.database, encoding);
+    packet.writeInt16(this.charsetNumber);
+    if (isSet('PLUGIN_AUTH')) {
+      // TODO: read this from parameters
+      packet.writeNullTerminatedString('mysql_native_password', 'latin1');
+    }
+    if (isSet('CONNECT_ATTRS')) {
+      const connectAttributes = this.connectAttributes;
+      const attrNames = Object.keys(connectAttributes);
+      let keysLength = 0;
+      for (let k = 0; k < attrNames.length; ++k) {
+        keysLength += Packet.lengthCodedStringLength(attrNames[k], encoding);
+        keysLength += Packet.lengthCodedStringLength(
+          connectAttributes[attrNames[k]],
+          encoding
+        );
+      }
+      packet.writeLengthCodedNumber(keysLength);
+      for (let k = 0; k < attrNames.length; ++k) {
+        packet.writeLengthCodedString(attrNames[k], encoding);
+        packet.writeLengthCodedString(
+          connectAttributes[attrNames[k]],
+          encoding
+        );
+      }
+    }
+    return packet;
+  }
+
+  toPacket() {
+    if (typeof this.user !== 'string') {
+      throw new Error('"user" connection config property must be a string');
+    }
+    if (typeof this.database !== 'string') {
+      throw new Error('"database" connection config property must be a string');
+    }
+    // dry run: calculate resulting packet length
+    const p = this.serializeToBuffer(Packet.MockBuffer());
+    return this.serializeToBuffer(Buffer.allocUnsafe(p.offset));
+  }
+}
+
+module.exports = ChangeUser;

package/.output/server/node_modules/mysql2/lib/packets/close_statement.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const Packet = require('../packets/packet');
+const CommandCodes = require('../constants/commands');
+
+class CloseStatement {
+  constructor(id) {
+    this.id = id;
+  }
+
+  // note: no response sent back
+  toPacket() {
+    const packet = new Packet(0, Buffer.allocUnsafe(9), 0, 9);
+    packet.offset = 4;
+    packet.writeInt8(CommandCodes.STMT_CLOSE);
+    packet.writeInt32(this.id);
+    return packet;
+  }
+}
+
+module.exports = CloseStatement;

package/.output/server/node_modules/mysql2/lib/packets/column_definition.js

@@ -0,0 +1,291 @@
+'use strict';
+
+const Packet = require('../packets/packet');
+const StringParser = require('../parsers/string');
+const CharsetToEncoding = require('../constants/charset_encodings.js');
+
+const fields = ['catalog', 'schema', 'table', 'orgTable', 'name', 'orgName'];
+
+// creating JS string is relatively expensive (compared to
+// reading few bytes from buffer) because all string properties
+// except for name are unlikely to be used we postpone
+// string conversion until property access
+//
+// TODO: watch for integration benchmarks (one with real network buffer)
+// there could be bad side effect as keeping reference to a buffer makes it
+// sit in the memory longer (usually until final .query() callback)
+// Latest v8 perform much better in regard to bufferer -> string conversion,
+// at some point of time this optimisation might become unnecessary
+// see https://github.com/sidorares/node-mysql2/pull/137
+//
+class ColumnDefinition {
+  constructor(packet, clientEncoding) {
+    this._buf = packet.buffer;
+    this._clientEncoding = clientEncoding;
+    this._catalogLength = packet.readLengthCodedNumber();
+    this._catalogStart = packet.offset;
+    packet.offset += this._catalogLength;
+    this._schemaLength = packet.readLengthCodedNumber();
+    this._schemaStart = packet.offset;
+    packet.offset += this._schemaLength;
+    this._tableLength = packet.readLengthCodedNumber();
+    this._tableStart = packet.offset;
+    packet.offset += this._tableLength;
+    this._orgTableLength = packet.readLengthCodedNumber();
+    this._orgTableStart = packet.offset;
+    packet.offset += this._orgTableLength;
+    // name is always used, don't make it lazy
+    const _nameLength = packet.readLengthCodedNumber();
+    const _nameStart = packet.offset;
+    packet.offset += _nameLength;
+    this._orgNameLength = packet.readLengthCodedNumber();
+    this._orgNameStart = packet.offset;
+    packet.offset += this._orgNameLength;
+    packet.skip(1); //  length of the following fields (always 0x0c)
+    this.characterSet = packet.readInt16();
+    this.encoding = CharsetToEncoding[this.characterSet];
+    this.name = StringParser.decode(
+      this._buf,
+      this.encoding === 'binary' ? this._clientEncoding : this.encoding,
+      _nameStart,
+      _nameStart + _nameLength
+    );
+    this.columnLength = packet.readInt32();
+    this.columnType = packet.readInt8();
+    this.type = this.columnType;
+    this.flags = packet.readInt16();
+    this.decimals = packet.readInt8();
+  }
+
+  inspect() {
+    return {
+      catalog: this.catalog,
+      schema: this.schema,
+      name: this.name,
+      orgName: this.orgName,
+      table: this.table,
+      orgTable: this.orgTable,
+      characterSet: this.characterSet,
+      encoding: this.encoding,
+      columnLength: this.columnLength,
+      type: this.columnType,
+      flags: this.flags,
+      decimals: this.decimals,
+    };
+  }
+
+  [Symbol.for('nodejs.util.inspect.custom')](depth, inspectOptions, inspect) {
+    const Types = require('../constants/types.js');
+    const typeNames = [];
+    for (const t in Types) {
+      typeNames[Types[t]] = t;
+    }
+    const fiedFlags = require('../constants/field_flags.js');
+    const flagNames = [];
+    // TODO: respect inspectOptions.showHidden
+    //const inspectFlags = inspectOptions.showHidden ? this.flags : this.flags & ~fiedFlags.PRI_KEY;
+    const inspectFlags = this.flags;
+    for (const f in fiedFlags) {
+      if (inspectFlags & fiedFlags[f]) {
+        if (f === 'PRI_KEY') {
+          flagNames.push('PRIMARY KEY');
+        } else if (f === 'NOT_NULL') {
+          flagNames.push('NOT NULL');
+        } else if (f === 'BINARY') {
+          // ignore flag for now
+        } else if (f === 'MULTIPLE_KEY') {
+          // not sure if that should be part of inspection.
+          // in the schema usually this is part of index definition
+          // example: UNIQUE KEY `my_uniq_id` (`id_box_elements`,`id_router`)
+          // note that only first column has MULTIPLE_KEY flag set in this case
+          // so there is no good way of knowing that this is part of index just
+          // by looking at indifidual field flags
+        } else if (f === 'NO_DEFAULT_VALUE') {
+          // almost the same as NOT_NULL?
+        } else if (f === 'BLOB') {
+          // included in the type
+        } else if (f === 'UNSIGNED') {
+          // this should be first after type
+        } else if (f === 'TIMESTAMP') {
+          // timestamp flag is redundant for inspection - already included in type
+        } else if (f === 'ON_UPDATE_NOW') {
+          flagNames.push('ON UPDATE CURRENT_TIMESTAMP');
+        } else {
+          flagNames.push(f);
+        }
+      }
+    }
+
+    if (depth > 1) {
+      return inspect({
+        ...this.inspect(),
+        typeName: typeNames[this.columnType],
+        flags: flagNames,
+      });
+    }
+
+    const isUnsigned = this.flags & fiedFlags.UNSIGNED;
+
+    let typeName = typeNames[this.columnType];
+    if (typeName === 'BLOB') {
+      // TODO: check for non-utf8mb4 encoding
+      if (this.columnLength === 4294967295) {
+        typeName = 'LONGTEXT';
+      } else if (this.columnLength === 67108860) {
+        typeName = 'MEDIUMTEXT';
+      } else if (this.columnLength === 262140) {
+        typeName = 'TEXT';
+      } else if (this.columnLength === 1020) {
+        // 255*4
+        typeName = 'TINYTEXT';
+      } else {
+        typeName = `BLOB(${this.columnLength})`;
+      }
+    } else if (typeName === 'VAR_STRING') {
+      // TODO: check for non-utf8mb4 encoding
+      typeName = `VARCHAR(${Math.ceil(this.columnLength / 4)})`;
+    } else if (typeName === 'TINY') {
+      if (
+        (this.columnLength === 3 && isUnsigned) ||
+        (this.columnLength === 4 && !isUnsigned)
+      ) {
+        typeName = 'TINYINT';
+      } else {
+        typeName = `TINYINT(${this.columnLength})`;
+      }
+    } else if (typeName === 'LONGLONG') {
+      if (this.columnLength === 20) {
+        typeName = 'BIGINT';
+      } else {
+        typeName = `BIGINT(${this.columnLength})`;
+      }
+    } else if (typeName === 'SHORT') {
+      if (isUnsigned && this.columnLength === 5) {
+        typeName = 'SMALLINT';
+      } else if (!isUnsigned && this.columnLength === 6) {
+        typeName = 'SMALLINT';
+      } else {
+        typeName = `SMALLINT(${this.columnLength})`;
+      }
+    } else if (typeName === 'LONG') {
+      if (isUnsigned && this.columnLength === 10) {
+        typeName = 'INT';
+      } else if (!isUnsigned && this.columnLength === 11) {
+        typeName = 'INT';
+      } else {
+        typeName = `INT(${this.columnLength})`;
+      }
+    } else if (typeName === 'INT24') {
+      if (isUnsigned && this.columnLength === 8) {
+        typeName = 'MEDIUMINT';
+      } else if (!isUnsigned && this.columnLength === 9) {
+        typeName = 'MEDIUMINT';
+      } else {
+        typeName = `MEDIUMINT(${this.columnLength})`;
+      }
+    } else if (typeName === 'DOUBLE') {
+      // DOUBLE without modifiers is reported as DOUBLE(22, 31)
+      if (this.columnLength === 22 && this.decimals === 31) {
+        typeName = 'DOUBLE';
+      } else {
+        typeName = `DOUBLE(${this.columnLength},${this.decimals})`;
+      }
+    } else if (typeName === 'FLOAT') {
+      // FLOAT without modifiers is reported as FLOAT(12, 31)
+      if (this.columnLength === 12 && this.decimals === 31) {
+        typeName = 'FLOAT';
+      } else {
+        typeName = `FLOAT(${this.columnLength},${this.decimals})`;
+      }
+    } else if (typeName === 'NEWDECIMAL') {
+      if (this.columnLength === 11 && this.decimals === 0) {
+        typeName = 'DECIMAL';
+      } else if (this.decimals === 0) {
+        // not sure why, but DECIMAL(13) is reported as DECIMAL(14, 0)
+        // and DECIMAL(13, 9) is reported as NEWDECIMAL(15, 9)
+        if (isUnsigned) {
+          typeName = `DECIMAL(${this.columnLength})`;
+        } else {
+          typeName = `DECIMAL(${this.columnLength - 1})`;
+        }
+      } else {
+        typeName = `DECIMAL(${this.columnLength - 2},${this.decimals})`;
+      }
+    } else {
+      typeName = `${typeNames[this.columnType]}(${this.columnLength})`;
+    }
+
+    if (isUnsigned) {
+      typeName += ' UNSIGNED';
+    }
+
+    // TODO respect colors option
+    return `\`${this.name}\` ${[typeName, ...flagNames].join(' ')}`;
+  }
+
+  static toPacket(column, sequenceId) {
+    let length = 17; // = 4 padding + 1 + 12 for the rest
+    fields.forEach((field) => {
+      length += Packet.lengthCodedStringLength(
+        column[field],
+        CharsetToEncoding[column.characterSet]
+      );
+    });
+    const buffer = Buffer.allocUnsafe(length);
+
+    const packet = new Packet(sequenceId, buffer, 0, length);
+    function writeField(name) {
+      packet.writeLengthCodedString(
+        column[name],
+        CharsetToEncoding[column.characterSet]
+      );
+    }
+    packet.offset = 4;
+    fields.forEach(writeField);
+    packet.writeInt8(0x0c);
+    packet.writeInt16(column.characterSet);
+    packet.writeInt32(column.columnLength);
+    packet.writeInt8(column.columnType);
+    packet.writeInt16(column.flags);
+    packet.writeInt8(column.decimals);
+    packet.writeInt16(0); // filler
+    return packet;
+  }
+
+  // node-mysql compatibility: alias "db" to "schema"
+  get db() {
+    return this.schema;
+  }
+}
+
+const addString = function (name) {
+  Object.defineProperty(ColumnDefinition.prototype, name, {
+    get: function () {
+      const start = this[`_${name}Start`];
+      const end = start + this[`_${name}Length`];
+      const val = StringParser.decode(
+        this._buf,
+        this.encoding === 'binary' ? this._clientEncoding : this.encoding,
+        start,
+        end
+      );
+
+      Object.defineProperty(this, name, {
+        value: val,
+        writable: false,
+        configurable: false,
+        enumerable: false,
+      });
+
+      return val;
+    },
+  });
+};
+
+addString('catalog');
+addString('schema');
+addString('table');
+addString('orgTable');
+addString('orgName');
+
+module.exports = ColumnDefinition;