mysql2 3.24.0 → 3.24.1

package/lib/packets/encode_parameter.js

@@ -88,14 +88,28 @@ function toParameter(value, encoding, timezone, jsonAsString, hint) {
     length = 0;
     writer = writeNothing;
   }
+  let byteLength;
   if (length === undefined) {
-    value = StringParser.encode(value, encoding);
-    length = Packet.lengthCodedNumberLength(value.length) + value.length;
+    // a non-string here (e.g. a Uint8Array) keeps the Buffer.from coercion
+    // inside StringParser.encode
+    if (
+      typeof value === 'string' &&
+      StringParser.hasFastUtf8Write &&
+      (encoding === 'utf8' || encoding === 'utf-8')
+    ) {
+      byteLength = Buffer.byteLength(value, 'utf8');
+      length = Packet.lengthCodedNumberLength(byteLength) + byteLength;
+      writer = Packet.prototype.writeLengthCodedUtf8String;
+    } else {
+      value = StringParser.encode(value, encoding);
+      length = Packet.lengthCodedNumberLength(value.length) + value.length;
+    }
   }
   return {
     value,
     type,
     length,
+    byteLength,
     writer,
     unsigned: false,
     isNull: type === Types.NULL,

package/lib/packets/execute.js

@@ -206,7 +206,7 @@ class Execute {
       for (let i = 0; i < totalParams; i++) {
         const parameter = allParams[i];
         if (!parameter.isNull) {
-          parameter.writer.call(packet, parameter.value);
+          parameter.writer.call(packet, parameter.value, parameter.byteLength);
         }
       }
     }

package/lib/packets/packet.js

@@ -1030,6 +1030,18 @@ class Packet {
     this.offset += buf.length;
   }
 
+  // byteLength, when the caller sized the packet, must be
+  // Buffer.byteLength(string, 'utf8'); only used where
+  // Buffer.prototype.utf8Write exists
+  writeLengthCodedUtf8String(string, byteLength) {
+    if (byteLength === undefined) {
+      byteLength = Buffer.byteLength(string, 'utf8');
+    }
+    this.writeLengthCodedNumber(byteLength);
+    this.buffer.utf8Write(string, this.offset, byteLength);
+    this.offset += byteLength;
+  }
+
   writeLengthCodedBuffer(b) {
     this.writeLengthCodedNumber(b.length);
     b.copy(this.buffer, this.offset);

package/lib/packets/prepare_statement.js

@@ -13,6 +13,18 @@ class PrepareStatement {
   }
 
   toPacket() {
+    if (
+      StringParser.hasFastUtf8Write &&
+      (this.encoding === 'utf8' || this.encoding === 'utf-8')
+    ) {
+      const length = 5 + Buffer.byteLength(this.query, 'utf8');
+      const buffer = Buffer.allocUnsafe(length);
+      buffer[4] = CommandCodes.STMT_PREPARE;
+      buffer.utf8Write(this.query, 5, length - 5);
+      const packet = new Packet(0, buffer, 0, length);
+      packet.offset = length;
+      return packet;
+    }
     const buf = StringParser.encode(this.query, this.encoding);
     const length = 5 + buf.length;
     const buffer = Buffer.allocUnsafe(length);

package/lib/packets/query.js

@@ -7,6 +7,19 @@ const CharsetToEncoding = require('../constants/charset_encodings.js');
 const ClientConstants = require('../constants/client.js');
 const { toParameter } = require('./encode_parameter.js');
 
+const { hasFastUtf8Write } = StringParser;
+
+function toQueryPacket(buffer, headerLength, length) {
+  buffer[4] = CommandCode.QUERY;
+  if (headerLength === 7) {
+    buffer[5] = 0; // parameter_count
+    buffer[6] = 1; // parameter_set_count, always 1
+  }
+  const packet = new Packet(0, buffer, 0, length);
+  packet.offset = length;
+  return packet;
+}
+
 class Query {
   constructor(sql, charsetNumber, attributes, clientFlags) {
     this.query = sql;
@@ -25,36 +38,30 @@ class Query {
         : 0;
 
     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
+      // fast path: no attribute values to serialize, so the packet is the
+      // header plus the encoded SQL
       const headerLength = useQueryAttributes ? 7 : 5;
+      if (
+        hasFastUtf8Write &&
+        (this.encoding === 'utf8' || this.encoding === 'utf-8')
+      ) {
+        const length = headerLength + Buffer.byteLength(this.query, 'utf8');
+        const buffer = Buffer.allocUnsafe(length);
+        buffer.utf8Write(this.query, headerLength, length - headerLength);
+        return toQueryPacket(buffer, headerLength, length);
+      }
       if (Buffer.isEncoding(this.encoding)) {
-        const sqlLength = Buffer.byteLength(this.query, this.encoding);
-        const length = headerLength + sqlLength;
+        const length =
+          headerLength + Buffer.byteLength(this.query, this.encoding);
         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
-        }
-        buffer.write(this.query, packet.offset, this.encoding);
-        packet.offset = length;
-        return packet;
+        buffer.write(this.query, headerLength, this.encoding);
+        return toQueryPacket(buffer, headerLength, length);
       }
-      const buf = StringParser.encode(this.query, this.encoding);
-      const length = headerLength + buf.length;
+      const sqlBuffer = StringParser.encode(this.query, this.encoding);
+      const length = headerLength + sqlBuffer.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;
+      sqlBuffer.copy(buffer, headerLength);
+      return toQueryPacket(buffer, headerLength, length);
     }
 
     const names = Object.keys(this.attributes);
@@ -120,7 +127,11 @@ class Query {
 
     for (let i = 0; i < attributeCount; i++) {
       if (!parameters[i].isNull) {
-        parameters[i].writer.call(packet, parameters[i].value);
+        parameters[i].writer.call(
+          packet,
+          parameters[i].value,
+          parameters[i].byteLength
+        );
       }
     }
 

package/lib/packets/typed_parameter.js

@@ -238,15 +238,25 @@ function timeEncoder() {
 
 function lengthCodedEncoder(encoding) {
   return (value) => {
-    const buffer = Buffer.isBuffer(value)
-      ? value
-      : StringParser.encode(
-          typeof value === 'string' ? value : String(value),
-          encoding
-        );
+    if (!Buffer.isBuffer(value)) {
+      const string = typeof value === 'string' ? value : String(value);
+      if (
+        StringParser.hasFastUtf8Write &&
+        (encoding === 'utf8' || encoding === 'utf-8')
+      ) {
+        const byteLength = Buffer.byteLength(string, 'utf8');
+        return {
+          value: string,
+          length: Packet.lengthCodedNumberLength(byteLength) + byteLength,
+          byteLength,
+          writer: Packet.prototype.writeLengthCodedUtf8String,
+        };
+      }
+      value = StringParser.encode(string, encoding);
+    }
     return {
-      value: buffer,
-      length: Packet.lengthCodedNumberLength(buffer.length) + buffer.length,
+      value,
+      length: Packet.lengthCodedNumberLength(value.length) + value.length,
       writer: Packet.prototype.writeLengthCodedBuffer,
     };
   };

package/lib/parsers/string.js

@@ -15,6 +15,10 @@ const hasFastSlices =
   typeof Buffer.prototype.latin1Slice === 'function' &&
   typeof Buffer.prototype.asciiSlice === 'function';
 
+// utf8Write skips the per-call encoding normalization and dispatch inside
+// buffer.write(); same stability story as the slice methods above
+exports.hasFastUtf8Write = typeof Buffer.prototype.utf8Write === 'function';
+
 exports.decode = function (buffer, encoding, start, end, options) {
   if (hasFastSlices) {
     // replicate buffer.toString() bounds coercion exactly (the *Slice

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mysql2",
-  "version": "3.24.0",
+  "version": "3.24.1",
   "description": "fast mysql driver. Implements core protocol, prepared statements, ssl and compression in native JS",
   "main": "index.js",
   "typings": "typings/mysql/index",