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

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/mysql2
 
 | Field | Value |
 |-------|-------|
-| Original | [mysql2](https://www.npmjs.com/package/mysql2) @ 3.23.4 |
-| Processed | 2026-08-20 |
+| Original | [mysql2](https://www.npmjs.com/package/mysql2) @ 3.24.0 |
+| Processed | 2026-08-24 |
 | Smoke test | passed |
 | Deps updated | 0 |
 

package/changes.json

@@ -1,5 +1,5 @@
 {
   "bumped": {},
-  "timestamp": "2026-08-20T08:13:41.208Z",
+  "timestamp": "2026-08-24T00:15:42.327Z",
   "totalUpdated": 0
 }

package/index.js

@@ -60,6 +60,11 @@ exports.__defineGetter__(
 
 exports.__defineGetter__('Types', () => require('./lib/constants/types.js'));
 
+exports.__defineGetter__(
+  'TypedParameter',
+  () => require('./lib/packets/typed_parameter.js').types
+);
+
 exports.__defineGetter__('Charsets', () =>
   require('./lib/constants/charsets.js')
 );

package/lib/base/connection.js

@@ -496,7 +496,9 @@ class BaseConnection extends EventEmitter {
 
   handlePacket(packet) {
     if (this._paused) {
-      this._paused_packets.push(packet);
+      // the parser reuses its packet instance; keep a stable copy when
+      // queueing for later
+      this._paused_packets.push(packet ? packet.clone() : packet);
       return;
     }
     if (this.config.debug) {

package/lib/commands/execute.js

@@ -22,6 +22,8 @@ class Execute extends Command {
     this.queryTimeout = null;
     this._rows = [];
     this._fields = [];
+    this._currentRows = null;
+    this._currentFields = null;
     this._result = [];
     this._fieldCount = 0;
     this._rowParser = null;
@@ -54,7 +56,8 @@ class Execute extends Command {
       connection.config.timezone,
       this._executeOptions.attributes,
       clientFlags,
-      connection._isMariaDB
+      connection._isMariaDB,
+      this.statement.parameters
     );
     //For reasons why this try-catch is here, please see
     // https://github.com/sidorares/node-mysql2/pull/689

package/lib/commands/query.js

@@ -33,6 +33,8 @@ class Query extends Command {
     this._rowParser = null;
     this._fields = [];
     this._rows = [];
+    this._currentRows = null;
+    this._currentFields = null;
     this._receivedFieldsCount = 0;
     this._resultIndex = 0;
     this._localStream = null;
@@ -137,8 +139,10 @@ class Query extends Command {
       return this._streamLocalInfile(connection, rs.infileName);
     }
     this._receivedFieldsCount = 0;
-    this._rows.push([]);
-    this._fields.push([]);
+    this._currentRows = [];
+    this._currentFields = [];
+    this._rows.push(this._currentRows);
+    this._fields.push(this._currentFields);
     return this.readField;
   }
 
@@ -252,17 +256,13 @@ class Query extends Command {
     }
     let row;
     try {
-      row = this._rowParser.next(
-        packet,
-        this._fields[this._resultIndex],
-        this.options
-      );
+      row = this._rowParser.next(packet, this._currentFields, this.options);
     } catch (err) {
       this._localStreamError = err;
       return this.doneInsert(null);
     }
     if (this.onResult) {
-      this._rows[this._resultIndex].push(row);
+      this._currentRows.push(row);
     } else {
       this.emit('result', row, this._resultIndex);
     }

package/lib/compressed_protocol.js

@@ -36,6 +36,9 @@ function handleCompressedPacket(packet) {
   const connection = this;
   const deflatedLength = packet.readInt24();
   const body = packet.readBuffer();
+  // the packet parser reuses its packet instance, so everything needed after
+  // the queued (asynchronous) inflate step must be read out now
+  const numPackets = packet.numPackets;
 
   if (deflatedLength !== 0) {
     connection.inflateQueue.push((task) => {
@@ -44,14 +47,14 @@ function handleCompressedPacket(packet) {
           connection._handleNetworkError(err);
           return;
         }
-        connection._bumpCompressedSequenceId(packet.numPackets);
+        connection._bumpCompressedSequenceId(numPackets);
         connection._inflatedPacketsParser.execute(data);
         task.done();
       });
     });
   } else {
     connection.inflateQueue.push((task) => {
-      connection._bumpCompressedSequenceId(packet.numPackets);
+      connection._bumpCompressedSequenceId(numPackets);
       connection._inflatedPacketsParser.execute(body);
       task.done();
     });

package/lib/constants/types.js

@@ -18,6 +18,7 @@ module.exports = {
   0x0e: 'NEWDATE', // aka ?
   0x0f: 'VARCHAR', // aka VARCHAR (?)
   0x10: 'BIT', // aka BIT, 1-8 byte
+  0xf2: 'VECTOR',
   0xf5: 'JSON',
   0xf6: 'NEWDECIMAL', // aka DECIMAL
   0xf7: 'ENUM', // aka ENUM

package/lib/packet_parser.js

@@ -33,6 +33,10 @@ class PacketParser {
     this.largePacketParts = [];
     this.firstPacketSequenceId = 0;
     this.onPacket = onPacket;
+    // complete packets are handed to onPacket through this single mutable
+    // instance; consumers that keep a packet past the synchronous callback
+    // (e.g. a paused connection) must clone() it
+    this._reusablePacket = new Packet(0, Buffer.allocUnsafe(4), 0, 4);
     this.execute = PacketParser.prototype.executeStart;
     this._flushLargePacket =
       packetHeaderLength === 7
@@ -72,14 +76,14 @@ class PacketParser {
           this.length < MAX_PACKET_LENGTH &&
           this.largePacketParts.length === 0
         ) {
-          this.onPacket(
-            new Packet(
-              sequenceId,
-              chunk,
-              start,
-              start + this.packetHeaderLength + this.length
-            )
-          );
+          const packet = this._reusablePacket;
+          packet.sequenceId = sequenceId;
+          packet.numPackets = 1;
+          packet.buffer = chunk;
+          packet.start = start;
+          packet.offset = start + 4;
+          packet.end = start + this.packetHeaderLength + this.length;
+          this.onPacket(packet);
         } else {
           // first large packet - remember it's id
           if (this.largePacketParts.length === 0) {
@@ -136,14 +140,14 @@ class PacketParser {
         this.length < MAX_PACKET_LENGTH &&
         this.largePacketParts.length === 0
       ) {
-        this.onPacket(
-          new Packet(
-            sequenceId,
-            payload,
-            0,
-            this.length + this.packetHeaderLength
-          )
-        );
+        const packet = this._reusablePacket;
+        packet.sequenceId = sequenceId;
+        packet.numPackets = 1;
+        packet.buffer = payload;
+        packet.start = 0;
+        packet.offset = 4;
+        packet.end = this.length + this.packetHeaderLength;
+        this.onPacket(packet);
       } else {
         // first large packet - remember it's id
         if (this.largePacketParts.length === 0) {

package/lib/packets/column_definition.js

@@ -288,24 +288,25 @@ class ColumnDefinition {
 }
 
 const addString = function (name) {
+  const cacheKey = `_${name}Value`;
+  const startKey = `_${name}Start`;
+  const lengthKey = `_${name}Length`;
+  ColumnDefinition.prototype[cacheKey] = undefined;
   Object.defineProperty(ColumnDefinition.prototype, name, {
     get: function () {
-      const start = this[`_${name}Start`];
-      const end = start + this[`_${name}Length`];
+      const cached = this[cacheKey];
+      if (cached !== undefined) {
+        return cached;
+      }
+      const start = this[startKey];
+      const end = start + this[lengthKey];
       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,
-      });
-
+      this[cacheKey] = val;
       return val;
     },
   });

package/lib/packets/encode_parameter.js

@@ -2,6 +2,13 @@
 
 const Types = require('../constants/types');
 const Packet = require('../packets/packet');
+const StringParser = require('../parsers/string.js');
+const {
+  TypedParameter,
+  encodeTypedParameter,
+  integerHint,
+} = require('./typed_parameter.js');
+const FieldFlags = require('../constants/field_flags.js');
 
 function isJSON(value) {
   return (
@@ -11,12 +18,23 @@ function isJSON(value) {
   );
 }
 
-function toParameter(value, encoding, timezone, jsonAsString) {
+function toParameter(value, encoding, timezone, jsonAsString, hint) {
+  if (value instanceof TypedParameter) {
+    return encodeTypedParameter(value, encoding, timezone, jsonAsString);
+  }
+  if (hint) {
+    const hinted = integerHint(
+      value,
+      hint.columnType,
+      Boolean(hint.flags & FieldFlags.UNSIGNED)
+    );
+    if (hinted) {
+      return encodeTypedParameter(hinted, encoding, timezone, jsonAsString);
+    }
+  }
   let type = Types.VAR_STRING;
   let length;
-  let writer = function (value) {
-    return Packet.prototype.writeLengthCodedString.call(this, value, encoding);
-  };
+  let writer = Packet.prototype.writeLengthCodedBuffer;
   if (value !== null) {
     switch (typeof value) {
       case 'undefined':
@@ -67,11 +85,23 @@ function toParameter(value, encoding, timezone, jsonAsString) {
   } else {
     value = '';
     type = Types.NULL;
+    length = 0;
+    writer = writeNothing;
   }
-  if (!length) {
-    length = Packet.lengthCodedStringLength(value, encoding);
+  if (length === undefined) {
+    value = StringParser.encode(value, encoding);
+    length = Packet.lengthCodedNumberLength(value.length) + value.length;
   }
-  return { value, type, length, writer };
+  return {
+    value,
+    type,
+    length,
+    writer,
+    unsigned: false,
+    isNull: type === Types.NULL,
+  };
 }
 
+function writeNothing() {}
+
 module.exports = { toParameter, isJSON };

package/lib/packets/execute.js

@@ -5,6 +5,7 @@ const CommandCodes = require('../constants/commands');
 const ClientConstants = require('../constants/client');
 const Types = require('../constants/types');
 const Packet = require('../packets/packet');
+const StringParser = require('../parsers/string.js');
 const CharsetToEncoding = require('../constants/charset_encodings.js');
 const { toParameter } = require('./encode_parameter.js');
 
@@ -16,7 +17,8 @@ class Execute {
     timezone,
     attributes,
     clientFlags,
-    jsonAsString
+    jsonAsString,
+    parameterDefinitions
   ) {
     this.id = id;
     this.parameters = parameters;
@@ -25,6 +27,7 @@ class Execute {
     this.attributes = attributes;
     this.clientFlags = clientFlags || 0;
     this.jsonAsString = jsonAsString || false;
+    this.parameterDefinitions = parameterDefinitions || [];
   }
 
   static fromPacket(packet, encoding) {
@@ -95,7 +98,7 @@ class Execute {
     return { stmtId, flags, iterationCount, values };
   }
 
-  _serializeToBuffer(buffer) {
+  toPacket() {
     const useQueryAttributes =
       this.clientFlags & ClientConstants.CLIENT_QUERY_ATTRIBUTES;
 
@@ -105,7 +108,53 @@ class Execute {
     const numAttrs = attrNames.length;
     const totalParams = numParams + numAttrs;
 
-    const packet = new Packet(0, buffer, 0, buffer.length);
+    // packet header, command, statement id, cursor flags, iteration count
+    let length = 14;
+    if (useQueryAttributes) {
+      length += Packet.lengthCodedNumberLength(totalParams);
+    }
+
+    let allParams = null;
+    let attrNameBuffers = null;
+    if (totalParams > 0) {
+      allParams = new Array(totalParams);
+      for (let i = 0; i < numParams; i++) {
+        allParams[i] = toParameter(
+          this.parameters[i],
+          this.encoding,
+          this.timezone,
+          this.jsonAsString,
+          this.parameterDefinitions[i]
+        );
+      }
+      for (let i = 0; i < numAttrs; i++) {
+        allParams[numParams + i] = toParameter(
+          this.attributes[attrNames[i]],
+          this.encoding,
+          this.timezone
+        );
+      }
+
+      // null bitmap, new-params-bound flag, type and unsigned byte per parameter
+      length += ((totalParams + 7) >> 3) + 1 + totalParams * 2;
+      if (useQueryAttributes) {
+        // one empty length-coded name per bind parameter
+        length += numParams;
+        attrNameBuffers = new Array(numAttrs);
+        for (let i = 0; i < numAttrs; i++) {
+          const name = StringParser.encode(attrNames[i], this.encoding);
+          attrNameBuffers[i] = name;
+          length += Packet.lengthCodedNumberLength(name.length) + name.length;
+        }
+      }
+      for (let i = 0; i < totalParams; i++) {
+        if (!allParams[i].isNull) {
+          length += allParams[i].length;
+        }
+      }
+    }
+
+    const packet = new Packet(0, Buffer.allocUnsafe(length), 0, length);
     packet.offset = 4;
     packet.writeInt8(CommandCodes.STMT_EXECUTE);
     packet.writeInt32(this.id);
@@ -122,23 +171,11 @@ class Execute {
     }
 
     if (totalParams > 0) {
-      const bindParams =
-        numParams > 0
-          ? this.parameters.map((v) =>
-              toParameter(v, this.encoding, this.timezone, this.jsonAsString)
-            )
-          : [];
-      const attrParams = attrNames.map((name) =>
-        toParameter(this.attributes[name], this.encoding, this.timezone)
-      );
-      const allParams = bindParams.concat(attrParams);
-
-      // null bitmap
       let bitmap = 0;
       let bitValue = 1;
-      allParams.forEach((parameter) => {
-        if (parameter.type === Types.NULL) {
-          bitmap += bitValue;
+      for (let i = 0; i < totalParams; i++) {
+        if (allParams[i].isNull) {
+          bitmap |= bitValue;
         }
         bitValue *= 2;
         if (bitValue === 256) {
@@ -146,38 +183,41 @@ class Execute {
           bitmap = 0;
           bitValue = 1;
         }
-      });
+      }
       if (bitValue !== 1) {
         packet.writeInt8(bitmap);
       }
 
       packet.writeInt8(1); // new-params-bound-flag
 
-      // types (and names for attributes)
-      for (let i = 0; i < allParams.length; i++) {
-        packet.writeInt8(allParams[i].type);
-        packet.writeInt8(0); // unsigned flag
+      for (let i = 0; i < totalParams; i++) {
+        const parameter = allParams[i];
+        packet.writeInt8(parameter.type);
+        packet.writeInt8(parameter.unsigned ? 0x80 : 0);
         if (useQueryAttributes) {
-          const name = i < numParams ? '' : attrNames[i - numParams];
-          packet.writeLengthCodedString(name, this.encoding);
+          if (i < numParams) {
+            packet.writeInt8(0); // bind parameters have an empty name
+          } else {
+            packet.writeLengthCodedBuffer(attrNameBuffers[i - numParams]);
+          }
         }
       }
 
-      // values
-      allParams.forEach((parameter) => {
-        if (parameter.type !== Types.NULL) {
+      for (let i = 0; i < totalParams; i++) {
+        const parameter = allParams[i];
+        if (!parameter.isNull) {
           parameter.writer.call(packet, parameter.value);
         }
-      });
+      }
     }
 
+    if (packet.offset !== length) {
+      throw new Error(
+        `Internal error: COM_STMT_EXECUTE serialized ${packet.offset - 4} bytes, expected ${length - 4}`
+      );
+    }
     return packet;
   }
-
-  toPacket() {
-    const p = this._serializeToBuffer(Packet.MockBuffer());
-    return this._serializeToBuffer(Buffer.allocUnsafe(p.offset));
-  }
 }
 
 module.exports = Execute;