mysql2 3.24.4-canary.9178c82 → 3.24.4

package/lib/base/connection.js

@@ -43,6 +43,49 @@ let _connectionId = 0;
 
 let convertNamedPlaceholders = null;
 
+// Building a secure context parses every certificate in the ssl config
+// (the bundled AWS profile alone carries over a hundred), which costs
+// milliseconds per connection. The context is immutable once built, so
+// pooled connections sharing one ssl config object share the context, as
+// long as none of the material it was built from has been replaced.
+const secureContexts = new WeakMap();
+
+function getSecureContext(ssl) {
+  const cached = secureContexts.get(ssl);
+  if (
+    cached !== undefined &&
+    cached.ca === ssl.ca &&
+    cached.cert === ssl.cert &&
+    cached.ciphers === ssl.ciphers &&
+    cached.key === ssl.key &&
+    cached.passphrase === ssl.passphrase &&
+    cached.minVersion === ssl.minVersion &&
+    cached.maxVersion === ssl.maxVersion
+  ) {
+    return cached.secureContext;
+  }
+  const secureContext = Tls.createSecureContext({
+    ca: ssl.ca,
+    cert: ssl.cert,
+    ciphers: ssl.ciphers,
+    key: ssl.key,
+    passphrase: ssl.passphrase,
+    minVersion: ssl.minVersion,
+    maxVersion: ssl.maxVersion,
+  });
+  secureContexts.set(ssl, {
+    secureContext,
+    ca: ssl.ca,
+    cert: ssl.cert,
+    ciphers: ssl.ciphers,
+    key: ssl.key,
+    passphrase: ssl.passphrase,
+    minVersion: ssl.minVersion,
+    maxVersion: ssl.maxVersion,
+  });
+  return secureContext;
+}
+
 class BaseConnection extends EventEmitter {
   constructor(opts) {
     super();
@@ -382,15 +425,7 @@ class BaseConnection extends EventEmitter {
     if (this.config.debug) {
       console.log('Upgrading connection to TLS');
     }
-    const secureContext = Tls.createSecureContext({
-      ca: this.config.ssl.ca,
-      cert: this.config.ssl.cert,
-      ciphers: this.config.ssl.ciphers,
-      key: this.config.ssl.key,
-      passphrase: this.config.ssl.passphrase,
-      minVersion: this.config.ssl.minVersion,
-      maxVersion: this.config.ssl.maxVersion,
-    });
+    const secureContext = getSecureContext(this.config.ssl);
     const rejectUnauthorized = this.config.ssl.rejectUnauthorized;
     const verifyIdentity = this.config.ssl.verifyIdentity;
     const servername = Net.isIP(this.config.host)

package/lib/commands/execute.js

@@ -5,6 +5,7 @@ const Timers = require('timers');
 const Command = require('./command.js');
 const Query = require('./query.js');
 const Packets = require('../packets/index.js');
+const ConnectionConfig = require('../connection_config.js');
 
 const getBinaryParser = require('../parsers/binary_parser.js');
 const getStaticBinaryParser = require('../parsers/static_binary_parser.js');
@@ -45,7 +46,10 @@ class Execute extends Command {
 
   start(packet, connection) {
     this._connection = connection;
-    this.options = Object.assign({}, connection.config, this._executeOptions);
+    this.options = ConnectionConfig.queryOptions(
+      connection.config,
+      this._executeOptions
+    );
     this._setTimeout();
     const clientFlags =
       connection.config.clientFlags & (connection.serverCapabilityFlags || 0);

package/lib/commands/query.js

@@ -10,6 +10,7 @@ const Packets = require('../packets/index.js');
 const getTextParser = require('../parsers/text_parser.js');
 const staticParser = require('../parsers/static_text_parser.js');
 const ServerStatus = require('../constants/server_status.js');
+const ConnectionConfig = require('../connection_config.js');
 
 const EmptyPacket = new Packets.Packet(0, Buffer.allocUnsafe(4), 0, 4);
 
@@ -56,7 +57,10 @@ class Query extends Command {
       console.log('        Sending query command: %s', this.sql);
     }
     this._connection = connection;
-    this.options = Object.assign({}, connection.config, this._queryOptions);
+    this.options = ConnectionConfig.queryOptions(
+      connection.config,
+      this._queryOptions
+    );
     this._setTimeout();
 
     const clientFlags =

package/lib/compressed_protocol.js

@@ -6,6 +6,15 @@
 const zlib = require('zlib');
 const PacketParser = require('./packet_parser.js');
 
+// the server sends payloads shorter than this uncompressed, and so does
+// the client: deflate cannot shrink them
+const MIN_COMPRESS_LENGTH = 50;
+// zlib work below these sizes takes a few microseconds, less than the trip
+// through the thread pool and the queue behind it, so it runs inline;
+// larger payloads stay asynchronous and keep the event loop free
+const MAX_SYNC_INFLATE_LENGTH = 16384;
+const MAX_SYNC_DEFLATE_LENGTH = 4096;
+
 class Queue {
   constructor() {
     this._queue = [];
@@ -40,6 +49,28 @@ function handleCompressedPacket(packet) {
   // the queued (asynchronous) inflate step must be read out now
   const numPackets = packet.numPackets;
 
+  // an inline step is only in order while no earlier packet is still
+  // being inflated on the thread pool
+  if (!connection.inflateQueue._running) {
+    if (deflatedLength === 0) {
+      connection._bumpCompressedSequenceId(numPackets);
+      connection._inflatedPacketsParser.execute(body);
+      return;
+    }
+    if (deflatedLength <= MAX_SYNC_INFLATE_LENGTH) {
+      let data;
+      try {
+        data = zlib.inflateSync(body, { maxOutputLength: deflatedLength });
+      } catch (err) {
+        connection._handleNetworkError(err);
+        return;
+      }
+      connection._bumpCompressedSequenceId(numPackets);
+      connection._inflatedPacketsParser.execute(data);
+      return;
+    }
+  }
+
   if (deflatedLength !== 0) {
     connection.inflateQueue.push((task) => {
       zlib.inflate(body, { maxOutputLength: deflatedLength }, (err, data) => {
@@ -61,6 +92,31 @@ function handleCompressedPacket(packet) {
   }
 }
 
+function writeCompressedFrame(
+  connection,
+  seqId,
+  packetLen,
+  buffer,
+  compressed
+) {
+  const compressHeader = Buffer.allocUnsafe(7);
+  const compressedLength = compressed === null ? packetLen : compressed.length;
+  if (compressed === null) {
+    // http://dev.mysql.com/doc/internals/en/uncompressed-payload.html
+    // To send an uncompressed payload:
+    //   - set length of payload before compression to 0
+    //   - the compressed payload contains the uncompressed payload instead.
+    packetLen = 0;
+  }
+  compressHeader.writeUInt8(compressedLength & 0xff, 0);
+  compressHeader.writeUInt16LE(compressedLength >> 8, 1);
+  compressHeader.writeUInt8(seqId, 3);
+  compressHeader.writeUInt8(packetLen & 0xff, 4);
+  compressHeader.writeUInt16LE(packetLen >> 8, 5);
+  connection.writeUncompressed(compressHeader);
+  connection.writeUncompressed(compressed === null ? buffer : compressed);
+}
+
 function writeCompressed(buffer) {
   // http://dev.mysql.com/doc/internals/en/example-several-mysql-packets.html
   // note: sending a MySQL Packet of the size 2^24−5 to 2^24−1 via compression
@@ -82,49 +138,55 @@ function writeCompressed(buffer) {
 
   const connection = this;
 
-  let packetLen = buffer.length;
-  const compressHeader = Buffer.allocUnsafe(7);
+  const packetLen = buffer.length;
+  const seqId = connection.compressedSequenceId;
+  connection._bumpCompressedSequenceId(1);
+
+  // an inline write is only in order while no earlier packet is still
+  // being deflated on the thread pool
+  if (!connection.deflateQueue._running) {
+    if (packetLen < MIN_COMPRESS_LENGTH) {
+      writeCompressedFrame(connection, seqId, packetLen, buffer, null);
+      return;
+    }
+    if (packetLen <= MAX_SYNC_DEFLATE_LENGTH) {
+      let compressed;
+      try {
+        compressed = zlib.deflateSync(buffer);
+      } catch (err) {
+        connection._handleFatalError(err);
+        return;
+      }
+      writeCompressedFrame(
+        connection,
+        seqId,
+        packetLen,
+        buffer,
+        compressed.length < packetLen ? compressed : null
+      );
+      return;
+    }
+  }
 
   // seqqueue is used here because zlib async execution is routed via thread pool
   // internally and when we have multiple compressed packets arriving we need
   // to assemble uncompressed result sequentially
-  (function (seqId) {
-    connection.deflateQueue.push((task) => {
-      zlib.deflate(buffer, (err, compressed) => {
-        if (err) {
-          connection._handleFatalError(err);
-          return;
-        }
-        let compressedLength = compressed.length;
-
-        if (compressedLength < packetLen) {
-          compressHeader.writeUInt8(compressedLength & 0xff, 0);
-          compressHeader.writeUInt16LE(compressedLength >> 8, 1);
-          compressHeader.writeUInt8(seqId, 3);
-          compressHeader.writeUInt8(packetLen & 0xff, 4);
-          compressHeader.writeUInt16LE(packetLen >> 8, 5);
-          connection.writeUncompressed(compressHeader);
-          connection.writeUncompressed(compressed);
-        } else {
-          // http://dev.mysql.com/doc/internals/en/uncompressed-payload.html
-          // To send an uncompressed payload:
-          //   - set length of payload before compression to 0
-          //   - the compressed payload contains the uncompressed payload instead.
-          compressedLength = packetLen;
-          packetLen = 0;
-          compressHeader.writeUInt8(compressedLength & 0xff, 0);
-          compressHeader.writeUInt16LE(compressedLength >> 8, 1);
-          compressHeader.writeUInt8(seqId, 3);
-          compressHeader.writeUInt8(packetLen & 0xff, 4);
-          compressHeader.writeUInt16LE(packetLen >> 8, 5);
-          connection.writeUncompressed(compressHeader);
-          connection.writeUncompressed(buffer);
-        }
-        task.done();
-      });
+  connection.deflateQueue.push((task) => {
+    zlib.deflate(buffer, (err, compressed) => {
+      if (err) {
+        connection._handleFatalError(err);
+        return;
+      }
+      writeCompressedFrame(
+        connection,
+        seqId,
+        packetLen,
+        buffer,
+        compressed.length < packetLen ? compressed : null
+      );
+      task.done();
     });
-  })(connection.compressedSequenceId);
-  connection._bumpCompressedSequenceId(1);
+  });
 }
 
 function enableCompression(connection) {

package/lib/connection_config.js

@@ -196,6 +196,65 @@ class ConnectionConfig {
     this.gracefulEnd = options.gracefulEnd || false;
   }
 
+  // Same result as Object.assign({}, config, overrides), built from a
+  // fixed-shape literal: one allocation instead of a transition per option,
+  // and every later options read stays a monomorphic in-object load. The
+  // key list mirrors the constructor above; test/unit/connection/
+  // test-query-options.test.mts fails when the two drift apart.
+  static queryOptions(config, overrides) {
+    if (!(config instanceof ConnectionConfig)) {
+      return Object.assign({}, config, overrides);
+    }
+    const options = {
+      isServer: config.isServer,
+      stream: config.stream,
+      host: config.host,
+      port: config.port,
+      localAddress: config.localAddress,
+      socketPath: config.socketPath,
+      user: config.user,
+      password: config.password,
+      password2: config.password2,
+      password3: config.password3,
+      passwordSha1: config.passwordSha1,
+      database: config.database,
+      connectTimeout: config.connectTimeout,
+      insecureAuth: config.insecureAuth,
+      infileStreamFactory: config.infileStreamFactory,
+      supportBigNumbers: config.supportBigNumbers,
+      bigNumberStrings: config.bigNumberStrings,
+      decimalNumbers: config.decimalNumbers,
+      dateStrings: config.dateStrings,
+      debug: config.debug,
+      trace: config.trace,
+      stringifyObjects: config.stringifyObjects,
+      enableKeepAlive: config.enableKeepAlive,
+      keepAliveInitialDelay: config.keepAliveInitialDelay,
+      timezone: config.timezone,
+      queryFormat: config.queryFormat,
+      pool: config.pool,
+      ssl: config.ssl,
+      multipleStatements: config.multipleStatements,
+      rowsAsArray: config.rowsAsArray,
+      namedPlaceholders: config.namedPlaceholders,
+      nestTables: config.nestTables,
+      typeCast: config.typeCast,
+      disableEval: config.disableEval,
+      enableCleartextPlugin: config.enableCleartextPlugin,
+      maxPacketSize: config.maxPacketSize,
+      charsetNumber: config.charsetNumber,
+      compress: config.compress,
+      authPlugins: config.authPlugins,
+      authSwitchHandler: config.authSwitchHandler,
+      clientFlags: config.clientFlags,
+      connectAttributes: config.connectAttributes,
+      maxPreparedStatements: config.maxPreparedStatements,
+      jsonStrings: config.jsonStrings,
+      gracefulEnd: config.gracefulEnd,
+    };
+    return Object.assign(options, overrides);
+  }
+
   static mergeFlags(default_flags, user_flags) {
     let flags = 0x0,
       i;

package/lib/packets/column_definition.js

@@ -52,7 +52,7 @@ class ColumnDefinition {
     packet.skip(1); //  length of the following fields (always 0x0c)
     this.characterSet = packet.readInt16();
     this.encoding = CharsetToEncoding[this.characterSet];
-    this.name = StringParser.decode(
+    this.name = StringParser.decodeShort(
       this._buf,
       this.encoding === 'binary' ? this._clientEncoding : this.encoding,
       _nameStart,

package/lib/packets/packet.js

@@ -9,6 +9,7 @@ const ErrorCodeToName = require('../constants/errors.js');
 const NativeBuffer = require('buffer').Buffer;
 const Long = require('long');
 const StringParser = require('../parsers/string.js');
+const { localDate } = require('../parsers/local_date.js');
 const Types = require('../constants/types.js');
 const ZERO_DATE = '0000-00-00';
 
@@ -335,7 +336,7 @@ class Packet {
       if (timezone === 'Z') {
         return new Date(Date.UTC(y, m - 1, d, H, M, S, ms));
       }
-      return new Date(y, m - 1, d, H, M, S, ms);
+      return localDate(y, m, d, H, M, S, ms);
     }
     let str = this.readDateTimeString(6, 'T', null);
     if (str.startsWith(ZERO_DATE)) {
@@ -441,6 +442,14 @@ class Packet {
     this.offset += len;
     // TODO: Use characterSetCode to get proper encoding
     // https://github.com/sidorares/node-mysql2/pull/374
+    if (len <= StringParser.SHORT_STRING_MAX_LENGTH) {
+      return StringParser.decodeShort(
+        this.buffer,
+        encoding,
+        this.offset - len,
+        this.offset
+      );
+    }
     return StringParser.decode(
       this.buffer,
       encoding,
@@ -735,7 +744,7 @@ class Packet {
     this.offset++; // -
     const d = this.parseInt(2);
     if (!timezone || timezone === 'local') {
-      return new Date(y, m - 1, d);
+      return localDate(y, m, d, 0, 0, 0, 0);
     }
     if (timezone === 'Z') {
       return new Date(Date.UTC(y, m - 1, d));
@@ -797,7 +806,7 @@ class Packet {
       }
       this.offset += len;
       if (!timezone || timezone === 'local') {
-        return new Date(y, mo - 1, d, h, mi, se, ms);
+        return localDate(y, mo, d, h, mi, se, ms);
       }
       const utc = Date.UTC(y, mo - 1, d, h, mi, se, ms);
       if (timezone === 'Z') {

package/lib/parsers/binary_parser.js

@@ -6,6 +6,7 @@ const Types = require('../constants/types.js');
 const helpers = require('../helpers');
 const genFunc = require('generate-function');
 const parserCache = require('./parser_cache.js');
+const LocalDate = require('./local_date.js');
 const typeNames = [];
 for (const t in Types) {
   typeNames[Types[t]] = t;
@@ -173,6 +174,9 @@ function compile(fields, options, config) {
   parserFn('(function(){');
   parserFn('return class BinaryRow {');
   parserFn('constructor() {');
+  if (fields.some((field) => LocalDate.usesLocalDate(field, options, config))) {
+    parserFn('LocalDate.checkTimezone();');
+  }
   parserFn('}');
 
   parserFn('next(packet, fields, options) {');
@@ -264,7 +268,7 @@ function compile(fields, options, config) {
       parserFn.toString()
     );
   }
-  return parserFn.toFunction({ wrap, wrapNull });
+  return parserFn.toFunction({ wrap, wrapNull, LocalDate });
 }
 
 function getBinaryParser(fields, options, config) {

package/lib/parsers/local_date.js

@@ -0,0 +1,158 @@
+'use strict';
+
+const Types = require('../constants/types.js');
+const helpers = require('../helpers.js');
+
+// new Date(y, m, d, h, mi, s, ms) interprets its arguments as local wall
+// time; the wall-time to UTC conversion inside that constructor dominates
+// the cost of materializing a DATE, DATETIME or TIMESTAMP value. The
+// conversion depends only on the wall-clock instant, and the offset it
+// applies is constant across almost every hour (it changes only at DST
+// transitions), so the offset is cached per wall-clock hour once the real
+// constructor has confirmed it holds over the whole hour. Hours where it
+// does not hold keep using the constructor.
+
+const MS_PER_HOUR = 3600000;
+const MS_PER_DAY = 86400000;
+const MAX_CACHED_HOURS = 4096;
+
+const hourOffsets = new Map();
+let lastTimezone = readTimezone();
+
+function readTimezone() {
+  try {
+    return process.env.TZ;
+  } catch {
+    return undefined;
+  }
+}
+
+// Node resets its own time zone cache when process.env.TZ is assigned;
+// called once per result set so the offsets cached here follow suit
+function checkTimezone() {
+  const timezone = readTimezone();
+  if (timezone !== lastTimezone) {
+    lastTimezone = timezone;
+    hourOffsets.clear();
+  }
+}
+
+// days since 1970-01-01 in the proleptic Gregorian calendar, the same value
+// ECMAScript's MakeDay produces for a month in 1..12 and any integer day
+function daysFromCivil(year, month, day) {
+  const y = month <= 2 ? year - 1 : year;
+  const era = Math.floor(y / 400);
+  const yearOfEra = y - era * 400;
+  const dayOfYear = (((153 * ((month + 9) % 12) + 2) / 5) | 0) + day - 1;
+  const dayOfEra =
+    yearOfEra * 365 +
+    ((yearOfEra / 4) | 0) -
+    ((yearOfEra / 100) | 0) +
+    dayOfYear;
+  return era * 146097 + dayOfEra - 719468;
+}
+
+function localTime(wallTime) {
+  const wall = new Date(wallTime);
+  return new Date(
+    wall.getUTCFullYear(),
+    wall.getUTCMonth(),
+    wall.getUTCDate(),
+    wall.getUTCHours(),
+    wall.getUTCMinutes(),
+    wall.getUTCSeconds(),
+    wall.getUTCMilliseconds()
+  ).getTime();
+}
+
+// the offset is trusted for the hour only when the constructor applies the
+// same one at its start, middle and end; null marks an hour that contains a
+// transition
+function proveHourOffset(hour) {
+  const start = hour * MS_PER_HOUR;
+  const offset = start - localTime(start);
+  if (
+    offset !== start + MS_PER_HOUR / 2 - localTime(start + MS_PER_HOUR / 2) ||
+    offset !== start + MS_PER_HOUR - 1 - localTime(start + MS_PER_HOUR - 1) ||
+    Number.isNaN(offset)
+  ) {
+    return null;
+  }
+  return offset;
+}
+
+// same value as new Date(year, month - 1, day, hours, minutes, seconds,
+// milliseconds), for the integer arguments the wire protocols carry
+function localDate(year, month, day, hours, minutes, seconds, milliseconds) {
+  if (year < 100 || month < 1 || month > 12) {
+    return new Date(
+      year,
+      month - 1,
+      day,
+      hours,
+      minutes,
+      seconds,
+      milliseconds
+    );
+  }
+  const wallTime =
+    daysFromCivil(year, month, day) * MS_PER_DAY +
+    hours * MS_PER_HOUR +
+    minutes * 60000 +
+    seconds * 1000 +
+    Math.trunc(milliseconds);
+  const hour = Math.floor(wallTime / MS_PER_HOUR);
+  let offset = hourOffsets.get(hour);
+  if (offset === undefined) {
+    if (hourOffsets.size >= MAX_CACHED_HOURS) {
+      hourOffsets.clear();
+    }
+    offset = proveHourOffset(hour);
+    hourOffsets.set(hour, offset);
+  }
+  if (offset === null) {
+    return new Date(
+      year,
+      month - 1,
+      day,
+      hours,
+      minutes,
+      seconds,
+      milliseconds
+    );
+  }
+  return new Date(wallTime - offset);
+}
+
+// whether a column's values are built through localDate, so the parser
+// for a result set knows to call checkTimezone first
+function usesLocalDate(field, options, config) {
+  const timezone = options.timezone || config.timezone;
+  if (timezone && timezone !== 'local') {
+    return false;
+  }
+  const type = field.columnType;
+  if (
+    type !== Types.DATE &&
+    type !== Types.DATETIME &&
+    type !== Types.TIMESTAMP &&
+    type !== Types.NEWDATE
+  ) {
+    return false;
+  }
+  return !helpers.typeMatch(
+    type,
+    options.dateStrings || config.dateStrings,
+    Types
+  );
+}
+
+module.exports = {
+  localDate,
+  checkTimezone,
+  usesLocalDate,
+  _daysFromCivil: daysFromCivil,
+  _clear() {
+    hourOffsets.clear();
+  },
+};

package/lib/parsers/parser_cache.js

@@ -6,58 +6,223 @@ const parserCache = createLRU({
   max: 15000,
 });
 
-// the fixed-size options head keeps JSON.stringify (cheap for a flat array,
-// and it normalizes exotic values the same way as before); the per-field part
-// is built by hand with length-prefixed strings, so no delimiter collision is
-// possible and no throwaway nested arrays are allocated per query
-function appendString(key, value) {
-  if (value === undefined || value === null) {
-    return `${key}u/`;
+// A compiled row parser depends on the parsing options and, per column, on
+// exactly the metadata the code generators bake into the function: type,
+// charset, flags, decimals, name, MariaDB extended metadata, and the table
+// name when rows are nested by table. The cache is keyed by an integer hash
+// of that data and every hit is confirmed against the full metadata kept in
+// the entry, so a hash collision can never hand out a parser compiled for
+// different columns or options.
+
+const TYPE_CAST_FALSE = 1;
+const TYPE_CAST_FUNCTION = 2;
+const TYPE_CAST_DEFAULT = 3;
+
+function typeCastKind(typeCast) {
+  if (typeCast === false) {
+    return TYPE_CAST_FALSE;
+  }
+  if (typeof typeCast === 'function') {
+    return TYPE_CAST_FUNCTION;
+  }
+  return TYPE_CAST_DEFAULT;
+}
+
+// helpers.typeMatch reads an array by the type names it lists and anything
+// else by truthiness
+function dateStringsKey(dateStrings) {
+  if (Array.isArray(dateStrings)) {
+    return dateStrings.map(String);
+  }
+  return Boolean(dateStrings);
+}
+
+function nestTablesKey(nestTables) {
+  if (typeof nestTables === 'string') {
+    return nestTables;
   }
-  return `${key}${value.length}#${value}/`;
+  return Boolean(nestTables);
 }
 
-function keyFromFields(type, fields, options, config) {
-  let key = JSON.stringify([
-    type,
-    typeof options.nestTables,
-    options.nestTables,
-    Boolean(options.rowsAsArray),
-    Boolean(options.supportBigNumbers || config.supportBigNumbers),
-    Boolean(options.bigNumberStrings || config.bigNumberStrings),
-    typeof options.typeCast === 'boolean'
-      ? options.typeCast
-      : typeof options.typeCast,
-    options.timezone || config.timezone,
-    Boolean(options.decimalNumbers),
-    options.dateStrings,
-    Boolean(config.jsonStrings),
-  ]);
+function optionBits(type, options, config, nestTables, dateStrings) {
+  return (
+    (type === 'binary' ? 1 : 0) |
+    (options.rowsAsArray ? 2 : 0) |
+    (options.supportBigNumbers || config.supportBigNumbers ? 4 : 0) |
+    (options.bigNumberStrings || config.bigNumberStrings ? 8 : 0) |
+    (typeCastKind(options.typeCast) << 4) |
+    (options.decimalNumbers ? 64 : 0) |
+    (config.jsonStrings ? 128 : 0) |
+    (nestTables === true ? 256 : 0) |
+    (typeof nestTables === 'string' ? 512 : 0) |
+    (dateStrings === true ? 1024 : 0) |
+    (Array.isArray(dateStrings) ? 2048 : 0)
+  );
+}
 
+function mixNumber(hash, value) {
+  return Math.imul(hash ^ (value | 0), 0x9e3779b1) | 0;
+}
+
+function mixString(hash, string) {
+  if (typeof string !== 'string') {
+    return mixNumber(hash, string === undefined ? -1 : -2);
+  }
+  hash = mixNumber(hash, string.length);
+  for (let i = 0; i < string.length; ++i) {
+    hash = (Math.imul(hash, 31) + string.charCodeAt(i)) | 0;
+  }
+  return hash;
+}
+
+function hashKey(type, fields, options, config) {
+  const nestTables = nestTablesKey(options.nestTables);
+  const dateStrings = dateStringsKey(options.dateStrings || config.dateStrings);
+  const includeTable = nestTables !== false;
+  let hash = mixNumber(
+    0x811c9dc5,
+    optionBits(type, options, config, nestTables, dateStrings)
+  );
+  hash = mixString(hash, String(options.timezone || config.timezone));
+  if (typeof nestTables === 'string') {
+    hash = mixString(hash, nestTables);
+  }
+  if (Array.isArray(dateStrings)) {
+    for (let i = 0; i < dateStrings.length; ++i) {
+      hash = mixString(hash, dateStrings[i]);
+    }
+  }
+  hash = mixNumber(hash, fields.length);
   for (let i = 0; i < fields.length; ++i) {
     const field = fields[i];
-    key = appendString(key, field.name);
-    key += `${field.columnType}/${field.length}/`;
-    key = appendString(key, field.schema);
-    key = appendString(key, field.table);
-    key += `${field.flags}/${field.characterSet}/`;
-    key = appendString(key, field.extendedTypeName);
-    key = appendString(key, field.extendedFormat);
+    hash = mixNumber(
+      hash,
+      field.columnType | (field.characterSet << 8) | (field.decimals << 24)
+    );
+    hash = mixNumber(hash, field.flags);
+    hash = mixString(hash, field.name);
+    if (field.extendedTypeName !== undefined) {
+      hash = mixString(hash, field.extendedTypeName);
+    }
+    if (field.extendedFormat !== undefined) {
+      hash = mixString(hash, field.extendedFormat);
+    }
+    if (includeTable) {
+      hash = mixString(hash, field.table);
+    }
   }
+  // small non-negative integers keep the Map keys as Smis
+  return hash & 0x3fffffff;
+}
 
-  return key;
+function sameList(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; ++i) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
 }
 
-function getParser(type, fields, options, config, compiler) {
-  const key = keyFromFields(type, fields, options, config);
-  let parser = parserCache.get(key);
+class Entry {
+  constructor(parser, type, fields, options, config) {
+    this.parser = parser;
+    this.nestTables = nestTablesKey(options.nestTables);
+    this.dateStrings = dateStringsKey(
+      options.dateStrings || config.dateStrings
+    );
+    this.optionBits = optionBits(
+      type,
+      options,
+      config,
+      this.nestTables,
+      this.dateStrings
+    );
+    this.timezone = String(options.timezone || config.timezone);
+    const count = fields.length;
+    this.columnTypes = new Array(count);
+    this.characterSets = new Array(count);
+    this.flags = new Array(count);
+    this.decimals = new Array(count);
+    this.names = new Array(count);
+    this.extendedTypeNames = new Array(count);
+    this.extendedFormats = new Array(count);
+    this.tables = this.nestTables === false ? null : new Array(count);
+    for (let i = 0; i < count; ++i) {
+      const field = fields[i];
+      this.columnTypes[i] = field.columnType;
+      this.characterSets[i] = field.characterSet;
+      this.flags[i] = field.flags;
+      this.decimals[i] = field.decimals;
+      this.names[i] = field.name;
+      this.extendedTypeNames[i] = field.extendedTypeName;
+      this.extendedFormats[i] = field.extendedFormat;
+      if (this.tables !== null) {
+        this.tables[i] = field.table;
+      }
+    }
+  }
 
-  if (parser) {
-    return parser;
+  matches(type, fields, options, config) {
+    const nestTables = nestTablesKey(options.nestTables);
+    const dateStrings = dateStringsKey(
+      options.dateStrings || config.dateStrings
+    );
+    if (
+      this.optionBits !==
+        optionBits(type, options, config, nestTables, dateStrings) ||
+      this.nestTables !== nestTables ||
+      this.timezone !== String(options.timezone || config.timezone) ||
+      this.names.length !== fields.length
+    ) {
+      return false;
+    }
+    // equal option bits already guarantee both sides are lists (or the
+    // same boolean), so only the list contents are left to compare
+    if (
+      Array.isArray(dateStrings) &&
+      !sameList(this.dateStrings, dateStrings)
+    ) {
+      return false;
+    }
+    for (let i = 0; i < fields.length; ++i) {
+      const field = fields[i];
+      if (
+        this.columnTypes[i] !== field.columnType ||
+        this.characterSets[i] !== field.characterSet ||
+        this.flags[i] !== field.flags ||
+        this.decimals[i] !== field.decimals ||
+        this.names[i] !== field.name ||
+        this.extendedTypeNames[i] !== field.extendedTypeName ||
+        this.extendedFormats[i] !== field.extendedFormat ||
+        (this.tables !== null && this.tables[i] !== field.table)
+      ) {
+        return false;
+      }
+    }
+    return true;
   }
+}
 
-  parser = compiler(fields, options, config);
-  parserCache.set(key, parser);
+function getParser(type, fields, options, config, compiler) {
+  const hash = hashKey(type, fields, options, config);
+  let entries = parserCache.get(hash);
+  if (entries !== undefined) {
+    for (let i = 0; i < entries.length; ++i) {
+      if (entries[i].matches(type, fields, options, config)) {
+        return entries[i].parser;
+      }
+    }
+  }
+  const parser = compiler(fields, options, config);
+  if (entries === undefined) {
+    entries = [];
+    parserCache.set(hash, entries);
+  }
+  entries.push(new Entry(parser, type, fields, options, config));
   return parser;
 }
 
@@ -73,5 +238,6 @@ module.exports = {
   getParser: getParser,
   setMaxCache: setMaxCache,
   clearCache: clearCache,
-  _keyFromFields: keyFromFields,
+  _hashKey: hashKey,
+  _Entry: Entry,
 };

package/lib/parsers/static_binary_parser.js

@@ -4,13 +4,19 @@ const FieldFlags = require('../constants/field_flags.js');
 const Charsets = require('../constants/charsets.js');
 const Types = require('../constants/types.js');
 const helpers = require('../helpers');
+const LocalDate = require('./local_date.js');
 
 const typeNames = [];
 for (const t in Types) {
   typeNames[Types[t]] = t;
 }
 
-function getBinaryParser(fields, _options, config) {
+function getBinaryParser(fields, queryOptions, config) {
+  if (
+    fields.some((field) => LocalDate.usesLocalDate(field, queryOptions, config))
+  ) {
+    LocalDate.checkTimezone();
+  }
   function readCode(field, config, options, fieldNum, packet) {
     const supportBigNumbers = Boolean(
       options.supportBigNumbers || config.supportBigNumbers

package/lib/parsers/static_text_parser.js

@@ -3,6 +3,7 @@
 const Types = require('../constants/types.js');
 const Charsets = require('../constants/charsets.js');
 const helpers = require('../helpers');
+const LocalDate = require('./local_date.js');
 
 const typeNames = [];
 for (const t in Types) {
@@ -118,7 +119,10 @@ function createTypecastField(field, packet) {
   };
 }
 
-function getTextParser(_fields, _options, config) {
+function getTextParser(fields, options, config) {
+  if (fields.some((field) => LocalDate.usesLocalDate(field, options, config))) {
+    LocalDate.checkTimezone();
+  }
   return {
     next(packet, fields, options) {
       const result = options.rowsAsArray ? [] : {};

package/lib/parsers/string.js

@@ -19,6 +19,120 @@ const hasFastSlices =
 // buffer.write(); same stability story as the slice methods above
 exports.hasFastUtf8Write = typeof Buffer.prototype.utf8Write === 'function';
 
+// A native slice costs a fixed ~50ns per call, mostly the JS to C++
+// transition, while String.fromCharCode with a handful of arguments stays
+// inside V8 at a fraction of that. Every ASCII byte decodes to the same
+// code unit under utf8, ascii and latin1, so short all-ASCII values skip
+// the transition; anything else returns null and takes the native path.
+function shortAscii(b, s, length) {
+  if (b[s] >= 128) {
+    return null;
+  }
+  switch (length) {
+    case 1: {
+      const c0 = b[s];
+      return c0 < 128 ? String.fromCharCode(c0) : null;
+    }
+    case 2: {
+      const c0 = b[s];
+      const c1 = b[s + 1];
+      return (c0 | c1) < 128 ? String.fromCharCode(c0, c1) : null;
+    }
+    case 3: {
+      const c0 = b[s];
+      const c1 = b[s + 1];
+      const c2 = b[s + 2];
+      return (c0 | c1 | c2) < 128 ? String.fromCharCode(c0, c1, c2) : null;
+    }
+    case 4: {
+      const c0 = b[s];
+      const c1 = b[s + 1];
+      const c2 = b[s + 2];
+      const c3 = b[s + 3];
+      return (c0 | c1 | c2 | c3) < 128
+        ? String.fromCharCode(c0, c1, c2, c3)
+        : null;
+    }
+    case 5: {
+      const c0 = b[s];
+      const c1 = b[s + 1];
+      const c2 = b[s + 2];
+      const c3 = b[s + 3];
+      const c4 = b[s + 4];
+      return (c0 | c1 | c2 | c3 | c4) < 128
+        ? String.fromCharCode(c0, c1, c2, c3, c4)
+        : null;
+    }
+    case 6: {
+      const c0 = b[s];
+      const c1 = b[s + 1];
+      const c2 = b[s + 2];
+      const c3 = b[s + 3];
+      const c4 = b[s + 4];
+      const c5 = b[s + 5];
+      return (c0 | c1 | c2 | c3 | c4 | c5) < 128
+        ? String.fromCharCode(c0, c1, c2, c3, c4, c5)
+        : null;
+    }
+    case 7: {
+      const c0 = b[s];
+      const c1 = b[s + 1];
+      const c2 = b[s + 2];
+      const c3 = b[s + 3];
+      const c4 = b[s + 4];
+      const c5 = b[s + 5];
+      const c6 = b[s + 6];
+      return (c0 | c1 | c2 | c3 | c4 | c5 | c6) < 128
+        ? String.fromCharCode(c0, c1, c2, c3, c4, c5, c6)
+        : null;
+    }
+    case 8: {
+      const c0 = b[s];
+      const c1 = b[s + 1];
+      const c2 = b[s + 2];
+      const c3 = b[s + 3];
+      const c4 = b[s + 4];
+      const c5 = b[s + 5];
+      const c6 = b[s + 6];
+      const c7 = b[s + 7];
+      return (c0 | c1 | c2 | c3 | c4 | c5 | c6 | c7) < 128
+        ? String.fromCharCode(c0, c1, c2, c3, c4, c5, c6, c7)
+        : null;
+    }
+    default:
+      return null;
+  }
+}
+
+exports.SHORT_STRING_MAX_LENGTH = 8;
+
+// decode() for values of at most SHORT_STRING_MAX_LENGTH bytes, with the
+// ASCII shortcut in front of the native slice; kept apart from decode() so
+// the long-value path stays as small and inlinable as before
+exports.decodeShort = function (buffer, encoding, start, end) {
+  if (hasFastSlices && start >= 0 && start <= end && end <= buffer.length) {
+    switch (encoding) {
+      case 'utf8':
+      case 'utf-8': {
+        const short = shortAscii(buffer, start, end - start);
+        return short !== null ? short : buffer.utf8Slice(start, end);
+      }
+      case 'latin1':
+      case 'binary': {
+        const short = shortAscii(buffer, start, end - start);
+        return short !== null ? short : buffer.latin1Slice(start, end);
+      }
+      case 'ascii': {
+        const short = shortAscii(buffer, start, end - start);
+        return short !== null ? short : buffer.asciiSlice(start, end);
+      }
+      default:
+        break;
+    }
+  }
+  return exports.decode(buffer, encoding, start, end);
+};
+
 exports.decode = function (buffer, encoding, start, end, options) {
   if (hasFastSlices) {
     // replicate buffer.toString() bounds coercion exactly (the *Slice

package/lib/parsers/text_parser.js

@@ -5,6 +5,7 @@ const Charsets = require('../constants/charsets.js');
 const helpers = require('../helpers');
 const genFunc = require('generate-function');
 const parserCache = require('./parser_cache.js');
+const LocalDate = require('./local_date.js');
 
 const typeNames = [];
 for (const t in Types) {
@@ -139,6 +140,9 @@ function compile(fields, options, config) {
     parserFn('this[`wrap${i}`] = wrap(fields[i], _this);');
     parserFn('}');
   }
+  if (fields.some((field) => LocalDate.usesLocalDate(field, options, config))) {
+    parserFn('LocalDate.checkTimezone();');
+  }
   parserFn('}');
 
   // next method
@@ -207,10 +211,7 @@ function compile(fields, options, config) {
       parserFn.toString()
     );
   }
-  if (typeof options.typeCast === 'function') {
-    return parserFn.toFunction({ wrap });
-  }
-  return parserFn.toFunction();
+  return parserFn.toFunction({ wrap, LocalDate });
 }
 
 function getTextParser(fields, options, config) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mysql2",
-  "version": "3.24.4-canary.9178c82",
+  "version": "3.24.4",
   "description": "fast mysql driver. Implements core protocol, prepared statements, ssl and compression in native JS",
   "main": "index.js",
   "typings": "typings/mysql/index",
@@ -20,6 +20,11 @@
     "test:coverage": "c8 npm test",
     "test:build": "rollup -c",
     "typecheck": "cd \"test/tsc-build\" && tsc -p \"tsconfig.json\" && cd .. && tsc -p \"tsconfig.json\" --noEmit",
+    "src:typecheck": "tsc -p src/tsconfig.json --noEmit && tsc -p tools/src/tsconfig.json",
+    "src:build": "tsx tools/src/clean.mts && tsc -p src/tsconfig.json",
+    "src:test": "npm run src:build && tsx tools/src/prepare-tests.mts && poku --config=tools/src/poku.config.mts",
+    "src:test:bun": "npm run src:build && tsx tools/src/prepare-tests.mts && bun poku --config=tools/src/poku.config.mts",
+    "src:test:deno": "npm run src:build && tsx tools/src/prepare-tests.mts && deno run -A npm:poku --config=tools/src/poku.config.mts",
     "benchmark": "node ./benchmarks/benchmark.js",
     "wait-port": "wait-on"
   },