orcaq 1.0.32 → 1.1.1

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

@@ -0,0 +1,27 @@
+'use strict';
+
+const Packet = require('../packets/packet');
+const CommandCodes = require('../constants/commands');
+const StringParser = require('../parsers/string.js');
+const CharsetToEncoding = require('../constants/charset_encodings.js');
+
+class PrepareStatement {
+  constructor(sql, charsetNumber) {
+    this.query = sql;
+    this.charsetNumber = charsetNumber;
+    this.encoding = CharsetToEncoding[charsetNumber];
+  }
+
+  toPacket() {
+    const buf = StringParser.encode(this.query, this.encoding);
+    const length = 5 + buf.length;
+    const buffer = Buffer.allocUnsafe(length);
+    const packet = new Packet(0, buffer, 0, length);
+    packet.offset = 4;
+    packet.writeInt8(CommandCodes.STMT_PREPARE);
+    packet.writeBuffer(buf);
+    return packet;
+  }
+}
+
+module.exports = PrepareStatement;

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

@@ -0,0 +1,16 @@
+'use strict';
+
+class PreparedStatementHeader {
+  constructor(packet) {
+    packet.skip(1); // should be 0
+    this.id = packet.readInt32();
+    this.fieldCount = packet.readInt16();
+    this.parameterCount = packet.readInt16();
+    packet.skip(1); // should be 0
+    this.warningCount = packet.readInt16();
+  }
+}
+
+// TODO: toPacket
+
+module.exports = PreparedStatementHeader;

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

@@ -0,0 +1,102 @@
+'use strict';
+
+const Packet = require('../packets/packet.js');
+const CommandCode = require('../constants/commands.js');
+const StringParser = require('../parsers/string.js');
+const CharsetToEncoding = require('../constants/charset_encodings.js');
+const ClientConstants = require('../constants/client.js');
+const Types = require('../constants/types.js');
+const { toParameter } = require('./encode_parameter.js');
+
+class Query {
+  constructor(sql, charsetNumber, attributes, clientFlags) {
+    this.query = sql;
+    this.charsetNumber = charsetNumber;
+    this.encoding = CharsetToEncoding[charsetNumber];
+    this.attributes = attributes;
+    this.clientFlags = clientFlags || 0;
+  }
+
+  serializeToBuffer(buffer) {
+    const useQueryAttributes =
+      this.clientFlags & ClientConstants.CLIENT_QUERY_ATTRIBUTES;
+    const sqlBuf = StringParser.encode(this.query, this.encoding);
+    const packet = new Packet(0, buffer, 0, buffer.length);
+    packet.offset = 4;
+    packet.writeInt8(CommandCode.QUERY);
+
+    if (useQueryAttributes) {
+      const attrs = this.attributes;
+      const names = attrs ? Object.keys(attrs) : [];
+      const paramCount = names.length;
+
+      packet.writeLengthCodedNumber(paramCount);
+      packet.writeLengthCodedNumber(1); // parameter_set_count, always 1
+
+      if (paramCount > 0) {
+        const parameters = names.map((name) =>
+          toParameter(attrs[name], this.encoding, 'local')
+        );
+
+        // null bitmap
+        let bitmap = 0;
+        let bitValue = 1;
+        parameters.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);
+        }
+
+        packet.writeInt8(1); // new_params_bind_flag
+
+        // types and names
+        for (let i = 0; i < paramCount; i++) {
+          packet.writeInt8(parameters[i].type);
+          packet.writeInt8(0); // unsigned flag
+          packet.writeLengthCodedString(names[i], this.encoding);
+        }
+
+        // values
+        parameters.forEach((parameter) => {
+          if (parameter.type !== Types.NULL) {
+            parameter.writer.call(packet, parameter.value);
+          }
+        });
+      }
+    }
+
+    packet.writeBuffer(sqlBuf);
+    return packet;
+  }
+
+  toPacket() {
+    const useQueryAttributes =
+      this.clientFlags & ClientConstants.CLIENT_QUERY_ATTRIBUTES;
+
+    if (!useQueryAttributes) {
+      const buf = StringParser.encode(this.query, this.encoding);
+      const length = 5 + buf.length;
+      const buffer = Buffer.allocUnsafe(length);
+      const packet = new Packet(0, buffer, 0, length);
+      packet.offset = 4;
+      packet.writeInt8(CommandCode.QUERY);
+      packet.writeBuffer(buf);
+      return packet;
+    }
+
+    // dry run to calculate required buffer length
+    const p = this.serializeToBuffer(Packet.MockBuffer());
+    return this.serializeToBuffer(Buffer.allocUnsafe(p.offset));
+  }
+}
+
+module.exports = Query;

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

