@depup/mysql2 3.23.4-depup.0 → 3.24.0-depup.0

package/lib/packets/packet.js

@@ -10,7 +10,7 @@ const NativeBuffer = require('buffer').Buffer;
 const Long = require('long');
 const StringParser = require('../parsers/string.js');
 const Types = require('../constants/types.js');
-const INVALID_DATE = new Date(NaN);
+const ZERO_DATE = '0000-00-00';
 
 // this is nearly duplicate of previous function so generated code is not slower
 // due to "if (dateStrings)" branching
@@ -70,6 +70,27 @@ function jsonBigNumberReviver(key, value, context) {
 const dot = '.'.charCodeAt(0);
 const exponent = 'e'.charCodeAt(0);
 const exponentCapital = 'E'.charCodeAt(0);
+const colon = ':'.charCodeAt(0);
+
+// '+HH:MM' / '-HH:MM' -> signed minutes, memoized on the last seen value
+// (the timezone is a per-connection constant in practice)
+let lastTimezone;
+let lastTimezoneOffset = null;
+function timezoneOffsetMinutes(timezone) {
+  if (timezone === lastTimezone) {
+    return lastTimezoneOffset;
+  }
+  let offset = null;
+  if (/^[+-]\d{2}:\d{2}$/.test(timezone)) {
+    offset =
+      (timezone[0] === '-' ? -1 : 1) *
+      (parseInt(timezone.substring(1, 3), 10) * 60 +
+        parseInt(timezone.substring(4), 10));
+  }
+  lastTimezone = timezone;
+  lastTimezoneOffset = offset;
+  return offset;
+}
 
 class Packet {
   constructor(id, buffer, start, end) {
@@ -151,18 +172,14 @@ class Packet {
   readInt64JSNumber() {
     const word0 = this.readInt32();
     const word1 = this.readInt32();
-    const l = new Long(word0, word1, true);
-    return l.toNumber();
+    // same value Long.toNumber() would produce, without the allocation
+    return word0 + 0x100000000 * word1;
   }
 
   readSInt64JSNumber() {
     const word0 = this.readInt32();
     const word1 = this.readInt32();
-    if (!(word1 & 0x80000000)) {
-      return word0 + 0x100000000 * word1;
-    }
-    const l = new Long(word0, word1, false);
-    return l.toNumber();
+    return word0 + 0x100000000 * (word1 | 0);
   }
 
   readInt64String() {
@@ -182,17 +199,21 @@ class Packet {
   readInt64() {
     const word0 = this.readInt32();
     const word1 = this.readInt32();
-    const res = new Long(word0, word1, true);
-    const resNumber = res.toNumber();
-    return Number.isSafeInteger(resNumber) ? resNumber : res.toString();
+    const resNumber = word0 + 0x100000000 * word1;
+    if (Number.isSafeInteger(resNumber)) {
+      return resNumber;
+    }
+    return new Long(word0, word1, true).toString();
   }
 
   readSInt64() {
     const word0 = this.readInt32();
     const word1 = this.readInt32();
-    const res = new Long(word0, word1, false);
-    const resNumber = res.toNumber();
-    return Number.isSafeInteger(resNumber) ? resNumber : res.toString();
+    const resNumber = word0 + 0x100000000 * (word1 | 0);
+    if (Number.isSafeInteger(resNumber)) {
+      return resNumber;
+    }
+    return new Long(word0, word1, false).toString();
   }
 
   isEOF() {
@@ -309,7 +330,7 @@ class Packet {
       // possible MySQL flavours we still need to account for the
       // non-standard behaviour.
       if (y + m + d + H + M + S + ms === 0) {
-        return INVALID_DATE;
+        return new Date(NaN);
       }
       if (timezone === 'Z') {
         return new Date(Date.UTC(y, m - 1, d, H, M, S, ms));
@@ -317,8 +338,10 @@ class Packet {
       return new Date(y, m - 1, d, H, M, S, ms);
     }
     let str = this.readDateTimeString(6, 'T', null);
-    if (!str) {
-      return INVALID_DATE;
+    if (str.startsWith(ZERO_DATE)) {
+      // fresh instance: Date is mutable, a shared invalid-date singleton
+      // could be corrupted by callers (see the parseDateTime tests)
+      return new Date(NaN);
     }
     if (str.length === 10) {
       str += 'T00:00:00';
@@ -335,7 +358,7 @@ class Packet {
     let M = 0;
     let S = 0;
     let ms = 0;
-    let str;
+    let str = ZERO_DATE;
     if (length > 3) {
       y = this.readInt16();
       m = this.readInt8();
@@ -723,10 +746,75 @@ class Packet {
   }
 
   parseDateTime(timezone) {
-    const str = this.readLengthCodedString('binary');
-    if (str === null) {
+    const len = this.readLengthCodedNumber();
+    if (len === null) {
       return null;
     }
+    const b = this.buffer;
+    const s = this.offset;
+    // fast path for the wire format 'YYYY-MM-DD[ HH:MM:SS[.ffffff]]';
+    // parses digits straight from the buffer, avoiding both the intermediate
+    // string and the much slower Date-from-string constructor
+    if (
+      len >= 19 &&
+      b[s + 4] === minus &&
+      b[s + 7] === minus &&
+      b[s + 13] === colon &&
+      b[s + 16] === colon
+    ) {
+      const y =
+        (b[s] - 48) * 1000 +
+        (b[s + 1] - 48) * 100 +
+        (b[s + 2] - 48) * 10 +
+        (b[s + 3] - 48);
+      const mo = (b[s + 5] - 48) * 10 + (b[s + 6] - 48);
+      const d = (b[s + 8] - 48) * 10 + (b[s + 9] - 48);
+      if (mo === 0 || d === 0 || mo > 12 || d > 31) {
+        // matches Date-from-string behaviour for zero/invalid dates
+        this.offset += len;
+        return new Date(NaN);
+      }
+      if (y < 100) {
+        // new Date(y, ...) maps years 0-99 to 1900+y; let the string
+        // constructor handle this (out of MySQL's documented range anyway)
+        const str = StringParser.decode(b, 'binary', s, s + len);
+        this.offset += len;
+        return !timezone || timezone === 'local'
+          ? new Date(str)
+          : new Date(`${str}${timezone}`);
+      }
+      const h = (b[s + 11] - 48) * 10 + (b[s + 12] - 48);
+      const mi = (b[s + 14] - 48) * 10 + (b[s + 15] - 48);
+      const se = (b[s + 17] - 48) * 10 + (b[s + 18] - 48);
+      let ms = 0;
+      if (len > 20) {
+        // fractional part: Date resolution is ms, use the first 3 digits
+        let scale = 100;
+        for (let i = s + 20; i < s + len && scale >= 1; i++) {
+          ms += (b[i] - 48) * scale;
+          scale /= 10;
+        }
+      }
+      this.offset += len;
+      if (!timezone || timezone === 'local') {
+        return new Date(y, mo - 1, d, h, mi, se, ms);
+      }
+      const utc = Date.UTC(y, mo - 1, d, h, mi, se, ms);
+      if (timezone === 'Z') {
+        return new Date(utc);
+      }
+      const offsetMinutes = timezoneOffsetMinutes(timezone);
+      if (offsetMinutes !== null) {
+        return new Date(utc - offsetMinutes * 60000);
+      }
+      // not a fixed '+HH:MM' offset: preserve the legacy string behaviour
+      // (V8 accepts some timezone abbreviations in Date-from-string)
+      return new Date(
+        `${StringParser.decode(b, 'binary', s, s + len)}${timezone}`
+      );
+    }
+    const str = StringParser.decode(b, 'binary', s, s + len);
+    this.offset += len;
     if (!timezone || timezone === 'local') {
       return new Date(str);
     }
@@ -863,6 +951,44 @@ class Packet {
     this.offset += 8;
   }
 
+  writeFloat(n) {
+    this.buffer.writeFloatLE(n, this.offset);
+    this.offset += 4;
+  }
+
+  writeUIntLE(n, bytes) {
+    if (bytes === 8) {
+      this.buffer.writeBigUInt64LE(n, this.offset);
+    } else {
+      this.buffer.writeUIntLE(Number(n), this.offset, bytes);
+    }
+    this.offset += bytes;
+  }
+
+  // must match writeTime's choice of encoding byte for byte
+  static timeLength({ days, hours, minutes, seconds, microseconds }) {
+    if (!days && !hours && !minutes && !seconds && !microseconds) {
+      return 1;
+    }
+    return microseconds ? 13 : 9;
+  }
+
+  writeTime({ negative, days, hours, minutes, seconds, microseconds }) {
+    if (!days && !hours && !minutes && !seconds && !microseconds) {
+      this.writeInt8(0);
+      return;
+    }
+    this.writeInt8(microseconds ? 12 : 8);
+    this.writeInt8(negative ? 1 : 0);
+    this.writeInt32(days);
+    this.writeInt8(hours);
+    this.writeInt8(minutes);
+    this.writeInt8(seconds);
+    if (microseconds) {
+      this.writeInt32(microseconds);
+    }
+  }
+
   writeBuffer(b) {
     b.copy(this.buffer, this.offset);
     this.offset += b.length;
@@ -1009,6 +1135,9 @@ class Packet {
   }
 
   static MockBuffer() {
+    if (Packet._mockBuffer) {
+      return Packet._mockBuffer;
+    }
     const noop = function () {};
     const res = Buffer.alloc(0);
     for (const op in NativeBuffer.prototype) {
@@ -1016,6 +1145,7 @@ class Packet {
         res[op] = noop;
       }
     }
+    Packet._mockBuffer = res;
     return res;
   }
 }

package/lib/packets/query.js

@@ -5,7 +5,6 @@ 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 {
@@ -17,85 +16,122 @@ class Query {
     this.clientFlags = clientFlags || 0;
   }
 
-  serializeToBuffer(buffer) {
+  toPacket() {
     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')
-        );
+    const attributeCount =
+      useQueryAttributes && this.attributes
+        ? Object.keys(this.attributes).length
+        : 0;
 
-        // 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);
+    if (attributeCount === 0) {
+      // fast path: no attribute values to serialize, so the packet length is
+      // known upfront and the SQL can be encoded straight into the buffer
+      const headerLength = useQueryAttributes ? 7 : 5;
+      if (Buffer.isEncoding(this.encoding)) {
+        const sqlLength = Buffer.byteLength(this.query, this.encoding);
+        const length = headerLength + sqlLength;
+        const buffer = Buffer.allocUnsafe(length);
+        const packet = new Packet(0, buffer, 0, length);
+        packet.offset = 4;
+        packet.writeInt8(CommandCode.QUERY);
+        if (useQueryAttributes) {
+          packet.writeInt8(0); // parameter_count
+          packet.writeInt8(1); // parameter_set_count, always 1
         }
-
-        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);
-          }
-        });
+        buffer.write(this.query, packet.offset, this.encoding);
+        packet.offset = length;
+        return packet;
       }
-    }
-
-    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 length = headerLength + buf.length;
       const buffer = Buffer.allocUnsafe(length);
       const packet = new Packet(0, buffer, 0, length);
       packet.offset = 4;
       packet.writeInt8(CommandCode.QUERY);
+      if (useQueryAttributes) {
+        packet.writeInt8(0); // parameter_count
+        packet.writeInt8(1); // parameter_set_count, always 1
+      }
       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));
+    const names = Object.keys(this.attributes);
+    const parameters = new Array(attributeCount);
+    const nameBuffers = new Array(attributeCount);
+
+    // packet header, command, parameter count, parameter_set_count (always
+    // the single-byte form), null bitmap, new_params_bind_flag, type and
+    // unsigned byte per parameter
+    let length =
+      5 +
+      Packet.lengthCodedNumberLength(attributeCount) +
+      1 +
+      ((attributeCount + 7) >> 3) +
+      1 +
+      attributeCount * 2;
+    for (let i = 0; i < attributeCount; i++) {
+      parameters[i] = toParameter(
+        this.attributes[names[i]],
+        this.encoding,
+        'local'
+      );
+      const name = StringParser.encode(names[i], this.encoding);
+      nameBuffers[i] = name;
+      length += Packet.lengthCodedNumberLength(name.length) + name.length;
+      if (!parameters[i].isNull) {
+        length += parameters[i].length;
+      }
+    }
+    const sqlBuffer = StringParser.encode(this.query, this.encoding);
+    length += sqlBuffer.length;
+
+    const packet = new Packet(0, Buffer.allocUnsafe(length), 0, length);
+    packet.offset = 4;
+    packet.writeInt8(CommandCode.QUERY);
+    packet.writeLengthCodedNumber(attributeCount);
+    packet.writeLengthCodedNumber(1); // parameter_set_count, always 1
+
+    let bitmap = 0;
+    let bitValue = 1;
+    for (let i = 0; i < attributeCount; i++) {
+      if (parameters[i].isNull) {
+        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
+
+    for (let i = 0; i < attributeCount; i++) {
+      packet.writeInt8(parameters[i].type);
+      packet.writeInt8(parameters[i].unsigned ? 0x80 : 0);
+      packet.writeLengthCodedBuffer(nameBuffers[i]);
+    }
+
+    for (let i = 0; i < attributeCount; i++) {
+      if (!parameters[i].isNull) {
+        parameters[i].writer.call(packet, parameters[i].value);
+      }
+    }
+
+    packet.writeBuffer(sqlBuffer);
+
+    if (packet.offset !== length) {
+      throw new Error(
+        `Internal error: COM_QUERY serialized ${packet.offset - 4} bytes, expected ${length - 4}`
+      );
+    }
+    return packet;
   }
 }