@depup/mysql2 3.22.0-depup.0 → 3.23.2-depup.0

package/lib/packets/ssl_request.js

@@ -4,9 +4,10 @@ const ClientConstants = require('../constants/client');
 const Packet = require('../packets/packet');
 
 class SSLRequest {
-  constructor(flags, charset) {
+  constructor(flags, charset, mariadbExtendedClientFlags) {
     this.clientFlags = flags | ClientConstants.SSL;
     this.charset = charset;
+    this.mariadbExtendedClientFlags = mariadbExtendedClientFlags || 0;
   }
 
   toPacket() {
@@ -18,6 +19,10 @@ class SSLRequest {
     packet.writeInt32(this.clientFlags);
     packet.writeInt32(0); // max packet size. todo: move to config
     packet.writeInt8(this.charset);
+    // the last 4 of the 23 reserved bytes carry the MariaDB extended client
+    // capabilities (zero when not negotiated, i.e. plain filler)
+    packet.skip(19);
+    packet.writeInt32(this.mariadbExtendedClientFlags);
     return packet;
   }
 }

package/lib/packets/text_row.js

@@ -17,7 +17,7 @@ class TextRow {
   }
 
   static toPacket(columns, encoding) {
-    const sequenceId = 0; // TODO remove, this is calculated now in connecton
+    const sequenceId = 0; // TODO remove, this is calculated now in connection
     let length = 0;
     columns.forEach((val) => {
       if (val === null || typeof val === 'undefined') {

package/lib/parsers/binary_parser.js

@@ -21,6 +21,13 @@ function readCodeFor(field, config, options, fieldNum) {
   const timezone = options.timezone || config.timezone;
   const dateStrings = options.dateStrings || config.dateStrings;
   const unsigned = field.flags & FieldFlags.UNSIGNED;
+  // MariaDB sends JSON values as LONGTEXT; the JSON type is only visible in
+  // the extended metadata (MARIADB_CLIENT_EXTENDED_METADATA capability)
+  if (field.extendedFormat === 'json') {
+    return config.jsonStrings
+      ? `packet.readLengthCodedString(fields[${fieldNum}].encoding)`
+      : `packet.parseJson(fields[${fieldNum}].encoding, ${supportBigNumbers});`;
+  }
   switch (field.columnType) {
     case Types.TINY:
       return unsigned ? 'packet.readInt8();' : 'packet.readSInt8();';
@@ -63,7 +70,7 @@ function readCodeFor(field, config, options, fieldNum) {
       // see https://github.com/sidorares/node-mysql2/issues/409
       return config.jsonStrings
         ? 'packet.readLengthCodedString("utf8")'
-        : 'JSON.parse(packet.readLengthCodedString("utf8"));';
+        : `packet.parseJson("utf8", ${supportBigNumbers});`;
     case Types.LONGLONG:
       if (!supportBigNumbers) {
         return unsigned
@@ -89,13 +96,21 @@ function compile(fields, options, config) {
   const parserFn = genFunc();
   const nullBitmapLength = Math.floor((fields.length + 7 + 2) / 8);
 
-  function wrap(field, packet) {
+  function fieldMetadata(field) {
     return {
       type: typeNames[field.columnType],
+      extendedTypeName: field.extendedTypeName,
+      extendedFormat: field.extendedFormat,
       length: field.columnLength,
       db: field.schema,
       table: field.table,
       name: field.name,
+    };
+  }
+
+  function wrap(field, packet) {
+    return {
+      ...fieldMetadata(field),
       string: function (encoding = field.encoding) {
         if (field.columnType === Types.JSON && encoding === field.encoding) {
           // Since for JSON columns mysql always returns charset 63 (BINARY),
@@ -139,6 +154,22 @@ function compile(fields, options, config) {
     };
   }
 
+  /** A NULL value carries no bytes in the binary row packet, so the accessors return null without reading from it. */
+  function wrapNull(field) {
+    return {
+      ...fieldMetadata(field),
+      string: function () {
+        return null;
+      },
+      buffer: function () {
+        return null;
+      },
+      geometry: function () {
+        return null;
+      },
+    };
+  }
+
   parserFn('(function(){');
   parserFn('return class BinaryRow {');
   parserFn('constructor() {');
@@ -187,9 +218,17 @@ function compile(fields, options, config) {
       lvalue = `result[${fieldName}]`;
     }
 
-    parserFn(`if (nullBitmaskByte${nullByteIndex} & ${currentFieldNullBit}) `);
-    parserFn(`${lvalue} = null;`);
-    parserFn('else {');
+    parserFn(`if (nullBitmaskByte${nullByteIndex} & ${currentFieldNullBit}) {`);
+    if (typeof options.typeCast === 'function') {
+      const nullWrapperVar = `nullWrapper${i}`;
+      parserFn(`const ${nullWrapperVar} = wrapNull(fields[${i}]);`);
+      parserFn(
+        `${lvalue} = options.typeCast(${nullWrapperVar}, function() { return null; });`
+      );
+    } else {
+      parserFn(`${lvalue} = null;`);
+    }
+    parserFn('} else {');
 
     if (options.typeCast === false) {
       parserFn(`${lvalue} = packet.readLengthCodedBuffer();`);
@@ -225,7 +264,7 @@ function compile(fields, options, config) {
       parserFn.toString()
     );
   }
-  return parserFn.toFunction({ wrap });
+  return parserFn.toFunction({ wrap, wrapNull });
 }
 
 function getBinaryParser(fields, options, config) {

package/lib/parsers/parser_cache.js

@@ -20,6 +20,7 @@ function keyFromFields(type, fields, options, config) {
     options.timezone || config.timezone,
     Boolean(options.decimalNumbers),
     options.dateStrings,
+    Boolean(config.jsonStrings),
   ];
 
   for (let i = 0; i < fields.length; ++i) {
@@ -33,6 +34,8 @@ function keyFromFields(type, fields, options, config) {
       field.table,
       field.flags,
       field.characterSet,
+      field.extendedTypeName,
+      field.extendedFormat,
     ]);
   }
 

package/lib/parsers/static_binary_parser.js

@@ -22,6 +22,14 @@ function getBinaryParser(fields, _options, config) {
     const dateStrings = options.dateStrings || config.dateStrings;
     const unsigned = field.flags & FieldFlags.UNSIGNED;
 
+    // MariaDB sends JSON values as LONGTEXT; the JSON type is only visible in
+    // the extended metadata (MARIADB_CLIENT_EXTENDED_METADATA capability)
+    if (field.extendedFormat === 'json') {
+      return config.jsonStrings
+        ? packet.readLengthCodedString(field.encoding)
+        : packet.parseJson(field.encoding, supportBigNumbers);
+    }
+
     switch (field.columnType) {
       case Types.TINY:
         return unsigned ? packet.readInt8() : packet.readSInt8();
@@ -66,7 +74,7 @@ function getBinaryParser(fields, _options, config) {
         // see https://github.com/sidorares/node-mysql2/issues/409
         return config.jsonStrings
           ? packet.readLengthCodedString('utf8')
-          : JSON.parse(packet.readLengthCodedString('utf8'));
+          : packet.parseJson('utf8', supportBigNumbers);
       case Types.LONGLONG:
         if (!supportBigNumbers)
           return unsigned
@@ -86,6 +94,28 @@ function getBinaryParser(fields, _options, config) {
     }
   }
 
+  /** A NULL value carries no bytes in the binary row packet, so the accessors return null without reading from it. */
+  function wrapNull(field) {
+    return {
+      type: typeNames[field.columnType],
+      extendedTypeName: field.extendedTypeName,
+      extendedFormat: field.extendedFormat,
+      length: field.columnLength,
+      db: field.schema,
+      table: field.table,
+      name: field.name,
+      string: function () {
+        return null;
+      },
+      buffer: function () {
+        return null;
+      },
+      geometry: function () {
+        return null;
+      },
+    };
+  }
+
   return class BinaryRow {
     constructor() {}
 
@@ -110,7 +140,10 @@ function getBinaryParser(fields, _options, config) {
 
         let value;
         if (nullBitmaskBytes[nullByteIndex] & currentFieldNullBit) {
-          value = null;
+          value =
+            typeof typeCast === 'function'
+              ? typeCast(wrapNull(field), () => null)
+              : null;
         } else if (options.typeCast === false) {
           value = packet.readLengthCodedBuffer();
         } else {
@@ -120,6 +153,8 @@ function getBinaryParser(fields, _options, config) {
               ? typeCast(
                   {
                     type: typeNames[field.columnType],
+                    extendedTypeName: field.extendedTypeName,
+                    extendedFormat: field.extendedFormat,
                     length: field.columnLength,
                     db: field.schema,
                     table: field.table,

package/lib/parsers/static_text_parser.js

@@ -9,7 +9,15 @@ for (const t in Types) {
   typeNames[Types[t]] = t;
 }
 
-function readField({ packet, type, charset, encoding, config, options }) {
+function readField({
+  packet,
+  field,
+  type,
+  charset,
+  encoding,
+  config,
+  options,
+}) {
   const supportBigNumbers = Boolean(
     options.supportBigNumbers || config.supportBigNumbers
   );
@@ -19,6 +27,14 @@ function readField({ packet, type, charset, encoding, config, options }) {
   const timezone = options.timezone || config.timezone;
   const dateStrings = options.dateStrings || config.dateStrings;
 
+  // MariaDB sends JSON values as LONGTEXT; the JSON type is only visible in
+  // the extended metadata (MARIADB_CLIENT_EXTENDED_METADATA capability)
+  if (field.extendedFormat === 'json') {
+    return config.jsonStrings
+      ? packet.readLengthCodedString(encoding)
+      : packet.parseJson(encoding, supportBigNumbers);
+  }
+
   switch (type) {
     case Types.TINY:
     case Types.SHORT:
@@ -64,7 +80,7 @@ function readField({ packet, type, charset, encoding, config, options }) {
       // see https://github.com/sidorares/node-mysql2/issues/409
       return config.jsonStrings
         ? packet.readLengthCodedString('utf8')
-        : JSON.parse(packet.readLengthCodedString('utf8'));
+        : packet.parseJson('utf8', supportBigNumbers);
     default:
       if (charset === Charsets.BINARY) {
         return packet.readLengthCodedBuffer();
@@ -76,6 +92,8 @@ function readField({ packet, type, charset, encoding, config, options }) {
 function createTypecastField(field, packet) {
   return {
     type: typeNames[field.columnType],
+    extendedTypeName: field.extendedTypeName,
+    extendedFormat: field.extendedFormat,
     length: field.columnLength,
     db: field.schema,
     table: field.table,
@@ -110,6 +128,7 @@ function getTextParser(_fields, _options, config) {
         const next = () =>
           readField({
             packet,
+            field,
             type: field.columnType,
             encoding: field.encoding,
             charset: field.characterSet,

package/lib/parsers/text_parser.js

@@ -11,7 +11,9 @@ for (const t in Types) {
   typeNames[Types[t]] = t;
 }
 
-function readCodeFor(type, charset, encodingExpr, config, options) {
+function readCodeFor(field, encodingExpr, config, options) {
+  const type = field.columnType;
+  const charset = field.characterSet;
   const supportBigNumbers = Boolean(
     options.supportBigNumbers || config.supportBigNumbers
   );
@@ -21,6 +23,14 @@ function readCodeFor(type, charset, encodingExpr, config, options) {
   const timezone = options.timezone || config.timezone;
   const dateStrings = options.dateStrings || config.dateStrings;
 
+  // MariaDB sends JSON values as LONGTEXT; the JSON type is only visible in
+  // the extended metadata (MARIADB_CLIENT_EXTENDED_METADATA capability)
+  if (field.extendedFormat === 'json') {
+    return config.jsonStrings
+      ? `packet.readLengthCodedString(${encodingExpr})`
+      : `packet.parseJson(${encodingExpr}, ${supportBigNumbers})`;
+  }
+
   switch (type) {
     case Types.TINY:
     case Types.SHORT:
@@ -67,7 +77,7 @@ function readCodeFor(type, charset, encodingExpr, config, options) {
       // see https://github.com/sidorares/node-mysql2/issues/409
       return config.jsonStrings
         ? 'packet.readLengthCodedString("utf8")'
-        : 'JSON.parse(packet.readLengthCodedString("utf8"))';
+        : `packet.parseJson("utf8", ${supportBigNumbers})`;
     default:
       if (charset === Charsets.BINARY) {
         return 'packet.readLengthCodedBuffer()';
@@ -88,6 +98,8 @@ function compile(fields, options, config) {
   function wrap(field, _this) {
     return {
       type: typeNames[field.columnType],
+      extendedTypeName: field.extendedTypeName,
+      extendedFormat: field.extendedFormat,
       length: field.columnLength,
       db: field.schema,
       table: field.table,
@@ -174,13 +186,7 @@ function compile(fields, options, config) {
       parserFn(`${lvalue} = packet.readLengthCodedBuffer();`);
     } else {
       const encodingExpr = `fields[${i}].encoding`;
-      const readCode = readCodeFor(
-        fields[i].columnType,
-        fields[i].characterSet,
-        encodingExpr,
-        config,
-        options
-      );
+      const readCode = readCodeFor(fields[i], encodingExpr, config, options);
       if (typeof options.typeCast === 'function') {
         parserFn(
           `${lvalue} = options.typeCast(this.wrap${i}, function() { return ${readCode} });`

package/lib/promise/capture_local_err.js

@@ -0,0 +1,25 @@
+'use strict';
+
+/** @param {Function} constructorOpt Passed to Error.captureStackTrace (omit this frame from stacks). */
+function captureStackHolder(constructorOpt) {
+  const holder = {};
+  Error.captureStackTrace(holder, constructorOpt);
+  return holder;
+}
+
+/**
+ * Replace `err.stack` frames with the capture from `holder`, keeping the
+ * callback error instance and its MySQL fields.
+ *
+ * @param {Error} err
+ * @param {{ stack?: string }} holder
+ */
+function applyCapturedStack(err, holder) {
+  const stack = holder && holder.stack;
+  if (typeof stack !== 'string' || !stack) return;
+  const lines = stack.split('\n');
+  lines[0] = `${err.name}: ${err.message}`;
+  err.stack = lines.join('\n');
+}
+
+module.exports = { captureStackHolder, applyCapturedStack };

package/lib/promise/connection.js

@@ -2,6 +2,10 @@
 
 const EventEmitter = require('events').EventEmitter;
 const PromisePreparedStatementInfo = require('./prepared_statement_info.js');
+const {
+  captureStackHolder,
+  applyCapturedStack,
+} = require('./capture_local_err.js');
 const makeDoneCb = require('./make_done_cb.js');
 const inheritEvents = require('./inherit_events.js');
 const BaseConnection = require('../base/connection.js');
@@ -26,13 +30,14 @@ class PromiseConnection extends EventEmitter {
 
   query(query, params) {
     const c = this.connection;
+    const stackHolder = captureStackHolder(PromiseConnection.prototype.query);
     if (typeof params === 'function') {
       throw new Error(
         'Callback function is not available with promise clients.'
       );
     }
     return new this.Promise((resolve, reject) => {
-      const done = makeDoneCb(resolve, reject);
+      const done = makeDoneCb(resolve, reject, stackHolder);
       if (params !== undefined) {
         c.query(query, params, done);
       } else {
@@ -43,13 +48,14 @@ class PromiseConnection extends EventEmitter {
 
   execute(query, params) {
     const c = this.connection;
+    const stackHolder = captureStackHolder(PromiseConnection.prototype.execute);
     if (typeof params === 'function') {
       throw new Error(
         'Callback function is not available with promise clients.'
       );
     }
     return new this.Promise((resolve, reject) => {
-      const done = makeDoneCb(resolve, reject);
+      const done = makeDoneCb(resolve, reject, stackHolder);
       if (params !== undefined) {
         c.execute(query, params, done);
       } else {
@@ -72,40 +78,43 @@ class PromiseConnection extends EventEmitter {
 
   beginTransaction() {
     const c = this.connection;
+    const stackHolder = captureStackHolder(
+      PromiseConnection.prototype.beginTransaction
+    );
     return new this.Promise((resolve, reject) => {
-      const done = makeDoneCb(resolve, reject);
+      const done = makeDoneCb(resolve, reject, stackHolder);
       c.beginTransaction(done);
     });
   }
 
   commit() {
     const c = this.connection;
+    const stackHolder = captureStackHolder(PromiseConnection.prototype.commit);
     return new this.Promise((resolve, reject) => {
-      const done = makeDoneCb(resolve, reject);
+      const done = makeDoneCb(resolve, reject, stackHolder);
       c.commit(done);
     });
   }
 
   rollback() {
     const c = this.connection;
+    const stackHolder = captureStackHolder(
+      PromiseConnection.prototype.rollback
+    );
     return new this.Promise((resolve, reject) => {
-      const done = makeDoneCb(resolve, reject);
+      const done = makeDoneCb(resolve, reject, stackHolder);
       c.rollback(done);
     });
   }
 
   ping() {
     const c = this.connection;
+    const stackHolder = captureStackHolder(PromiseConnection.prototype.ping);
     return new this.Promise((resolve, reject) => {
       c.ping((err) => {
         if (err) {
-          const localErr = new Error();
-          localErr.message = err.message;
-          localErr.code = err.code;
-          localErr.errno = err.errno;
-          localErr.sqlState = err.sqlState;
-          localErr.sqlMessage = err.sqlMessage;
-          reject(localErr);
+          applyCapturedStack(err, stackHolder);
+          reject(err);
         } else {
           resolve(true);
         }
@@ -115,16 +124,12 @@ class PromiseConnection extends EventEmitter {
 
   reset() {
     const c = this.connection;
+    const stackHolder = captureStackHolder(PromiseConnection.prototype.reset);
     return new this.Promise((resolve, reject) => {
       c.reset((err) => {
         if (err) {
-          const localErr = new Error();
-          localErr.message = err.message;
-          localErr.code = err.code;
-          localErr.errno = err.errno;
-          localErr.sqlState = err.sqlState;
-          localErr.sqlMessage = err.sqlMessage;
-          reject(localErr);
+          applyCapturedStack(err, stackHolder);
+          reject(err);
         } else {
           resolve();
         }
@@ -134,16 +139,12 @@ class PromiseConnection extends EventEmitter {
 
   connect() {
     const c = this.connection;
+    const stackHolder = captureStackHolder(PromiseConnection.prototype.connect);
     return new this.Promise((resolve, reject) => {
       c.connect((err, param) => {
         if (err) {
-          const localErr = new Error();
-          localErr.message = err.message;
-          localErr.code = err.code;
-          localErr.errno = err.errno;
-          localErr.sqlState = err.sqlState;
-          localErr.sqlMessage = err.sqlMessage;
-          reject(localErr);
+          applyCapturedStack(err, stackHolder);
+          reject(err);
         } else {
           resolve(param);
         }
@@ -154,16 +155,12 @@ class PromiseConnection extends EventEmitter {
   prepare(options) {
     const c = this.connection;
     const promiseImpl = this.Promise;
+    const stackHolder = captureStackHolder(PromiseConnection.prototype.prepare);
     return new this.Promise((resolve, reject) => {
       c.prepare(options, (err, statement) => {
         if (err) {
-          const localErr = new Error();
-          localErr.message = err.message;
-          localErr.code = err.code;
-          localErr.errno = err.errno;
-          localErr.sqlState = err.sqlState;
-          localErr.sqlMessage = err.sqlMessage;
-          reject(localErr);
+          applyCapturedStack(err, stackHolder);
+          reject(err);
         } else {
           const wrappedStatement = new PromisePreparedStatementInfo(
             statement,
@@ -177,16 +174,14 @@ class PromiseConnection extends EventEmitter {
 
   changeUser(options) {
     const c = this.connection;
+    const stackHolder = captureStackHolder(
+      PromiseConnection.prototype.changeUser
+    );
     return new this.Promise((resolve, reject) => {
       c.changeUser(options, (err) => {
         if (err) {
-          const localErr = new Error();
-          localErr.message = err.message;
-          localErr.code = err.code;
-          localErr.errno = err.errno;
-          localErr.sqlState = err.sqlState;
-          localErr.sqlMessage = err.sqlMessage;
-          reject(localErr);
+          applyCapturedStack(err, stackHolder);
+          reject(err);
         } else {
           resolve();
         }

package/lib/promise/make_done_cb.js

@@ -1,16 +1,12 @@
 'use strict';
 
-function makeDoneCb(resolve, reject) {
+const { applyCapturedStack } = require('./capture_local_err.js');
+
+function makeDoneCb(resolve, reject, stackHolder) {
   return function (err, rows, fields) {
     if (err) {
-      const localErr = new Error();
-      localErr.message = err.message;
-      localErr.code = err.code;
-      localErr.errno = err.errno;
-      localErr.sql = err.sql;
-      localErr.sqlState = err.sqlState;
-      localErr.sqlMessage = err.sqlMessage;
-      reject(localErr);
+      applyCapturedStack(err, stackHolder);
+      reject(err);
     } else {
       resolve([rows, fields]);
     }

package/lib/promise/pool.js

@@ -1,6 +1,10 @@
 'use strict';
 
 const EventEmitter = require('events').EventEmitter;
+const {
+  captureStackHolder,
+  applyCapturedStack,
+} = require('./capture_local_err.js');
 const makeDoneCb = require('./make_done_cb.js');
 const PromisePoolConnection = require('./pool_connection.js');
 const inheritEvents = require('./inherit_events.js');
@@ -33,13 +37,14 @@ class PromisePool extends EventEmitter {
 
   query(sql, args) {
     const corePool = this.pool;
+    const stackHolder = captureStackHolder(PromisePool.prototype.query);
     if (typeof args === 'function') {
       throw new Error(
         'Callback function is not available with promise clients.'
       );
     }
     return new this.Promise((resolve, reject) => {
-      const done = makeDoneCb(resolve, reject);
+      const done = makeDoneCb(resolve, reject, stackHolder);
       if (args !== undefined) {
         corePool.query(sql, args, done);
       } else {
@@ -50,13 +55,14 @@ class PromisePool extends EventEmitter {
 
   execute(sql, args) {
     const corePool = this.pool;
+    const stackHolder = captureStackHolder(PromisePool.prototype.execute);
     if (typeof args === 'function') {
       throw new Error(
         'Callback function is not available with promise clients.'
       );
     }
     return new this.Promise((resolve, reject) => {
-      const done = makeDoneCb(resolve, reject);
+      const done = makeDoneCb(resolve, reject, stackHolder);
       if (args) {
         corePool.execute(sql, args, done);
       } else {
@@ -67,16 +73,12 @@ class PromisePool extends EventEmitter {
 
   end() {
     const corePool = this.pool;
+    const stackHolder = captureStackHolder(PromisePool.prototype.end);
     return new this.Promise((resolve, reject) => {
       corePool.end((err) => {
         if (err) {
-          const localErr = new Error();
-          localErr.message = err.message;
-          localErr.code = err.code;
-          localErr.errno = err.errno;
-          localErr.sqlState = err.sqlState;
-          localErr.sqlMessage = err.sqlMessage;
-          reject(localErr);
+          applyCapturedStack(err, stackHolder);
+          reject(err);
         } else {
           resolve();
         }

package/lib/promise/pool_cluster.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const { captureStackHolder } = require('./capture_local_err.js');
 const PromisePoolConnection = require('./pool_connection');
 const makeDoneCb = require('./make_done_cb');
 
@@ -24,26 +25,32 @@ class PromisePoolNamespace {
 
   query(sql, values) {
     const corePoolNamespace = this.poolNamespace;
+    const stackHolder = captureStackHolder(
+      PromisePoolNamespace.prototype.query
+    );
     if (typeof values === 'function') {
       throw new Error(
         'Callback function is not available with promise clients.'
       );
     }
     return new this.Promise((resolve, reject) => {
-      const done = makeDoneCb(resolve, reject);
+      const done = makeDoneCb(resolve, reject, stackHolder);
       corePoolNamespace.query(sql, values, done);
     });
   }
 
   execute(sql, values) {
     const corePoolNamespace = this.poolNamespace;
+    const stackHolder = captureStackHolder(
+      PromisePoolNamespace.prototype.execute
+    );
     if (typeof values === 'function') {
       throw new Error(
         'Callback function is not available with promise clients.'
       );
     }
     return new this.Promise((resolve, reject) => {
-      const done = makeDoneCb(resolve, reject);
+      const done = makeDoneCb(resolve, reject, stackHolder);
       corePoolNamespace.execute(sql, values, done);
     });
   }

package/lib/promise/prepared_statement_info.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const { captureStackHolder } = require('./capture_local_err.js');
 const makeDoneCb = require('./make_done_cb.js');
 
 class PromisePreparedStatementInfo {
@@ -10,8 +11,11 @@ class PromisePreparedStatementInfo {
 
   execute(parameters) {
     const s = this.statement;
+    const stackHolder = captureStackHolder(
+      PromisePreparedStatementInfo.prototype.execute
+    );
     return new this.Promise((resolve, reject) => {
-      const done = makeDoneCb(resolve, reject);
+      const done = makeDoneCb(resolve, reject, stackHolder);
       if (parameters) {
         s.execute(parameters, done);
       } else {