@@ -0,0 +1,46 @@
+'use strict';
+
+// http://dev.mysql.com/doc/internals/en/com-register-slave.html
+// note that documentation is incorrect, for example command code is actually 0x15 but documented as 0x14
+
+const Packet = require('../packets/packet');
+const CommandCodes = require('../constants/commands');
+
+class RegisterSlave {
+  constructor(opts) {
+    this.serverId = opts.serverId || 0;
+    this.slaveHostname = opts.slaveHostname || '';
+    this.slaveUser = opts.slaveUser || '';
+    this.slavePassword = opts.slavePassword || '';
+    this.slavePort = opts.slavePort || 0;
+    this.replicationRank = opts.replicationRank || 0;
+    this.masterId = opts.masterId || 0;
+  }
+
+  toPacket() {
+    const length =
+      15 + // TODO: should be ascii?
+      Buffer.byteLength(this.slaveHostname, 'utf8') +
+      Buffer.byteLength(this.slaveUser, 'utf8') +
+      Buffer.byteLength(this.slavePassword, 'utf8') +
+      3 +
+      4;
+    const buffer = Buffer.allocUnsafe(length);
+    const packet = new Packet(0, buffer, 0, length);
+    packet.offset = 4;
+    packet.writeInt8(CommandCodes.REGISTER_SLAVE);
+    packet.writeInt32(this.serverId);
+    packet.writeInt8(Buffer.byteLength(this.slaveHostname, 'utf8'));
+    packet.writeString(this.slaveHostname);
+    packet.writeInt8(Buffer.byteLength(this.slaveUser, 'utf8'));
+    packet.writeString(this.slaveUser);
+    packet.writeInt8(Buffer.byteLength(this.slavePassword, 'utf8'));
+    packet.writeString(this.slavePassword);
+    packet.writeInt16(this.slavePort);
+    packet.writeInt32(this.replicationRank);
+    packet.writeInt32(this.masterId);
+    return packet;
+  }
+}
+
+module.exports = RegisterSlave;

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

@@ -0,0 +1,17 @@
+'use strict';
+
+const Packet = require('../packets/packet');
+const CommandCodes = require('../constants/commands');
+
+class ResetConnection {
+  constructor() {}
+
+  toPacket() {
+    const packet = new Packet(0, Buffer.alloc(5), 0, 5);
+    packet.offset = 4;
+    packet.writeInt8(CommandCodes.RESET_CONNECTION);
+    return packet;
+  }
+}
+
+module.exports = ResetConnection;

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

@@ -0,0 +1,124 @@
+'use strict';
+
+// TODO: rename to OK packet
+// https://dev.mysql.com/doc/internals/en/packet-OK_Packet.html
+
+const Packet = require('./packet.js');
+const ClientConstants = require('../constants/client.js');
+const ServerSatusFlags = require('../constants/server_status.js');
+
+const EncodingToCharset = require('../constants/encoding_charset.js');
+const sessionInfoTypes = require('../constants/session_track.js');
+
+class ResultSetHeader {
+  constructor(packet, connection) {
+    const bigNumberStrings = connection.config.bigNumberStrings;
+    const encoding = connection.serverEncoding;
+    const flags = connection._handshakePacket.capabilityFlags;
+    const isSet = function (flag) {
+      return flags & ClientConstants[flag];
+    };
+    if (packet.buffer[packet.offset] !== 0) {
+      this.fieldCount = packet.readLengthCodedNumber();
+      if (this.fieldCount === null) {
+        this.infileName = packet.readString(undefined, encoding);
+      }
+      return;
+    }
+    this.fieldCount = packet.readInt8(); // skip OK byte
+    this.affectedRows = packet.readLengthCodedNumber(bigNumberStrings);
+    this.insertId = packet.readLengthCodedNumberSigned(bigNumberStrings);
+    this.info = '';
+    if (isSet('PROTOCOL_41')) {
+      this.serverStatus = packet.readInt16();
+      this.warningStatus = packet.readInt16();
+    } else if (isSet('TRANSACTIONS')) {
+      this.serverStatus = packet.readInt16();
+    }
+    let stateChanges = null;
+    if (isSet('SESSION_TRACK') && packet.offset < packet.end) {
+      this.info = packet.readLengthCodedString(encoding);
+
+      if (this.serverStatus & ServerSatusFlags.SERVER_SESSION_STATE_CHANGED) {
+        // session change info record - see
+        // https://dev.mysql.com/doc/internals/en/packet-OK_Packet.html#cs-sect-packet-ok-sessioninfo
+        let len =
+          packet.offset < packet.end ? packet.readLengthCodedNumber() : 0;
+        const end = packet.offset + len;
+        let type, key, stateEnd;
+        if (len > 0) {
+          stateChanges = {
+            systemVariables: {},
+            schema: null,
+            gtids: [],
+            trackStateChange: null,
+          };
+        }
+        while (packet.offset < end) {
+          type = packet.readInt8();
+          len = packet.readLengthCodedNumber();
+          stateEnd = packet.offset + len;
+          if (type === sessionInfoTypes.SYSTEM_VARIABLES) {
+            key = packet.readLengthCodedString(encoding);
+            const val = packet.readLengthCodedString(encoding);
+            stateChanges.systemVariables[key] = val;
+            if (key === 'character_set_client') {
+              const charsetNumber = EncodingToCharset[val];
+              // TODO - better api for driver users to handle unknown encodings?
+              // maybe custom coverter in the config?
+              // For now just ignore character_set_client command if there is
+              // no known mapping from reported encoding to a charset code
+              if (typeof charsetNumber !== 'undefined') {
+                connection.config.charsetNumber = charsetNumber;
+              }
+            }
+          } else if (type === sessionInfoTypes.SCHEMA) {
+            key = packet.readLengthCodedString(encoding);
+            stateChanges.schema = key;
+          } else if (type === sessionInfoTypes.STATE_CHANGE) {
+            stateChanges.trackStateChange =
+              packet.readLengthCodedString(encoding);
+          } else if (type === sessionInfoTypes.STATE_GTIDS) {
+            // TODO: find if the first length coded string means anything. Usually comes as empty
+            // eslint-disable-next-line no-unused-vars
+            const _unknownString = packet.readLengthCodedString(encoding);
+            const gtid = packet.readLengthCodedString(encoding);
+            stateChanges.gtids = gtid.split(',');
+          } else {
+            // unsupported session track type. For now just ignore
+          }
+          packet.offset = stateEnd;
+        }
+      }
+    } else {
+      this.info = packet.readString(undefined, encoding);
+    }
+    if (stateChanges) {
+      this.stateChanges = stateChanges;
+    }
+    const m = this.info.match(/\schanged:\s*(\d+)/i);
+    if (m !== null) {
+      this.changedRows = parseInt(m[1], 10);
+    } else {
+      this.changedRows = 0;
+    }
+  }
+
+  // TODO: should be consistent instance member, but it's just easier here to have just function
+  static toPacket(fieldCount, insertId) {
+    let length = 4 + Packet.lengthCodedNumberLength(fieldCount);
+    if (typeof insertId !== 'undefined') {
+      length += Packet.lengthCodedNumberLength(insertId);
+    }
+    const buffer = Buffer.allocUnsafe(length);
+    const packet = new Packet(0, buffer, 0, length);
+    packet.offset = 4;
+    packet.writeLengthCodedNumber(fieldCount);
+    if (typeof insertId !== 'undefined') {
+      packet.writeLengthCodedNumber(insertId);
+    }
+    return packet;
+  }
+}
+
+module.exports = ResultSetHeader;

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

@@ -0,0 +1,25 @@
+'use strict';
+
+const ClientConstants = require('../constants/client');
+const Packet = require('../packets/packet');
+
+class SSLRequest {
+  constructor(flags, charset) {
+    this.clientFlags = flags | ClientConstants.SSL;
+    this.charset = charset;
+  }
+
+  toPacket() {
+    const length = 36;
+    const buffer = Buffer.allocUnsafe(length);
+    const packet = new Packet(0, buffer, 0, length);
+    buffer.fill(0);
+    packet.offset = 4;
+    packet.writeInt32(this.clientFlags);
+    packet.writeInt32(0); // max packet size. todo: move to config
+    packet.writeInt8(this.charset);
+    return packet;
+  }
+}
+
+module.exports = SSLRequest;

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

@@ -0,0 +1,47 @@
+'use strict';
+
+const Packet = require('../packets/packet');
+
+class TextRow {
+  constructor(columns) {
+    this.columns = columns || [];
+  }
+
+  static fromPacket(packet) {
+    // packet.reset(); // set offset to starting point?
+    const columns = [];
+    while (packet.haveMoreData()) {
+      columns.push(packet.readLengthCodedString());
+    }
+    return new TextRow(columns);
+  }
+
+  static toPacket(columns, encoding) {
+    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);
+    });
+    const buffer = Buffer.allocUnsafe(length + 4);
+    const packet = new Packet(sequenceId, buffer, 0, length + 4);
+    packet.offset = 4;
+    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;
+  }
+}
+
+module.exports = TextRow;

package/.output/server/node_modules/mysql2/lib/parsers/binary_parser.js

@@ -0,0 +1,235 @@
+'use strict';
+
+const FieldFlags = require('../constants/field_flags.js');
+const Charsets = require('../constants/charsets.js');
+const Types = require('../constants/types.js');
+const helpers = require('../helpers');
+const genFunc = require('generate-function');
+const parserCache = require('./parser_cache.js');
+const typeNames = [];
+for (const t in Types) {
+  typeNames[Types[t]] = t;
+}
+
+function readCodeFor(field, config, options, fieldNum) {
+  const supportBigNumbers = Boolean(
+    options.supportBigNumbers || config.supportBigNumbers
+  );
+  const bigNumberStrings = Boolean(
+    options.bigNumberStrings || config.bigNumberStrings
+  );
+  const timezone = options.timezone || config.timezone;
+  const dateStrings = options.dateStrings || config.dateStrings;
+  const unsigned = field.flags & FieldFlags.UNSIGNED;
+  switch (field.columnType) {
+    case Types.TINY:
+      return unsigned ? 'packet.readInt8();' : 'packet.readSInt8();';
+    case Types.SHORT:
+      return unsigned ? 'packet.readInt16();' : 'packet.readSInt16();';
+    case Types.LONG:
+    case Types.INT24: // in binary protocol int24 is encoded in 4 bytes int32
+      return unsigned ? 'packet.readInt32();' : 'packet.readSInt32();';
+    case Types.YEAR:
+      return 'packet.readInt16()';
+    case Types.FLOAT:
+      return 'packet.readFloat();';
+    case Types.DOUBLE:
+      return 'packet.readDouble();';
+    case Types.NULL:
+      return 'null;';
+    case Types.DATE:
+    case Types.DATETIME:
+    case Types.TIMESTAMP:
+    case Types.NEWDATE:
+      if (helpers.typeMatch(field.columnType, dateStrings, Types)) {
+        return `packet.readDateTimeString(${parseInt(field.decimals, 10)}, ${null}, ${field.columnType});`;
+      }
+      return `packet.readDateTime(${helpers.srcEscape(timezone)});`;
+    case Types.TIME:
+      return 'packet.readTimeString()';
+    case Types.DECIMAL:
+    case Types.NEWDECIMAL:
+      if (config.decimalNumbers) {
+        return 'packet.parseLengthCodedFloat();';
+      }
+      return 'packet.readLengthCodedString("ascii");';
+    case Types.GEOMETRY:
+      return 'packet.parseGeometryValue();';
+    case Types.VECTOR:
+      return 'packet.parseVector()';
+    case Types.JSON:
+      // Since for JSON columns mysql always returns charset 63 (BINARY),
+      // we have to handle it according to JSON specs and use "utf8",
+      // see https://github.com/sidorares/node-mysql2/issues/409
+      return config.jsonStrings
+        ? 'packet.readLengthCodedString("utf8")'
+        : 'JSON.parse(packet.readLengthCodedString("utf8"));';
+    case Types.LONGLONG:
+      if (!supportBigNumbers) {
+        return unsigned
+          ? 'packet.readInt64JSNumber();'
+          : 'packet.readSInt64JSNumber();';
+      }
+      if (bigNumberStrings) {
+        return unsigned
+          ? 'packet.readInt64String();'
+          : 'packet.readSInt64String();';
+      }
+      return unsigned ? 'packet.readInt64();' : 'packet.readSInt64();';
+
+    default:
+      if (field.characterSet === Charsets.BINARY) {
+        return 'packet.readLengthCodedBuffer();';
+      }
+      return `packet.readLengthCodedString(fields[${fieldNum}].encoding)`;
+  }
+}
+
+function compile(fields, options, config) {
+  const parserFn = genFunc();
+  const nullBitmapLength = Math.floor((fields.length + 7 + 2) / 8);
+
+  function wrap(field, packet) {
+    return {
+      type: typeNames[field.columnType],
+      length: field.columnLength,
+      db: field.schema,
+      table: field.table,
+      name: field.name,
+      string: function (encoding = field.encoding) {
+        if (field.columnType === Types.JSON && encoding === field.encoding) {
+          // Since for JSON columns mysql always returns charset 63 (BINARY),
+          // we have to handle it according to JSON specs and use "utf8",
+          // see https://github.com/sidorares/node-mysql2/issues/1661
+          console.warn(
+            `typeCast: JSON column "${field.name}" is interpreted as BINARY by default, recommended to manually set utf8 encoding: \`field.string("utf8")\``
+          );
+        }
+
+        if (
+          [Types.DATETIME, Types.NEWDATE, Types.TIMESTAMP, Types.DATE].includes(
+            field.columnType
+          )
+        ) {
+          return packet.readDateTimeString(
+            parseInt(field.decimals, 10),
+            ' ',
+            field.columnType
+          );
+        }
+
+        if (field.columnType === Types.TINY) {
+          const unsigned = field.flags & FieldFlags.UNSIGNED;
+
+          return String(unsigned ? packet.readInt8() : packet.readSInt8());
+        }
+
+        if (field.columnType === Types.TIME) {
+          return packet.readTimeString();
+        }
+
+        return packet.readLengthCodedString(encoding);
+      },
+      buffer: function () {
+        return packet.readLengthCodedBuffer();
+      },
+      geometry: function () {
+        return packet.parseGeometryValue();
+      },
+    };
+  }
+
+  parserFn('(function(){');
+  parserFn('return class BinaryRow {');
+  parserFn('constructor() {');
+  parserFn('}');
+
+  parserFn('next(packet, fields, options) {');
+  if (options.rowsAsArray) {
+    parserFn(`const result = new Array(${fields.length});`);
+  } else {
+    parserFn('const result = {};');
+  }
+
+  // Global typeCast
+  if (
+    typeof config.typeCast === 'function' &&
+    typeof options.typeCast !== 'function'
+  ) {
+    options.typeCast = config.typeCast;
+  }
+
+  parserFn('packet.readInt8();'); // status byte
+  for (let i = 0; i < nullBitmapLength; ++i) {
+    parserFn(`const nullBitmaskByte${i} = packet.readInt8();`);
+  }
+
+  let lvalue = '';
+  let currentFieldNullBit = 4;
+  let nullByteIndex = 0;
+  let fieldName = '';
+  let tableName = '';
+
+  for (let i = 0; i < fields.length; i++) {
+    fieldName = helpers.fieldEscape(fields[i].name);
+    // parserFn(`// ${fieldName}: ${typeNames[fields[i].columnType]}`);
+
+    if (typeof options.nestTables === 'string') {
+      lvalue = `result[${helpers.fieldEscape(fields[i].table + options.nestTables + fields[i].name)}]`;
+    } else if (options.nestTables === true) {
+      tableName = helpers.fieldEscape(fields[i].table);
+
+      parserFn(`if (!result[${tableName}]) result[${tableName}] = {};`);
+      lvalue = `result[${tableName}][${fieldName}]`;
+    } else if (options.rowsAsArray) {
+      lvalue = `result[${i.toString(10)}]`;
+    } else {
+      lvalue = `result[${fieldName}]`;
+    }
+
+    parserFn(`if (nullBitmaskByte${nullByteIndex} & ${currentFieldNullBit}) `);
+    parserFn(`${lvalue} = null;`);
+    parserFn('else {');
+
+    if (options.typeCast === false) {
+      parserFn(`${lvalue} = packet.readLengthCodedBuffer();`);
+    } else {
+      const fieldWrapperVar = `fieldWrapper${i}`;
+      parserFn(`const ${fieldWrapperVar} = wrap(fields[${i}], packet);`);
+      const readCode = readCodeFor(fields[i], config, options, i);
+
+      if (typeof options.typeCast === 'function') {
+        parserFn(
+          `${lvalue} = options.typeCast(${fieldWrapperVar}, function() { return ${readCode} });`
+        );
+      } else {
+        parserFn(`${lvalue} = ${readCode};`);
+      }
+    }
+    parserFn('}');
+
+    currentFieldNullBit *= 2;
+    if (currentFieldNullBit === 0x100) {
+      currentFieldNullBit = 1;
+      nullByteIndex++;
+    }
+  }
+
+  parserFn('return result;');
+  parserFn('}');
+  parserFn('};')('})()');
+
+  if (config.debug) {
+    helpers.printDebugWithCode(
+      'Compiled binary protocol row parser',
+      parserFn.toString()
+    );
+  }
+  return parserFn.toFunction({ wrap });
+}
+
+function getBinaryParser(fields, options, config) {
+  return parserCache.getParser('binary', fields, options, config, compile);
+}
+
+module.exports = getBinaryParser;